Merge remote-tracking branch 'qatar/master'

* qatar/master: (31 commits)
  tiffenc: initialize forgotten avctx.
  avplay: free the active audio packet at exit.
  avplay: free rdft data used for spectrogram analysis.
  log.h: make AVClass a named struct
  fix ac3 encoder documentation
  vc1: more prettyprinting cosmetics
  vc1: prettyprint some tables
  vc1: K&R formatting cosmetics
  AVOptions: bump minor and add APIchanges entry.
  cmdutils/avtools: simplify show_help() by using av_opt_child_class_next()
  AVOptions: rename FF_OPT_TYPE_* => AV_OPT_TYPE_*
  Remove all uses of deprecated AVOptions API.
  AVOptions: add av_opt_next, deprecate av_next_option.
  AVOptions: add functions for evaluating option strings.
  AVOptions: split get_number().
  AVOptions: add av_opt_get*, deprecate av_get*.
  AVOptions: add av_opt_set*().
  AVOptions: add new API for enumerating children.
  rv34: move inverse transform functions to DSP context
  flvenc: Write the right metadata entry count
  ...

Conflicts:
	avconv.c
	cmdutils.c
	doc/APIchanges
	ffplay.c
	ffprobe.c
	libavcodec/ac3dec.c
	libavcodec/h264.c
	libavcodec/libvpxenc.c
	libavcodec/libx264.c
	libavcodec/mpeg12enc.c
	libavcodec/options.c
	libavdevice/libdc1394.c
	libavdevice/v4l2.c
	libavfilter/vf_drawtext.c
	libavformat/flvdec.c
	libavformat/mpegtsenc.c
	libavformat/options.c
	libavutil/avutil.h
	libavutil/opt.c
	libswscale/utils.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>

1 files changed, 316 insertions, 121 deletions

diff --git a/libavutil/opt.c b/libavutil/opt.c
index c425cfefbd..7fe272dd9d 100644
--- a/libavutil/opt.c
+++ b/libavutil/opt.c
@@ -46,13 +46,35 @@ const AVOption *av_find_opt(void *v, const char *name, const char *unit, int mas
 }
 #endif
 
+#if FF_API_OLD_AVOPTIONS
 const AVOption *av_next_option(void *obj, const AVOption *last)
 {
+    return av_opt_next(obj, last);
+}
+#endif
+
+const AVOption *av_opt_next(void *obj, const AVOption *last)
+{
     if (last && last[1].name) return ++last;
     else if (last || !(*(AVClass**)obj)->option->name) return NULL;
     else                      return (*(AVClass**)obj)->option;
 }
 
