Merge commit 'b439c992c23f3e0f3832fffd2a34a664b236c525'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 10 Apr 2013 10:41:06 +0000 (12:41 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 10 Apr 2013 10:41:06 +0000 (12:41 +0200)
* commit 'b439c992c23f3e0f3832fffd2a34a664b236c525':
  lavfi: switch to an AVOptions-based system.
  dfa: implement missing TDLT coding method

Conflicts:
libavcodec/dfa.c
libavfilter/avfilter.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
doc/filters.texi
libavcodec/dfa.c
libavfilter/avfilter.c
libavfilter/avfilter.h
libavfilter/version.h

Simple merge
index 4c77f4e2733ff68f668bd822fa9cdee698597378,2828af6e56b266ff02a63712d40f3b66a8a5f9ff..32459098a7f8916452a224f3dfe2967e8b17fcd1
@@@ -291,18 -287,20 +291,20 @@@ static int decode_wdlt(GetByteContext *
  static int decode_tdlt(GetByteContext *gb, uint8_t *frame, int width, int height)
  {
      const uint8_t *frame_end = frame + width * height;
 -    int segments = bytestream2_get_le32(gb);
 +    uint32_t segments = bytestream2_get_le32(gb);
+     int skip, copy;
  
      while (segments--) {
-         int count = bytestream2_get_byte(gb) << 1;
-         int skip = bytestream2_get_byte(gb) << 1;
-         if (frame_end - frame < skip + count)
+         if (bytestream2_get_bytes_left(gb) < 2)
              return AVERROR_INVALIDDATA;
-         frame += skip;
-         if (bytestream2_get_buffer(gb, frame, count) != count)
+         copy = bytestream2_get_byteu(gb) * 2;
+         skip = bytestream2_get_byteu(gb) * 2;
+         if (frame_end - frame < copy + skip ||
+             bytestream2_get_bytes_left(gb) < copy)
              return AVERROR_INVALIDDATA;
-         frame += count;
+         frame += skip;
+         bytestream2_get_buffer(gb, frame, copy);
+         frame += copy;
      }
  
      return 0;
index b689fbe9d4b9ca51e43c2c902ca2d99f8b17a5a9,93d1855ce36bd7372d0b71d35633a10e8ea95e78..0b6a65266f145988c69189f371a3d9c74de2d2d9
@@@ -562,13 -399,8 +567,11 @@@ void avfilter_free(AVFilterContext *fil
      int i;
      AVFilterLink *link;
  
 +    if (!filter)
 +        return;
 +
      if (filter->filter->uninit)
          filter->filter->uninit(filter);
-     if (filter->filter->shorthand)
-         av_opt_free(filter->priv);
  
      for (i = 0; i < filter->nb_inputs; i++) {
          if ((link = filter->inputs[i])) {
              ff_channel_layouts_unref(&link->in_channel_layouts);
              ff_channel_layouts_unref(&link->out_channel_layouts);
          }
 -        av_freep(&link);
 +        avfilter_link_free(&link);
      }
  
 -    if (filter->filter->priv_class)
++    if (filter->filter->priv_class || filter->filter->shorthand)
+         av_opt_free(filter->priv);
      av_freep(&filter->name);
      av_freep(&filter->input_pads);
      av_freep(&filter->output_pads);
      av_free(filter);
  }
  
+ /* process a list of value1:value2:..., each value corresponding
+  * to subsequent AVOption, in the order they are declared */
+ static int process_unnamed_options(AVFilterContext *ctx, AVDictionary **options,
+                                    const char *args)
+ {
+     const AVOption *o = NULL;
+     const char *p = args;
+     char *val;
+     while (*p) {
+         o = av_opt_next(ctx->priv, o);
+         if (!o) {
+             av_log(ctx, AV_LOG_ERROR, "More options provided than "
+                    "this filter supports.\n");
+             return AVERROR(EINVAL);
+         }
+         if (o->type == AV_OPT_TYPE_CONST)
+             continue;
+         val = av_get_token(&p, ":");
+         if (!val)
+             return AVERROR(ENOMEM);
+         av_dict_set(options, o->name, val, 0);
+         av_freep(&val);
+         if (*p)
+             p++;
+     }
+     return 0;
+ }
  int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque)
  {
+     AVDictionary *options = NULL;
+     AVDictionaryEntry *e;
      int ret=0;
-     if (filter->filter->init_opaque)
-         ret = filter->filter->init_opaque(filter, args, opaque);
-     else if (filter->filter->init)
-         ret = filter->filter->init(filter, args);
++    int anton_options = 0;
 +
 +    if (filter->filter->shorthand) {
 +        av_assert0(filter->priv);
 +        av_assert0(filter->filter->priv_class);
 +        *(const AVClass **)filter->priv = filter->filter->priv_class;
 +        av_opt_set_defaults(filter->priv);
 +        ret = av_opt_set_from_string(filter->priv, args,
 +                                     filter->filter->shorthand, "=", ":");
 +        if (ret < 0)
 +            return ret;
 +        args = NULL;
 +    }
 -    if (args && *args && filter->filter->priv_class) {
 -    if (filter->filter->priv_class) {
++    if (anton_options && args && *args && filter->filter->priv_class) {
+         if (strchr(args, '=')) {
+             /* assume a list of key1=value1:key2=value2:... */
+             ret = av_dict_parse_string(&options, args, "=", ":", 0);
+             if (ret < 0)
+                 goto fail;
+         } else {
+             ret = process_unnamed_options(filter, &options, args);
+             if (ret < 0)
+                 goto fail;
+         }
+     }
 -    if (filter->filter->init) {
 -        ret = filter->filter->init(filter, args);
++    if (anton_options && filter->filter->priv_class) {
+         ret = av_opt_set_dict(filter->priv, &options);
+         if (ret < 0) {
+             av_log(filter, AV_LOG_ERROR, "Error applying options to the filter.\n");
+             goto fail;
+         }
+     }
++    if (filter->filter->init || filter->filter->init_opaque) {
++        if (filter->filter->init_opaque)
++            ret = filter->filter->init_opaque(filter, args, opaque);
++        else
++            ret = filter->filter->init(filter, args);
+         if (ret < 0)
+             goto fail;
+     }
+     if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
+         av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
+         ret = AVERROR_OPTION_NOT_FOUND;
+         goto fail;
+     }
+ fail:
+     av_dict_free(&options);
      return ret;
  }
  
index 7583dccfbe2f2db496db8c50666524f2c6a2c535,66f57df150bd3ad5754682827255e49a627099f4..282d4dfb5156229e8dccc233aad06aaeccf376bd
@@@ -463,38 -426,6 +469,36 @@@ typedef struct AVFilter 
      int (*query_formats)(AVFilterContext *);
  
      int priv_size;      ///< size of private data to allocate for the filter
-     const AVClass *priv_class;      ///< private class, containing filter specific options
 +
 +    /**
 +     * Make the filter instance process a command.
 +     *
 +     * @param cmd    the command to process, for handling simplicity all commands must be alphanumeric only
 +     * @param arg    the argument for the command
 +     * @param res    a buffer with size res_size where the filter(s) can return a response. This must not change when the command is not supported.
 +     * @param flags  if AVFILTER_CMD_FLAG_FAST is set and the command would be
 +     *               time consuming then a filter should treat it like an unsupported command
 +     *
 +     * @returns >=0 on success otherwise an error code.
 +     *          AVERROR(ENOSYS) on unsupported commands
 +     */
 +    int (*process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags);
 +
 +    /**
 +     * Filter initialization function, alternative to the init()
 +     * callback. Args contains the user-supplied parameters, opaque is
 +     * used for providing binary data.
 +     */
 +    int (*init_opaque)(AVFilterContext *ctx, const char *args, void *opaque);
 +
 +    /**
 +     * Shorthand syntax for init arguments.
 +     * If this field is set (even to an empty list), just before init the
 +     * private class will be set and the arguments string will be parsed
 +     * using av_opt_set_from_string() with "=" and ":" delimiters, and
 +     * av_opt_free() will be called just after uninit.
 +     */
 +    const char *const *shorthand;
  } AVFilter;
  
  /** An instance of a filter */
Simple merge