+static int read_number(const AVOption *o, void *dst, double *num, int *den, int64_t *intnum)
+{
+    switch (o->type) {
+    case AV_OPT_TYPE_FLAGS:     *intnum = *(unsigned int*)dst;return 0;
+    case AV_OPT_TYPE_INT:       *intnum = *(int         *)dst;return 0;
+    case AV_OPT_TYPE_INT64:     *intnum = *(int64_t     *)dst;return 0;
+    case AV_OPT_TYPE_FLOAT:     *num    = *(float       *)dst;return 0;
+    case AV_OPT_TYPE_DOUBLE:    *num    = *(double      *)dst;return 0;
+    case AV_OPT_TYPE_RATIONAL:  *intnum = ((AVRational*)dst)->num;
+                                *den    = ((AVRational*)dst)->den;
+                                                        return 0;
+    }
+    return AVERROR(EINVAL);
+}
+
 static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
 {
     if (o->max*den < num*intnum || o->min*den > num*intnum) {
@@ -61,12 +83,12 @@ static int write_number(void *obj, const AVOption *o, void *dst, double num, int
     }
 
     switch (o->type) {
-    case FF_OPT_TYPE_FLAGS:
-    case FF_OPT_TYPE_INT:   *(int       *)dst= llrint(num/den)*intnum; break;
-    case FF_OPT_TYPE_INT64: *(int64_t   *)dst= llrint(num/den)*intnum; break;
-    case FF_OPT_TYPE_FLOAT: *(float     *)dst= num*intnum/den;         break;
-    case FF_OPT_TYPE_DOUBLE:*(double    *)dst= num*intnum/den;         break;
-    case FF_OPT_TYPE_RATIONAL:
+    case AV_OPT_TYPE_FLAGS:
+    case AV_OPT_TYPE_INT:   *(int       *)dst= llrint(num/den)*intnum; break;
+    case AV_OPT_TYPE_INT64: *(int64_t   *)dst= llrint(num/den)*intnum; break;
+    case AV_OPT_TYPE_FLOAT: *(float     *)dst= num*intnum/den;         break;
+    case AV_OPT_TYPE_DOUBLE:*(double    *)dst= num*intnum/den;         break;
+    case AV_OPT_TYPE_RATIONAL:
         if ((int)num == num) *(AVRational*)dst= (AVRational){num*intnum, den};
         else                 *(AVRational*)dst= av_d2q(num*intnum/den, 1<<24);
         break;
@@ -137,10 +159,11 @@ static int set_string_number(void *obj, const AVOption *o, const char *val, void
 {
     int ret = 0, notfirst = 0;
     for (;;) {
-        int i;
+        int i, den = 1;
         char buf[256];
         int cmd = 0;
-        double d;
+        double d, num = 1;
+        int64_t intnum = 1;
 
         if (*val == '+' || *val == '-')
             cmd = *(val++);
@@ -151,7 +174,7 @@ static int set_string_number(void *obj, const AVOption *o, const char *val, void
 
         {
             const AVOption *o_named = av_opt_find(obj, buf, o->unit, 0, 0);
-            if (o_named && o_named->type == FF_OPT_TYPE_CONST)
+            if (o_named && o_named->type == AV_OPT_TYPE_CONST)
                 d = o_named->default_val.dbl;
             else if (!strcmp(buf, "default")) d = o->default_val.dbl;
             else if (!strcmp(buf, "max"    )) d = o->max;
@@ -166,12 +189,14 @@ static int set_string_number(void *obj, const AVOption *o, const char *val, void
                 }
             }
         }
-        if (o->type == FF_OPT_TYPE_FLAGS) {
-            if      (cmd == '+') d = av_get_int(obj, o->name, NULL) | (int64_t)d;
-            else if (cmd == '-') d = av_get_int(obj, o->name, NULL) &~(int64_t)d;
+        if (o->type == AV_OPT_TYPE_FLAGS) {
+            read_number(o, dst, NULL, NULL, &intnum);
+            if      (cmd == '+') d = intnum | (int64_t)d;
+            else if (cmd == '-') d = intnum &~(int64_t)d;
         } else {
-            if      (cmd == '+') d = notfirst*av_get_double(obj, o->name, NULL) + d;
-            else if (cmd == '-') d = notfirst*av_get_double(obj, o->name, NULL) - d;
+            read_number(o, dst, &num, &den, &intnum);
+            if      (cmd == '+') d = notfirst*num*intnum/den + d;
+            else if (cmd == '-') d = notfirst*num*intnum/den - d;
         }
 
         if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
@@ -185,63 +210,111 @@ static int set_string_number(void *obj, const AVOption *o, const char *val, void
     return 0;
 }
 
+#if FF_API_OLD_AVOPTIONS
 int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out)
 {
     const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
-    void *dst;
     if (o_out)
         *o_out = o;
-    if (!o)
+    return av_opt_set(obj, name, val, 0);
+}
+#endif
+
+int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
+{
+    void *dst, *target_obj;
+    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
+    if (!o || !target_obj)
         return AVERROR_OPTION_NOT_FOUND;
-    if (!val && o->type != FF_OPT_TYPE_STRING)
+    if (!val && o->type != AV_OPT_TYPE_STRING)
         return AVERROR(EINVAL);
 
-    dst = ((uint8_t*)obj) + o->offset;
+    dst = ((uint8_t*)target_obj) + o->offset;
     switch (o->type) {
-    case FF_OPT_TYPE_STRING:   return set_string(obj, o, val, dst);
-    case FF_OPT_TYPE_BINARY:   return set_string_binary(obj, o, val, dst);
-    case FF_OPT_TYPE_FLAGS:
-    case FF_OPT_TYPE_INT:
-    case FF_OPT_TYPE_INT64:
-    case FF_OPT_TYPE_FLOAT:
-    case FF_OPT_TYPE_DOUBLE:
-    case FF_OPT_TYPE_RATIONAL: return set_string_number(obj, o, val, dst);
+    case AV_OPT_TYPE_STRING:   return set_string(obj, o, val, dst);
+    case AV_OPT_TYPE_BINARY:   return set_string_binary(obj, o, val, dst);
+    case AV_OPT_TYPE_FLAGS:
+    case AV_OPT_TYPE_INT:
+    case AV_OPT_TYPE_INT64:
+    case AV_OPT_TYPE_FLOAT:
+    case AV_OPT_TYPE_DOUBLE:
+    case AV_OPT_TYPE_RATIONAL: return set_string_number(obj, o, val, dst);
     }
 
     av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
     return AVERROR(EINVAL);
 }
 
-static const AVOption *set_number(void *obj, const char *name, double num, int den, int64_t intnum)
+#define OPT_EVAL_NUMBER(name, opttype, vartype)\
+    int av_opt_eval_ ## name(void *obj, const AVOption *o, const char *val, vartype *name ## _out)\
+    {\
+        if (!o || o->type != opttype)\
+            return AVERROR(EINVAL);\
+        return set_string_number(obj, o, val, name ## _out);\
+    }
+
+OPT_EVAL_NUMBER(flags,  AV_OPT_TYPE_FLAGS,    int)
+OPT_EVAL_NUMBER(int,    AV_OPT_TYPE_INT,      int)
+OPT_EVAL_NUMBER(int64,  AV_OPT_TYPE_INT64,    int64_t)
+OPT_EVAL_NUMBER(float,  AV_OPT_TYPE_FLOAT,    float)
+OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE,   double)
+OPT_EVAL_NUMBER(q,      AV_OPT_TYPE_RATIONAL, AVRational)
+
+static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
+                                  int search_flags)
 {
-    const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
-    void *dst;
+    void *dst, *target_obj;
+    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
 
-    if (!o)
-        return NULL;
+    if (!o || !target_obj)
+        return AVERROR_OPTION_NOT_FOUND;
 
-    dst = ((uint8_t*)obj) + o->offset;
-    if (write_number(obj, o, dst, num, den, intnum) < 0)
-        return NULL;
-    else
-        return o;
+    dst = ((uint8_t*)target_obj) + o->offset;
+    return write_number(obj, o, dst, num, den, intnum);
 }
 
+#if FF_API_OLD_AVOPTIONS
 const AVOption *av_set_double(void *obj, const char *name, double n)
 {
-    return set_number(obj, name, n, 1, 1);
+    const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
+    if (set_number(obj, name, n, 1, 1, 0) < 0)
+        return NULL;
+    return o;
 }
 
 const AVOption *av_set_q(void *obj, const char *name, AVRational n)
 {
-    return set_number(obj, name, n.num, n.den, 1);
+    const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
+    if (set_number(obj, name, n.num, n.den, 1, 0) < 0)
+        return NULL;
+    return o;
 }
 
 const AVOption *av_set_int(void *obj, const char *name, int64_t n)
 {
-    return set_number(obj, name, 1, 1, n);
+    const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
+    if (set_number(obj, name, 1, 1, n, 0) < 0)
+        return NULL;
+    return o;
+}
+#endif
+
+int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
+{
+    return set_number(obj, name, 1, 1, val, search_flags);
+}
+
+int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
+{
+    return set_number(obj, name, val, 1, 1, search_flags);
+}
+
+int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
+{
+    return set_number(obj, name, val.num, val.den, 1, search_flags);
 }
 
+#if FF_API_OLD_AVOPTIONS
 /**
  *
  * @param buf a buffer which is used for returning non string values as strings, can be NULL
@@ -255,21 +328,21 @@ const char *av_get_string(void *obj, const char *name, const AVOption **o_out, c
     int len, i;
     if (!o)
         return NULL;
-    if (o->type != FF_OPT_TYPE_STRING && (!buf || !buf_len))
+    if (o->type != AV_OPT_TYPE_STRING && (!buf || !buf_len))
         return NULL;
 
     dst= ((uint8_t*)obj) + o->offset;
     if (o_out) *o_out= o;
 
     switch (o->type) {
-    case FF_OPT_TYPE_FLAGS:     snprintf(buf, buf_len, "0x%08X",*(int    *)dst);break;
-    case FF_OPT_TYPE_INT:       snprintf(buf, buf_len, "%d" , *(int    *)dst);break;
-    case FF_OPT_TYPE_INT64:     snprintf(buf, buf_len, "%"PRId64, *(int64_t*)dst);break;
-    case FF_OPT_TYPE_FLOAT:     snprintf(buf, buf_len, "%f" , *(float  *)dst);break;
-    case FF_OPT_TYPE_DOUBLE:    snprintf(buf, buf_len, "%f" , *(double *)dst);break;
-    case FF_OPT_TYPE_RATIONAL:  snprintf(buf, buf_len, "%d/%d", ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
-    case FF_OPT_TYPE_STRING:    return *(void**)dst;
-    case FF_OPT_TYPE_BINARY:
+    case AV_OPT_TYPE_FLAGS:     snprintf(buf, buf_len, "0x%08X",*(int    *)dst);break;
+    case AV_OPT_TYPE_INT:       snprintf(buf, buf_len, "%d" , *(int    *)dst);break;
+    case AV_OPT_TYPE_INT64:     snprintf(buf, buf_len, "%"PRId64, *(int64_t*)dst);break;
+    case AV_OPT_TYPE_FLOAT:     snprintf(buf, buf_len, "%f" , *(float  *)dst);break;
+    case AV_OPT_TYPE_DOUBLE:    snprintf(buf, buf_len, "%f" , *(double *)dst);break;
+    case AV_OPT_TYPE_RATIONAL:  snprintf(buf, buf_len, "%d/%d", ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
+    case AV_OPT_TYPE_STRING:    return *(void**)dst;
+    case AV_OPT_TYPE_BINARY:
         len = *(int*)(((uint8_t *)dst) + sizeof(uint8_t *));
         if (len >= (buf_len + 1)/2) return NULL;
         bin = *(uint8_t**)dst;
@@ -279,41 +352,82 @@ const char *av_get_string(void *obj, const char *name, const AVOption **o_out, c
     }
     return buf;
 }
+#endif
 
-static int get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum)
+int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
 {
-    const AVOption *o = av_opt_find(obj, name, NULL, 0, AV_OPT_SEARCH_CHILDREN);
-    void *dst;
-    if (!o || (o->offset<=0 && o->type != FF_OPT_TYPE_CONST))
-        goto error;
+    void *dst, *target_obj;
+    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
+    uint8_t *bin, buf[128];
+    int len, i, ret;
 
-    dst= ((uint8_t*)obj) + o->offset;
+    if (!o || !target_obj || (o->offset<=0 && o->type != AV_OPT_TYPE_CONST))
+        return AVERROR_OPTION_NOT_FOUND;
 
-    if (o_out) *o_out= o;
+    dst = (uint8_t*)target_obj + o->offset;
 
+    buf[0] = 0;
     switch (o->type) {
-    case FF_OPT_TYPE_FLAGS:     *intnum= *(unsigned int*)dst;return 0;
-    case FF_OPT_TYPE_INT:       *intnum= *(int    *)dst;return 0;
-    case FF_OPT_TYPE_INT64:     *intnum= *(int64_t*)dst;return 0;
-    case FF_OPT_TYPE_FLOAT:     *num=    *(float  *)dst;return 0;
-    case FF_OPT_TYPE_DOUBLE:    *num=    *(double *)dst;return 0;
-    case FF_OPT_TYPE_RATIONAL:  *intnum= ((AVRational*)dst)->num;
-                                *den   = ((AVRational*)dst)->den;
-                                                        return 0;
-    case FF_OPT_TYPE_CONST:     *intnum= o->default_val.dbl;return 0;
+    case AV_OPT_TYPE_FLAGS:     ret = snprintf(buf, sizeof(buf), "0x%08X",  *(int    *)dst);break;
+    case AV_OPT_TYPE_INT:       ret = snprintf(buf, sizeof(buf), "%d" ,     *(int    *)dst);break;
+    case AV_OPT_TYPE_INT64:     ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t*)dst);break;
+    case AV_OPT_TYPE_FLOAT:     ret = snprintf(buf, sizeof(buf), "%f" ,     *(float  *)dst);break;
+    case AV_OPT_TYPE_DOUBLE:    ret = snprintf(buf, sizeof(buf), "%f" ,     *(double *)dst);break;
+    case AV_OPT_TYPE_RATIONAL:  ret = snprintf(buf, sizeof(buf), "%d/%d",   ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
+    case AV_OPT_TYPE_CONST:     ret = snprintf(buf, sizeof(buf), "%f" ,     o->default_val.dbl);break;
+    case AV_OPT_TYPE_STRING:
+        if (*(uint8_t**)dst)
+            *out_val = av_strdup(*(uint8_t**)dst);
+        else
+            *out_val = av_strdup("");
+        return 0;
+    case AV_OPT_TYPE_BINARY:
+        len = *(int*)(((uint8_t *)dst) + sizeof(uint8_t *));
+        if ((uint64_t)len*2 + 1 > INT_MAX)
+            return AVERROR(EINVAL);
+        if (!(*out_val = av_malloc(len*2 + 1)))
+            return AVERROR(ENOMEM);
+        bin = *(uint8_t**)dst;
+        for (i = 0; i < len; i++)
+            snprintf(*out_val + i*2, 3, "%02X", bin[i]);
+        return 0;
+    default:
+        return AVERROR(EINVAL);
     }
+
+    if (ret >= sizeof(buf))
+        return AVERROR(EINVAL);
+    *out_val = av_strdup(buf);
+    return 0;
+}
+
+static int get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum,
+                      int search_flags)
+{
+    void *dst, *target_obj;
+    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
+    if (!o || !target_obj)
+        goto error;
+
+    dst = ((uint8_t*)target_obj) + o->offset;
+
+    if (o_out) *o_out= o;
+
+    return read_number(o, dst, num, den, intnum);
+
 error:
     *den=*intnum=0;
     return -1;
 }
 
+#if FF_API_OLD_AVOPTIONS
 double av_get_double(void *obj, const char *name, const AVOption **o_out)
 {
     int64_t intnum=1;
     double num=1;
     int den=1;
 
-    if (get_number(obj, name, o_out, &num, &den, &intnum) < 0)
+    if (get_number(obj, name, o_out, &num, &den, &intnum, 0) < 0)
         return NAN;
     return num*intnum/den;
 }
@@ -324,7 +438,7 @@ AVRational av_get_q(void *obj, const char *name, const AVOption **o_out)
     double num=1;
     int den=1;
 
-    if (get_number(obj, name, o_out, &num, &den, &intnum) < 0)
+    if (get_number(obj, name, o_out, &num, &den, &intnum, 0) < 0)
         return (AVRational){0, 0};
     if (num == 1.0 && (int)intnum == intnum)
         return (AVRational){intnum, den};
@@ -338,19 +452,62 @@ int64_t av_get_int(void *obj, const char *name, const AVOption **o_out)
     double num=1;
     int den=1;
 
-    if (get_number(obj, name, o_out, &num, &den, &intnum) < 0)
+    if (get_number(obj, name, o_out, &num, &den, &intnum, 0) < 0)
         return -1;
     return num*intnum/den;
 }
+#endif
+
+int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
+{
+    int64_t intnum = 1;
+    double     num = 1;
+    int   ret, den = 1;
+
+    if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
+        return ret;
+    *out_val = num*intnum/den;
+    return 0;
+}
+
+int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
+{
+    int64_t intnum = 1;
+    double     num = 1;
+    int   ret, den = 1;
+
+    if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
+        return ret;
+    *out_val = num*intnum/den;
+    return 0;
+}
+
+int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
+{
+    int64_t intnum = 1;
+    double     num = 1;
+    int   ret, den = 1;
+
+    if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
+        return ret;
+
+    if (num == 1.0 && (int)intnum == intnum)
+        *out_val = (AVRational){intnum, den};
+    else
+        *out_val = av_d2q(num*intnum/den, 1<<24);
+    return 0;
+}
 
 int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
 {
-    const AVOption *field = av_find_opt(obj, field_name, NULL, 0, 0);
-    const AVOption *flag  = av_find_opt(obj, flag_name,  NULL, 0, 0);
+    const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
+    const AVOption *flag  = av_opt_find(obj, flag_name,  NULL, 0, 0);
+    int64_t res;
 
-    if (!field || !flag || flag->type != FF_OPT_TYPE_CONST)
+    if (!field || !flag || flag->type != AV_OPT_TYPE_CONST ||
+        av_opt_get_int(obj, field_name, 0, &res) < 0)
         return 0;
-    return av_get_int(obj, field_name, NULL) & (int) flag->default_val.dbl;
+    return res & (int) flag->default_val.dbl;
 }
 
 static void opt_list(void *obj, void *av_log_obj, const char *unit,
@@ -358,7 +515,7 @@ static void opt_list(void *obj, void *av_log_obj, const char *unit,
 {
     const AVOption *opt=NULL;
 
-    while ((opt= av_next_option(obj, opt))) {
+    while ((opt = av_opt_next(obj, opt))) {
         if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
             continue;
 
@@ -366,43 +523,43 @@ static void opt_list(void *obj, void *av_log_obj, const char *unit,
          * Don't print anything but CONST's on level two.
          * Only print items from the requested unit.
          */
-        if (!unit && opt->type==FF_OPT_TYPE_CONST)
+        if (!unit && opt->type==AV_OPT_TYPE_CONST)
             continue;
-        else if (unit && opt->type!=FF_OPT_TYPE_CONST)
+        else if (unit && opt->type!=AV_OPT_TYPE_CONST)
             continue;
-        else if (unit && opt->type==FF_OPT_TYPE_CONST && strcmp(unit, opt->unit))
+        else if (unit && opt->type==AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
             continue;
-        else if (unit && opt->type == FF_OPT_TYPE_CONST)
+        else if (unit && opt->type == AV_OPT_TYPE_CONST)
             av_log(av_log_obj, AV_LOG_INFO, "   %-15s ", opt->name);
         else
             av_log(av_log_obj, AV_LOG_INFO, "-%-17s ", opt->name);
 
         switch (opt->type) {
-            case FF_OPT_TYPE_FLAGS:
+            case AV_OPT_TYPE_FLAGS:
                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<flags>");
                 break;
-            case FF_OPT_TYPE_INT:
+            case AV_OPT_TYPE_INT:
                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<int>");
                 break;
-            case FF_OPT_TYPE_INT64:
+            case AV_OPT_TYPE_INT64:
                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<int64>");
                 break;
-            case FF_OPT_TYPE_DOUBLE:
+            case AV_OPT_TYPE_DOUBLE:
                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<double>");
                 break;
-            case FF_OPT_TYPE_FLOAT:
+            case AV_OPT_TYPE_FLOAT:
                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<float>");
                 break;
-            case FF_OPT_TYPE_STRING:
+            case AV_OPT_TYPE_STRING:
                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<string>");
                 break;
-            case FF_OPT_TYPE_RATIONAL:
+            case AV_OPT_TYPE_RATIONAL:
                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<rational>");
                 break;
-            case FF_OPT_TYPE_BINARY:
+            case AV_OPT_TYPE_BINARY:
                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<binary>");
                 break;
-            case FF_OPT_TYPE_CONST:
+            case AV_OPT_TYPE_CONST:
             default:
                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "");
                 break;
@@ -416,7 +573,7 @@ static void opt_list(void *obj, void *av_log_obj, const char *unit,
         if (opt->help)
             av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
         av_log(av_log_obj, AV_LOG_INFO, "\n");
-        if (opt->unit && opt->type != FF_OPT_TYPE_CONST) {
+        if (opt->unit && opt->type != AV_OPT_TYPE_CONST) {
             opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags);
         }
     }
@@ -444,44 +601,44 @@ void av_opt_set_defaults2(void *s, int mask, int flags)
 {
 #endif
     const AVOption *opt = NULL;
-    while ((opt = av_next_option(s, opt)) != NULL) {
+    while ((opt = av_opt_next(s, opt)) != NULL) {
 #if FF_API_OLD_AVOPTIONS
         if ((opt->flags & mask) != flags)
             continue;
 #endif
         switch (opt->type) {
-            case FF_OPT_TYPE_CONST:
+            case AV_OPT_TYPE_CONST:
                 /* Nothing to be done here */
             break;
-            case FF_OPT_TYPE_FLAGS:
-            case FF_OPT_TYPE_INT: {
+            case AV_OPT_TYPE_FLAGS:
+            case AV_OPT_TYPE_INT: {
                 int val;
                 val = opt->default_val.dbl;
-                av_set_int(s, opt->name, val);
+                av_opt_set_int(s, opt->name, val, 0);
             }
             break;
-            case FF_OPT_TYPE_INT64:
+            case AV_OPT_TYPE_INT64:
                 if ((double)(opt->default_val.dbl+0.6) == opt->default_val.dbl)
                     av_log(s, AV_LOG_DEBUG, "loss of precision in default of %s\n", opt->name);
-                av_set_int(s, opt->name, opt->default_val.dbl);
+                av_opt_set_int(s, opt->name, opt->default_val.dbl, 0);
             break;
-            case FF_OPT_TYPE_DOUBLE:
-            case FF_OPT_TYPE_FLOAT: {
+            case AV_OPT_TYPE_DOUBLE:
+            case AV_OPT_TYPE_FLOAT: {
                 double val;
                 val = opt->default_val.dbl;
-                av_set_double(s, opt->name, val);
+                av_opt_set_double(s, opt->name, val, 0);
             }
             break;
-            case FF_OPT_TYPE_RATIONAL: {
+            case AV_OPT_TYPE_RATIONAL: {
                 AVRational val;
                 val = av_d2q(opt->default_val.dbl, INT_MAX);
-                av_set_q(s, opt->name, val);
+                av_opt_set_q(s, opt->name, val, 0);
             }
             break;
-            case FF_OPT_TYPE_STRING:
-                av_set_string3(s, opt->name, opt->default_val.str, 1, NULL);
+            case AV_OPT_TYPE_STRING:
+                av_opt_set(s, opt->name, opt->default_val.str, 0);
                 break;
-            case FF_OPT_TYPE_BINARY:
+            case AV_OPT_TYPE_BINARY:
                 /* Cannot set default for binary */
             break;
             default:
@@ -504,7 +661,7 @@ void av_opt_set_defaults2(void *s, int mask, int flags)
  * set, or a negative value corresponding to an AVERROR code in case
  * of error:
  * AVERROR(EINVAL) if the key/value pair cannot be parsed,
- * the error code issued by av_set_string3() if the key/value pair
+ * the error code issued by av_opt_set() if the key/value pair
  * cannot be set
  */
 static int parse_key_value_pair(void *ctx, const char **buf,
@@ -525,7 +682,7 @@ static int parse_key_value_pair(void *ctx, const char **buf,
 
     av_log(ctx, AV_LOG_DEBUG, "Setting value '%s' for key '%s'\n", val, key);
 
-    ret = av_set_string3(ctx, key, val, 1, NULL);
+    ret = av_opt_set(ctx, key, val, 0);
     if (ret == AVERROR_OPTION_NOT_FOUND)
         av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
 
@@ -556,8 +713,8 @@ int av_set_options_string(void *ctx, const char *opts,
 void av_opt_free(void *obj)
 {
     const AVOption *o = NULL;
-    while ((o = av_next_option(obj, o)))
-        if (o->type == FF_OPT_TYPE_STRING || o->type == FF_OPT_TYPE_BINARY)
+    while ((o = av_opt_next(obj, o)))
+        if (o->type == AV_OPT_TYPE_STRING || o->type == AV_OPT_TYPE_BINARY)
             av_freep((uint8_t *)obj + o->offset);
 }
 
@@ -568,7 +725,7 @@ int av_opt_set_dict(void *obj, AVDictionary **options)
     int ret = 0;
 
     while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
-        ret = av_set_string3(obj, t->key, t->value, 1, NULL);
+        ret = av_opt_set(obj, t->key, t->value, 0);
         if (ret == AVERROR_OPTION_NOT_FOUND)
             av_dict_set(&tmp, t->key, t->value, 0);
         else if (ret < 0) {
@@ -585,22 +742,60 @@ int av_opt_set_dict(void *obj, AVDictionary **options)
 const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
                             int opt_flags, int search_flags)
 {
-    AVClass *c = *(AVClass**)obj;
+    return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL);
+}
+
+const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
+                             int opt_flags, int search_flags, void **target_obj)
+{
+    const AVClass  *c = *(AVClass**)obj;
     const AVOption *o = NULL;
 
-    if (c->opt_find && search_flags & AV_OPT_SEARCH_CHILDREN &&
-        (o = c->opt_find(obj, name, unit, opt_flags, search_flags)))
-        return o;
+    if (search_flags & AV_OPT_SEARCH_CHILDREN) {
+        if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
+            const AVClass *child = NULL;
+            while (child = av_opt_child_class_next(c, child))
+                if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
+                    return o;
+        } else {
+            void *child = NULL;
+            while (child = av_opt_child_next(obj, child))
+                if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
+                    return o;
+        }
+    }
 
-    while (o = av_next_option(obj, o)) {
+    while (o = av_opt_next(obj, o)) {
         if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
-            ((!unit && o->type != FF_OPT_TYPE_CONST) ||
-             (unit  && o->type == FF_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit))))
+            ((!unit && o->type != AV_OPT_TYPE_CONST) ||
+             (unit  && o->type == AV_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit)))) {
+            if (target_obj) {
+                if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
+                    *target_obj = obj;
+                else
+                    *target_obj = NULL;
+            }
             return o;
+        }
     }
     return NULL;
 }
 
+void *av_opt_child_next(void *obj, void *prev)
+{
+    const AVClass *c = *(AVClass**)obj;
+    if (c->child_next)
+        return c->child_next(obj, prev);
+    return NULL;
+}
+
+const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
+{
+    if (parent->child_class_next)
+        return parent->child_class_next(prev);
+    return NULL;
+}
+
 #ifdef TEST
 
 #undef printf
@@ -622,14 +817,14 @@ typedef struct TestContext
 #define TEST_FLAG_MU   04
 
 static const AVOption test_options[]= {
-{"num",      "set num",        OFFSET(num),      FF_OPT_TYPE_INT,      {0},              0,        100                 },
-{"toggle",   "set toggle",     OFFSET(toggle),   FF_OPT_TYPE_INT,      {0},              0,        1                   },
-{"rational", "set rational",   OFFSET(rational), FF_OPT_TYPE_RATIONAL, {0},              0,        10                  },
-{"string",   "set string",     OFFSET(string),   FF_OPT_TYPE_STRING,   {0},              CHAR_MIN, CHAR_MAX            },
-{"flags",    "set flags",      OFFSET(flags),    FF_OPT_TYPE_FLAGS,    {0},              0,        INT_MAX, 0, "flags" },
-{"cool",     "set cool flag ", 0,                FF_OPT_TYPE_CONST,    {TEST_FLAG_COOL}, INT_MIN,  INT_MAX, 0, "flags" },
-{"lame",     "set lame flag ", 0,                FF_OPT_TYPE_CONST,    {TEST_FLAG_LAME}, INT_MIN,  INT_MAX, 0, "flags" },
-{"mu",       "set mu flag ",   0,                FF_OPT_TYPE_CONST,    {TEST_FLAG_MU},   INT_MIN,  INT_MAX, 0, "flags" },
+{"num",      "set num",        OFFSET(num),      AV_OPT_TYPE_INT,      {0},              0,        100                 },
+{"toggle",   "set toggle",     OFFSET(toggle),   AV_OPT_TYPE_INT,      {0},              0,        1                   },
+{"rational", "set rational",   OFFSET(rational), AV_OPT_TYPE_RATIONAL, {0},              0,        10                  },
+{"string",   "set string",     OFFSET(string),   AV_OPT_TYPE_STRING,   {0},              CHAR_MIN, CHAR_MAX            },
+{"flags",    "set flags",      OFFSET(flags),    AV_OPT_TYPE_FLAGS,    {0},              0,        INT_MAX, 0, "flags" },
+{"cool",     "set cool flag ", 0,                AV_OPT_TYPE_CONST,    {TEST_FLAG_COOL}, INT_MIN,  INT_MAX, 0, "flags" },
+{"lame",     "set lame flag ", 0,                AV_OPT_TYPE_CONST,    {TEST_FLAG_LAME}, INT_MIN,  INT_MAX, 0, "flags" },
+{"mu",       "set mu flag ",   0,                AV_OPT_TYPE_CONST,    {TEST_FLAG_MU},   INT_MIN,  INT_MAX, 0, "flags" },
 {NULL},
 };