@@ -19,7 +19,7 @@ PROGS      := $(PROGS-yes:%=%$(EXESUF))

 INSTPROGS   = $(PROGS-yes:%=%$(PROGSSUF)$(EXESUF))

 OBJS        = $(PROGS-yes:%=%.o) cmdutils.o

 TESTTOOLS   = audiogen videogen rotozoom tiny_psnr base64

-HOSTPROGS  := $(TESTTOOLS:%=tests/%)

+HOSTPROGS  := $(TESTTOOLS:%=tests/%) doc/print_options

 TOOLS       = qt-faststart trasher

 TOOLS-$(CONFIG_ZLIB) += cws2fws

@@ -28,18 +28,27 @@ doc/%.txt: doc/%.texi

 	$(Q)$(TEXIDEP)

 	$(M)makeinfo --force --no-headers -o $@ $< 2>/dev/null

+doc/print_options.o: libavformat/options_table.h libavcodec/options_table.h

+

+GENTEXI  = format codec

+GENTEXI := $(GENTEXI:%=doc/avoptions_%.texi)

+

+$(GENTEXI): TAG = GENTEXI

+$(GENTEXI): doc/avoptions_%.texi: doc/print_options

+	$(M)doc/print_options $* > $@

+

 doc/%.html: TAG = HTML

-doc/%.html: doc/%.texi $(SRC_PATH)/doc/t2h.init

+doc/%.html: doc/%.texi $(SRC_PATH)/doc/t2h.init $(GENTEXI)

 	$(Q)$(TEXIDEP)

-	$(M)texi2html -monolithic --init-file $(SRC_PATH)/doc/t2h.init --output $@ $<

+	$(M)texi2html -I doc -monolithic --init-file $(SRC_PATH)/doc/t2h.init --output $@ $<

 doc/%.pod: TAG = POD

-doc/%.pod: doc/%.texi

+doc/%.pod: doc/%.texi $(GENTEXI)

 	$(Q)$(TEXIDEP)

-	$(M)$(SRC_PATH)/doc/texi2pod.pl $< $@

+	$(M)$(SRC_PATH)/doc/texi2pod.pl -Idoc $< $@

 doc/%.1: TAG = MAN

-doc/%.1: doc/%.pod

+doc/%.1: doc/%.pod $(GENTEXI)

 	$(M)pod2man --section=1 --center=" " --release=" " $< > $@

 $(DOCS): | doc

@@ -57,7 +66,7 @@ uninstall-man:

 	$(RM) $(addprefix "$(MANDIR)/man1/",$(ALLMANPAGES))

 clean::

-	$(RM) $(TXTPAGES) doc/*.html doc/*.pod doc/*.1 $(CLEANSUFFIXES:%=doc/%)

+	$(RM) $(TXTPAGES) doc/*.html doc/*.pod doc/*.1 $(CLEANSUFFIXES:%=doc/%) doc/avoptions_*.texi

 -include $(wildcard $(DOCS:%=%.d))

@@ -175,3 +175,6 @@ use @option{-option 0}/@option{-option 1}.

 Note2 old undocumented way of specifying per-stream AVOptions by prepending

 v/a/s to the options name is now obsolete and will be removed soon.

+

+@include avoptions_codec.texi

+@include avoptions_format.texi

@@ -370,25 +370,7 @@ pad=width:height:x:y:color instead.

 @item -vn (@emph{output})

 Disable video recording.

-@item -bt @var{tolerance}

-Set video bitrate tolerance (in bits, default 4000k).

-Has a minimum value of: (target_bitrate/target_framerate).

-In 1-pass mode, bitrate tolerance specifies how far ratecontrol is

-willing to deviate from the target average bitrate value. This is

-not related to min/max bitrate. Lowering tolerance too much has

-an adverse effect on quality.

-@item -maxrate @var{bitrate}

-Set max video bitrate (in bit/s).

-Requires -bufsize to be set.

-@item -minrate @var{bitrate}

-Set min video bitrate (in bit/s).

-Most useful in setting up a CBR encode:

-@example

-ffmpeg -i myfile.avi -b:v 4000k -minrate 4000k -maxrate 4000k -bufsize 1835k out.m2v

-@end example

-It is of little use elsewise.

-@item -bufsize @var{size}

-Set video buffer verifier buffer size (in bits).

+

 @item -vcodec @var{codec} (@emph{output})

 Set the video codec. This is an alias for @code{-codec:v}.

 @item -same_quant

@@ -435,197 +417,14 @@ Set pixel format. Use @code{-pix_fmts} to show all the supported

 pixel formats.

 @item -sws_flags @var{flags} (@emph{input/output})

 Set SwScaler flags.

-@item -g @var{gop_size}

-Set the group of pictures size.

-@item -intra

-deprecated, use -g 1

 @item -vdt @var{n}

 Discard threshold.

-@item -qmin @var{q}

-minimum video quantizer scale (VBR)

-@item -qmax @var{q}

-maximum video quantizer scale (VBR)

-@item -qdiff @var{q}

-maximum difference between the quantizer scales (VBR)

-@item -qblur @var{blur}

-video quantizer scale blur (VBR) (range 0.0 - 1.0)

-@item -qcomp @var{compression}

-video quantizer scale compression (VBR) (default 0.5).

-Constant of ratecontrol equation. Recommended range for default rc_eq: 0.0-1.0

-

-@item -lmin @var{lambda}

-minimum video lagrange factor (VBR)

-@item -lmax @var{lambda}

-max video lagrange factor (VBR)

-@item -mblmin @var{lambda}

-minimum macroblock quantizer scale (VBR)

-@item -mblmax @var{lambda}

-maximum macroblock quantizer scale (VBR)

-

-These four options (lmin, lmax, mblmin, mblmax) use 'lambda' units,

-but you may use the QP2LAMBDA constant to easily convert from 'q' units:

-@example

-ffmpeg -i src.ext -lmax 21*QP2LAMBDA dst.ext

-@end example

-

-@item -rc_init_cplx @var{complexity}

-initial complexity for single pass encoding

-@item -b_qfactor @var{factor}

-qp factor between P- and B-frames

-@item -i_qfactor @var{factor}

-qp factor between P- and I-frames

-@item -b_qoffset @var{offset}

-qp offset between P- and B-frames

-@item -i_qoffset @var{offset}

-qp offset between P- and I-frames

-@item -rc_eq @var{equation}

-Set rate control equation (see section "Expression Evaluation")

-(default = @code{tex^qComp}).

-

-When computing the rate control equation expression, besides the

-standard functions defined in the section "Expression Evaluation", the

-following functions are available:

-@table @var

-@item bits2qp(bits)

-@item qp2bits(qp)

-@end table

-

-and the following constants are available:

-@table @var

-@item iTex

-@item pTex

-@item tex

-@item mv

-@item fCode

-@item iCount

-@item mcVar

-@item var

-@item isI

-@item isP

-@item isB

-@item avgQP

-@item qComp

-@item avgIITex

-@item avgPITex

-@item avgPPTex

-@item avgBPTex

-@item avgTex

-@end table

 @item -rc_override[:@var{stream_specifier}] @var{override} (@emph{output,per-stream})

 Rate control override for specific intervals, formatted as "int,int,int"

 list separated with slashes. Two first values are the beginning and

 end frame numbers, last one is quantizer to use if positive, or quality

 factor if negative.

-@item -me_method @var{method}

-Set motion estimation method to @var{method}.

-Available methods are (from lowest to best quality):

-@table @samp

-@item zero

-Try just the (0, 0) vector.

-@item phods

-@item log

-@item x1

-@item hex

-@item umh

-@item epzs

-(default method)

-@item full

-exhaustive search (slow and marginally better than epzs)

-@end table

-

-@item -dct_algo @var{algo}

-Set DCT algorithm to @var{algo}. Available values are:

-@table @samp

-@item 0

-FF_DCT_AUTO (default)

-@item 1

-FF_DCT_FASTINT

-@item 2

-FF_DCT_INT

-@item 3

-FF_DCT_MMX

-@item 4

-FF_DCT_MLIB

-@item 5

-FF_DCT_ALTIVEC

-@end table

-

-@item -idct_algo @var{algo}

-Set IDCT algorithm to @var{algo}. Available values are:

-@table @samp

-@item 0

-FF_IDCT_AUTO (default)

-@item 1

-FF_IDCT_INT

-@item 2

-FF_IDCT_SIMPLE

-@item 3

-FF_IDCT_SIMPLEMMX

-@item 4

-FF_IDCT_LIBMPEG2MMX

-@item 5

-FF_IDCT_PS2

-@item 6

-FF_IDCT_MLIB

-@item 7

-FF_IDCT_ARM

-@item 8

-FF_IDCT_ALTIVEC

-@item 9

-FF_IDCT_SH4

-@item 10

-FF_IDCT_SIMPLEARM

-@end table

-

-@item -er @var{n}

-Set error resilience to @var{n}.

-@table @samp

-@item 1

-FF_ER_CAREFUL (default)

-@item 2

-FF_ER_COMPLIANT

-@item 3

-FF_ER_AGGRESSIVE

-@item 4

-FF_ER_VERY_AGGRESSIVE

-@end table

-

-@item -ec @var{bit_mask}

-Set error concealment to @var{bit_mask}. @var{bit_mask} is a bit mask of

-the following values:

-@table @samp

-@item 1

-FF_EC_GUESS_MVS (default = enabled)

-@item 2

-FF_EC_DEBLOCK (default = enabled)

-@end table

-

-@item -bf @var{frames}

-Use 'frames' B-frames (supported for MPEG-1, MPEG-2 and MPEG-4).

-@item -mbd @var{mode}

-macroblock decision

-@table @samp

-@item 0

-FF_MB_DECISION_SIMPLE: Use mb_cmp (cannot change it yet in ffmpeg).

-@item 1

-FF_MB_DECISION_BITS: Choose the one which needs the fewest bits.

-@item 2

-FF_MB_DECISION_RD: rate distortion

-@end table

-

-@item -4mv

-Use four motion vector by macroblock (MPEG-4 only).

-@item -part

-Use data partitioning (MPEG-4 only).

-@item -bug @var{param}

-Work around encoder bugs that are not auto-detected.

-@item -strict @var{strictness}

-How strictly to follow the standards.

-@item -aic

-Enable Advanced intra coding (h263+).

-@item -umv

-Enable Unlimited Motion Vector (h263+)

 @item -deinterlace

 Deinterlace pictures.

@@ -696,28 +495,6 @@ of supported sample formats.

 @table @option

 @item -atag @var{fourcc/tag} (@emph{output})

 Force audio tag/fourcc. This is an alias for @code{-tag:a}.

-@item -audio_service_type @var{type}

-Set the type of service that the audio stream contains.

-@table @option

-@item ma

-Main Audio Service (default)

-@item ef

-Effects

-@item vi

-Visually Impaired

-@item hi

-Hearing Impaired

-@item di

-Dialogue

-@item co

-Commentary

-@item em

-Emergency

-@item vo

-Voice Over

-@item ka

-Karaoke

-@end table

 @item -absf @var{bitstream_filter}

 Deprecated, see -bsf

 @end table

@@ -945,8 +722,6 @@ Exit after ffmpeg has been running for @var{duration} seconds.

 Dump each input packet to stderr.

 @item -hex (@emph{global})

 When dumping packets, also dump the payload.

-@item -ps @var{size}

-Set RTP payload size in bytes.

 @item -re (@emph{input})

 Read input at native frame rate. Mainly used to simulate a grab device.

 @item -loop_input

@@ -957,8 +732,6 @@ This option is deprecated, use -loop 1.

 Repeatedly loop output for formats that support looping such as animated GIF

 (0 will loop the output infinitely).

 This option is deprecated, use -loop.

-@item -threads @var{count}

-Thread count.

 @item -vsync @var{parameter}

 Video sync method.

 For compatibility reasons old values can be specified as numbers.

@@ -1294,6 +1067,19 @@ ffmpeg -i test1.avi -i test2.avi -map 0.3 -map 0.2 -map 0.1 -map 0.0 -c copy tes

 The resulting output file @file{test12.avi} will contain first four streams from

 the input file in reverse order.

+@item

+To force CBR video output:

+@example

+ffmpeg -i myfile.avi -b 4000k -minrate 4000k -maxrate 4000k -bufsize 1835k out.m2v

+@end example

+

+@item

+The four options lmin, lmax, mblmin and mblmax use 'lambda' units,

+but you may use the QP2LAMBDA constant to easily convert from 'q' units:

+@example

+ffmpeg -i src.ext -lmax 21*QP2LAMBDA dst.ext

+@end example

+

 @end itemize

 @c man end EXAMPLES

@@ -181,8 +181,15 @@ Allow the caller to manually choose when to cut fragments, by

 calling @code{av_write_frame(ctx, NULL)} to write a fragment with

 the packets written so far. (This is only useful with other

 applications integrating libavformat, not from @command{ffmpeg}.)

+@item -min_frag_duration @var{duration}

+Don't create fragments that are shorter than @var{duration} microseconds long.

 @end table

+If more than one condition is specified, fragments are cut when

+one of the specified conditions is fulfilled. The exception to this is

+@code{-min_frag_duration}, which has to be fulfilled for any of the other

+conditions to apply.

+

 Additionally, the way the output file is written can be adjusted

 through a few other options:

new file mode 100644

@@ -0,0 +1,123 @@

+/*

+ * Copyright (c) 2012 Anton Khirnov

+ *

+ * This file is part of Libav.

+ *

+ * Libav is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * Libav is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with Libav; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+/*

+ * generate texinfo manpages for avoptions

+ */

+

+#include <stddef.h>

+#include <string.h>

+#include <float.h>

+

+#include "libavformat/avformat.h"

+#include "libavcodec/avcodec.h"

+#include "libavutil/opt.h"

+

+static void print_usage(void)

+{

+    fprintf(stderr, "Usage: enum_options type\n"

+            "type: format codec\n");

+    exit(1);

+}

+

+static void print_option(const AVOption *opts, const AVOption *o, int per_stream)

+{

+    printf("@item -%s%s @var{", o->name, per_stream ? "[:stream_specifier]" : "");

+    switch (o->type) {

+    case AV_OPT_TYPE_BINARY:   printf("hexadecimal string"); break;

+    case AV_OPT_TYPE_STRING:   printf("string");             break;

+    case AV_OPT_TYPE_INT:

+    case AV_OPT_TYPE_INT64:    printf("integer");            break;

+    case AV_OPT_TYPE_FLOAT:

+    case AV_OPT_TYPE_DOUBLE:   printf("float");              break;

+    case AV_OPT_TYPE_RATIONAL: printf("rational number");    break;

+    case AV_OPT_TYPE_FLAGS:    printf("flags");              break;

+    default:                   printf("value");              break;

+    }

+    printf("} (@emph{");

+

+    if (o->flags & AV_OPT_FLAG_DECODING_PARAM) {

+        printf("input");

+        if (o->flags & AV_OPT_FLAG_ENCODING_PARAM)

+            printf("/");

+    }

+    if (o->flags & AV_OPT_FLAG_ENCODING_PARAM) printf("output");

+    if (o->flags & AV_OPT_FLAG_AUDIO_PARAM)    printf(",audio");

+    if (o->flags & AV_OPT_FLAG_VIDEO_PARAM)    printf(",video");

+    if (o->flags & AV_OPT_FLAG_SUBTITLE_PARAM) printf(",subtitles");

+

+    printf("})\n");

+    if (o->help)

+        printf("%s\n", o->help);

+

+    if (o->unit) {

+        const AVOption *u;

+        printf("\nPossible values:\n@table @samp\n");

+

+        for (u = opts; u->name; u++) {

+            if (u->type == AV_OPT_TYPE_CONST && u->unit && !strcmp(u->unit, o->unit))

+                printf("@item %s\n%s\n", u->name, u->help ? u->help : "");

+        }

+        printf("@end table\n");

+    }

+}

+

+static void show_opts(const AVOption *opts, int per_stream)

+{

+    const AVOption *o;

+

+    printf("@table @option\n");

+    for (o = opts; o->name; o++) {

+        if (o->type != AV_OPT_TYPE_CONST)

+            print_option(opts, o, per_stream);

+    }

+    printf("@end table\n");

+}

+

+static void show_format_opts(void)

+{

+#include "libavformat/options_table.h"

+

+    printf("@section Format AVOptions\n");

+    show_opts(options, 0);

+}

+

+static void show_codec_opts(void)

+{

+#include "libavcodec/options_table.h"

+

+    printf("@section Codec AVOptions\n");

+    show_opts(options, 1);

+}

+

+int main(int argc, char **argv)

+{

+    if (argc < 2)

+        print_usage();

+

+    if (!strcmp(argv[1], "format"))

+        show_format_opts();

+    else if (!strcmp(argv[1], "codec"))

+        show_codec_opts();

+    else

+        print_usage();

+

+    return 0;

+}

@@ -318,9 +318,9 @@ Accept packets only from negotiated peer address and port.

 @end table

 When receiving data over UDP, the demuxer tries to reorder received packets

-(since they may arrive out of order, or packets may get lost totally). In

-order for this to be enabled, a maximum delay must be specified in the

-@code{max_delay} field of AVFormatContext.

+(since they may arrive out of order, or packets may get lost totally). This

+can be disabled by setting the maximum demuxing delay to zero (via

+the @code{max_delay} field of AVFormatContext).

 When watching multi-bitrate Real-RTSP streams with @command{ffplay}, the

 streams to display can be chosen with @code{-vst} @var{n} and

@@ -36,7 +36,7 @@ $shift = "";

 %defs = ();

 $fnno = 1;

 $inf = "";

-$ibase = "";

+@ibase = ();

 while ($_ = shift) {

     if (/^-D(.*)$/) {

@@ -52,6 +52,8 @@ while ($_ = shift) {

         die "flags may only contain letters, digits, hyphens, dashes and underscores\n"

             unless $flag =~ /^[a-zA-Z0-9_-]+$/;

         $defs{$flag} = $value;

+    } elsif (/^-I(.*)$/) {

+        push @ibase, $1 ne "" ? $1 : shift;

     } elsif (/^-/) {

         usage();

     } else {

@@ -61,10 +63,12 @@ while ($_ = shift) {

     }

 }

+push @ibase, ".";

+

 if (defined $in) {

     $inf = gensym();

     open($inf, "<$in") or die "opening \"$in\": $!\n";

-    $ibase = $1 if $in =~ m|^(.+)/[^/]+$|;

+    push @ibase, $1 if $in =~ m|^(.+)/[^/]+$|;

 } else {

     $inf = \*STDIN;

 }

@@ -74,7 +78,7 @@ if (defined $out) {

 }

 while(defined $inf) {

-while(<$inf>) {

+INF: while(<$inf>) {

     # Certain commands are discarded without further processing.

     /^\@(?:

          [a-z]+index            # @*index: useful only in complete manual

@@ -104,11 +108,10 @@ while(<$inf>) {

         push @instack, $inf;

         $inf = gensym();

-        # Try cwd and $ibase.

-        open($inf, "<" . $1)

-            or open($inf, "<" . $ibase . "/" . $1)

-                or die "cannot open $1 or $ibase/$1: $!\n";

-        next;

+        for (@ibase) {

+            open($inf, "<" . $_ . "/" . $1) and next INF;

+        }

+        die "cannot open $1: $!\n";

     };

     # Look for blocks surrounded by @c man begin SECTION ... @c man end.

@@ -1007,8 +1007,10 @@ static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)

      * reordering, see do_video_out()

      */

     if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {

-        if (ost->frame_number >= ost->max_frames)

+        if (ost->frame_number >= ost->max_frames) {

+            av_free_packet(pkt);

             return;

+        }

         ost->frame_number++;

     }

@@ -1083,6 +1085,7 @@ static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,

             exit_program(1);

         }

+        frame->pts = ost->sync_opts;

         ost->sync_opts += frame->nb_samples;

     }

@@ -5065,7 +5068,7 @@ static const OptionDef options[] = {

     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },

-    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},

+    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},

     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },

     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },

     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },

@@ -616,7 +616,7 @@ OBJS-$(CONFIG_MPEGTS_DEMUXER)          += mpeg4audio.o mpegaudiodata.o

 OBJS-$(CONFIG_MXF_MUXER)               += timecode.o

 OBJS-$(CONFIG_NUT_MUXER)               += mpegaudiodata.o

 OBJS-$(CONFIG_OGG_DEMUXER)             += flacdec.o flacdata.o flac.o \

-                                          dirac.o mpeg12data.o vorbis_data.o

+                                          dirac.o mpeg12data.o vorbis_parser.o vorbis_data.o

 OBJS-$(CONFIG_OGG_MUXER)               += xiph.o flacdec.o flacdata.o flac.o \

                                           vorbis_data.o

 OBJS-$(CONFIG_RTP_MUXER)               += mpeg4audio.o mpegvideo.o xiph.o

@@ -146,6 +146,8 @@ enum BlockTypes {

  */

 static void init_lengths(BinkContext *c, int width, int bw)

 {

+    width = FFALIGN(width, 8);

+

     c->bundle[BINK_SRC_BLOCK_TYPES].len = av_log2((width >> 3) + 511) + 1;

     c->bundle[BINK_SRC_SUB_BLOCK_TYPES].len = av_log2(((width + 7) >> 4) + 511) + 1;

@@ -30,6 +30,8 @@

 #include "libavutil/opt.h"

 #include <float.h>              /* FLT_MIN, FLT_MAX */

+#include "options_table.h"

+

 static const char* context_to_name(void* ptr) {

     AVCodecContext *avc= ptr;

@@ -63,384 +65,12 @@ static const AVClass *codec_child_class_next(const AVClass *prev)

     return NULL;

 }

-#define OFFSET(x) offsetof(AVCodecContext,x)

-#define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C

-//these names are too long to be readable

-#define V AV_OPT_FLAG_VIDEO_PARAM

-#define A AV_OPT_FLAG_AUDIO_PARAM

-#define S AV_OPT_FLAG_SUBTITLE_PARAM

-#define E AV_OPT_FLAG_ENCODING_PARAM

-#define D AV_OPT_FLAG_DECODING_PARAM

-

-#define AV_CODEC_DEFAULT_BITRATE 200*1000

-

-static const AVOption options[]={

-{"b", "set bitrate (in bits/s)", OFFSET(bit_rate), AV_OPT_TYPE_INT, {.dbl = AV_CODEC_DEFAULT_BITRATE }, INT_MIN, INT_MAX, A|V|E},

-{"ab", "set bitrate (in bits/s)", OFFSET(bit_rate), AV_OPT_TYPE_INT, {.dbl = 128*1000 }, INT_MIN, INT_MAX, A|E},

-{"bt", "set video bitrate tolerance (in bits/s)", OFFSET(bit_rate_tolerance), AV_OPT_TYPE_INT, {.dbl = AV_CODEC_DEFAULT_BITRATE*20 }, 1, INT_MAX, V|E},

-{"flags", NULL, OFFSET(flags), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, 0, UINT_MAX, V|A|E|D, "flags"},

-{"mv4", "use four motion vector by macroblock (mpeg4)", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_4MV }, INT_MIN, INT_MAX, V|E, "flags"},

-{"qpel", "use 1/4 pel motion compensation", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_QPEL }, INT_MIN, INT_MAX, V|E, "flags"},

-{"loop", "use loop filter", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_LOOP_FILTER }, INT_MIN, INT_MAX, V|E, "flags"},

-{"qscale", "use fixed qscale", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_QSCALE }, INT_MIN, INT_MAX, 0, "flags"},

-{"gmc", "use gmc", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_GMC }, INT_MIN, INT_MAX, V|E, "flags"},

-{"mv0", "always try a mb with mv=<0,0>", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_MV0 }, INT_MIN, INT_MAX, V|E, "flags"},

-{"input_preserved", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_INPUT_PRESERVED }, INT_MIN, INT_MAX, 0, "flags"},

-{"pass1", "use internal 2pass ratecontrol in first  pass mode", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_PASS1 }, INT_MIN, INT_MAX, 0, "flags"},

-{"pass2", "use internal 2pass ratecontrol in second pass mode", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_PASS2 }, INT_MIN, INT_MAX, 0, "flags"},

-{"gray", "only decode/encode grayscale", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_GRAY }, INT_MIN, INT_MAX, V|E|D, "flags"},

-{"emu_edge", "don't draw edges", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_EMU_EDGE }, INT_MIN, INT_MAX, 0, "flags"},

-{"psnr", "error[?] variables will be set during encoding", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_PSNR }, INT_MIN, INT_MAX, V|E, "flags"},

-{"truncated", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_TRUNCATED }, INT_MIN, INT_MAX, 0, "flags"},

-{"naq", "normalize adaptive quantization", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_NORMALIZE_AQP }, INT_MIN, INT_MAX, V|E, "flags"},

-{"ildct", "use interlaced dct", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_INTERLACED_DCT }, INT_MIN, INT_MAX, V|E, "flags"},

-{"low_delay", "force low delay", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_LOW_DELAY }, INT_MIN, INT_MAX, V|D|E, "flags"},

-{"global_header", "place global headers in extradata instead of every keyframe", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_GLOBAL_HEADER }, INT_MIN, INT_MAX, V|A|E, "flags"},

-{"bitexact", "use only bitexact stuff (except (i)dct)", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_BITEXACT }, INT_MIN, INT_MAX, A|V|S|D|E, "flags"},

-{"aic", "h263 advanced intra coding / mpeg4 ac prediction", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_AC_PRED }, INT_MIN, INT_MAX, V|E, "flags"},

-#if FF_API_MPV_GLOBAL_OPTS

-{"cbp", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_CBP_RD }, INT_MIN, INT_MAX, V|E, "flags"},

-{"qprd", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_QP_RD }, INT_MIN, INT_MAX, V|E, "flags"},

-#endif

-{"ilme", "interlaced motion estimation", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_INTERLACED_ME }, INT_MIN, INT_MAX, V|E, "flags"},

-{"cgop", "closed gop", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_CLOSED_GOP }, INT_MIN, INT_MAX, V|E, "flags"},

-{"fast", "allow non spec compliant speedup tricks", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_FAST }, INT_MIN, INT_MAX, V|E, "flags2"},

-#if FF_API_MPV_GLOBAL_OPTS

-{"sgop", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_STRICT_GOP }, INT_MIN, INT_MAX, V|E, "flags2"},

-#endif

-{"noout", "skip bitstream encoding", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_NO_OUTPUT }, INT_MIN, INT_MAX, V|E, "flags2"},

-{"local_header", "place global headers at every keyframe instead of in extradata", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_LOCAL_HEADER }, INT_MIN, INT_MAX, V|E, "flags2"},

-{"showall", "Show all frames before the first keyframe", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_SHOW_ALL }, INT_MIN, INT_MAX, V|D, "flags2"},

-#if FF_API_SUB_ID

-{"sub_id", NULL, OFFSET(sub_id), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-#endif

-{"me_method", "set motion estimation method", OFFSET(me_method), AV_OPT_TYPE_INT, {.dbl = ME_EPZS }, INT_MIN, INT_MAX, V|E, "me_method"},

-{"zero", "zero motion estimation (fastest)", 0, AV_OPT_TYPE_CONST, {.dbl = ME_ZERO }, INT_MIN, INT_MAX, V|E, "me_method" },

-{"full", "full motion estimation (slowest)", 0, AV_OPT_TYPE_CONST, {.dbl = ME_FULL }, INT_MIN, INT_MAX, V|E, "me_method" },

-{"epzs", "EPZS motion estimation (default)", 0, AV_OPT_TYPE_CONST, {.dbl = ME_EPZS }, INT_MIN, INT_MAX, V|E, "me_method" },

-{"esa", "esa motion estimation (alias for full)", 0, AV_OPT_TYPE_CONST, {.dbl = ME_FULL }, INT_MIN, INT_MAX, V|E, "me_method" },

-{"tesa", "tesa motion estimation", 0, AV_OPT_TYPE_CONST, {.dbl = ME_TESA }, INT_MIN, INT_MAX, V|E, "me_method" },

-{"dia", "dia motion estimation (alias for epzs)", 0, AV_OPT_TYPE_CONST, {.dbl = ME_EPZS }, INT_MIN, INT_MAX, V|E, "me_method" },

-{"log", "log motion estimation", 0, AV_OPT_TYPE_CONST, {.dbl = ME_LOG }, INT_MIN, INT_MAX, V|E, "me_method" },

-{"phods", "phods motion estimation", 0, AV_OPT_TYPE_CONST, {.dbl = ME_PHODS }, INT_MIN, INT_MAX, V|E, "me_method" },

-{"x1", "X1 motion estimation", 0, AV_OPT_TYPE_CONST, {.dbl = ME_X1 }, INT_MIN, INT_MAX, V|E, "me_method" },

-{"hex", "hex motion estimation", 0, AV_OPT_TYPE_CONST, {.dbl = ME_HEX }, INT_MIN, INT_MAX, V|E, "me_method" },

-{"umh", "umh motion estimation", 0, AV_OPT_TYPE_CONST, {.dbl = ME_UMH }, INT_MIN, INT_MAX, V|E, "me_method" },

-{"iter", "iter motion estimation", 0, AV_OPT_TYPE_CONST, {.dbl = ME_ITER }, INT_MIN, INT_MAX, V|E, "me_method" },

-{"extradata_size", NULL, OFFSET(extradata_size), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, INT_MIN, INT_MAX},

-{"g", "set the group of picture size", OFFSET(gop_size), AV_OPT_TYPE_INT, {.dbl = 12 }, INT_MIN, INT_MAX, V|E},

-{"ar", "set audio sampling rate (in Hz)", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, A|D|E},

-{"ac", "set number of audio channels", OFFSET(channels), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, A|D|E},

-{"cutoff", "set cutoff bandwidth", OFFSET(cutoff), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, A|E},

-{"frame_size", NULL, OFFSET(frame_size), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, A|E},

-{"frame_number", NULL, OFFSET(frame_number), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"delay", NULL, OFFSET(delay), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"qcomp", "video quantizer scale compression (VBR)", OFFSET(qcompress), AV_OPT_TYPE_FLOAT, {.dbl = 0.5 }, -FLT_MAX, FLT_MAX, V|E},

-{"qblur", "video quantizer scale blur (VBR)", OFFSET(qblur), AV_OPT_TYPE_FLOAT, {.dbl = 0.5 }, -1, FLT_MAX, V|E},

-{"qmin", "min video quantizer scale (VBR)", OFFSET(qmin), AV_OPT_TYPE_INT, {.dbl = 2 }, -1, 69, V|E},

-{"qmax", "max video quantizer scale (VBR)", OFFSET(qmax), AV_OPT_TYPE_INT, {.dbl = 31 }, -1, 1024, V|E},

-{"qdiff", "max difference between the quantizer scale (VBR)", OFFSET(max_qdiff), AV_OPT_TYPE_INT, {.dbl = 3 }, INT_MIN, INT_MAX, V|E},

-{"bf", "use 'frames' B frames", OFFSET(max_b_frames), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, -1, FF_MAX_B_FRAMES, V|E},

-{"b_qfactor", "qp factor between p and b frames", OFFSET(b_quant_factor), AV_OPT_TYPE_FLOAT, {.dbl = 1.25 }, -FLT_MAX, FLT_MAX, V|E},

-{"rc_strategy", "ratecontrol method", OFFSET(rc_strategy), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},

-{"b_strategy", "strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, {.dbl = 0 }, INT_MIN, INT_MAX, V|E},

-{"ps", "rtp payload size in bytes", OFFSET(rtp_payload_size), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},

-{"mv_bits", NULL, OFFSET(mv_bits), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"header_bits", NULL, OFFSET(header_bits), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"i_tex_bits", NULL, OFFSET(i_tex_bits), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"p_tex_bits", NULL, OFFSET(p_tex_bits), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"i_count", NULL, OFFSET(i_count), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"p_count", NULL, OFFSET(p_count), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"skip_count", NULL, OFFSET(skip_count), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"misc_bits", NULL, OFFSET(misc_bits), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"frame_bits", NULL, OFFSET(frame_bits), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"codec_tag", NULL, OFFSET(codec_tag), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"bug", "workaround not auto detected encoder bugs", OFFSET(workaround_bugs), AV_OPT_TYPE_FLAGS, {.dbl = FF_BUG_AUTODETECT }, INT_MIN, INT_MAX, V|D, "bug"},

-{"autodetect", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_AUTODETECT }, INT_MIN, INT_MAX, V|D, "bug"},

-{"old_msmpeg4", "some old lavc generated msmpeg4v3 files (no autodetection)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_OLD_MSMPEG4 }, INT_MIN, INT_MAX, V|D, "bug"},

-{"xvid_ilace", "Xvid interlacing bug (autodetected if fourcc==XVIX)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_XVID_ILACE }, INT_MIN, INT_MAX, V|D, "bug"},

-{"ump4", "(autodetected if fourcc==UMP4)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_UMP4 }, INT_MIN, INT_MAX, V|D, "bug"},

-{"no_padding", "padding bug (autodetected)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_NO_PADDING }, INT_MIN, INT_MAX, V|D, "bug"},

-{"amv", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_AMV }, INT_MIN, INT_MAX, V|D, "bug"},

-{"ac_vlc", "illegal vlc bug (autodetected per fourcc)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_AC_VLC }, INT_MIN, INT_MAX, V|D, "bug"},

-{"qpel_chroma", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_QPEL_CHROMA }, INT_MIN, INT_MAX, V|D, "bug"},

-{"std_qpel", "old standard qpel (autodetected per fourcc/version)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_STD_QPEL }, INT_MIN, INT_MAX, V|D, "bug"},

-{"qpel_chroma2", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_QPEL_CHROMA2 }, INT_MIN, INT_MAX, V|D, "bug"},

-{"direct_blocksize", "direct-qpel-blocksize bug (autodetected per fourcc/version)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_DIRECT_BLOCKSIZE }, INT_MIN, INT_MAX, V|D, "bug"},

-{"edge", "edge padding bug (autodetected per fourcc/version)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_EDGE }, INT_MIN, INT_MAX, V|D, "bug"},

-{"hpel_chroma", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_HPEL_CHROMA }, INT_MIN, INT_MAX, V|D, "bug"},

-{"dc_clip", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_DC_CLIP }, INT_MIN, INT_MAX, V|D, "bug"},

-{"ms", "workaround various bugs in microsofts broken decoders", 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_MS }, INT_MIN, INT_MAX, V|D, "bug"},

-{"trunc", "trancated frames", 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_TRUNCATED}, INT_MIN, INT_MAX, V|D, "bug"},

-#if FF_API_MPV_GLOBAL_OPTS

-{"lelim", "single coefficient elimination threshold for luminance (negative values also consider dc coefficient)", OFFSET(luma_elim_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},

-{"celim", "single coefficient elimination threshold for chrominance (negative values also consider dc coefficient)", OFFSET(chroma_elim_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},

-#endif

-{"strict", "how strictly to follow the standards", OFFSET(strict_std_compliance), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, A|V|D|E, "strict"},

-{"very", "strictly conform to a older more strict version of the spec or reference software", 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_VERY_STRICT }, INT_MIN, INT_MAX, V|D|E, "strict"},

-{"strict", "strictly conform to all the things in the spec no matter what consequences", 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_STRICT }, INT_MIN, INT_MAX, V|D|E, "strict"},

-{"normal", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_NORMAL }, INT_MIN, INT_MAX, V|D|E, "strict"},

-{"unofficial", "allow unofficial extensions", 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_UNOFFICIAL }, INT_MIN, INT_MAX, V|D|E, "strict"},

-{"experimental", "allow non standardized experimental things", 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_EXPERIMENTAL }, INT_MIN, INT_MAX, V|D|E, "strict"},

-{"b_qoffset", "qp offset between P and B frames", OFFSET(b_quant_offset), AV_OPT_TYPE_FLOAT, {.dbl = 1.25 }, -FLT_MAX, FLT_MAX, V|E},

-{"err_detect", "set error detection flags", OFFSET(err_recognition), AV_OPT_TYPE_FLAGS, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, A|V|D, "err_detect"},

-{"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, A|V|D, "err_detect"},

-{"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, A|V|D, "err_detect"},

-{"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BUFFER }, INT_MIN, INT_MAX, A|V|D, "err_detect"},

-{"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_EXPLODE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},

-{"careful",    "consider things that violate the spec and have not been seen in the wild as errors", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_CAREFUL }, INT_MIN, INT_MAX, A|V|D, "err_detect"},

-{"compliant",  "consider all spec non compliancies as errors", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_COMPLIANT }, INT_MIN, INT_MAX, A|V|D, "err_detect"},

-{"aggressive", "consider things that a sane encoder shouldnt do as an error", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_AGGRESSIVE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},

-{"has_b_frames", NULL, OFFSET(has_b_frames), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"block_align", NULL, OFFSET(block_align), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"mpeg_quant", "use MPEG quantizers instead of H.263", OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},

-{"stats_out", NULL, OFFSET(stats_out), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX},

-{"stats_in", NULL, OFFSET(stats_in), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX},

-{"qsquish", "how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function)", OFFSET(rc_qsquish), AV_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, 0, 99, V|E},

-{"rc_qmod_amp", "experimental quantizer modulation", OFFSET(rc_qmod_amp), AV_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, -FLT_MAX, FLT_MAX, V|E},

-{"rc_qmod_freq", "experimental quantizer modulation", OFFSET(rc_qmod_freq), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},

-{"rc_override_count", NULL, OFFSET(rc_override_count), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"rc_eq", "set rate control equation", OFFSET(rc_eq), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, V|E},

-{"maxrate", "set max bitrate tolerance (in bits/s)", OFFSET(rc_max_rate), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|A|E},

-{"minrate", "set min bitrate tolerance (in bits/s)", OFFSET(rc_min_rate), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|A|E},

-{"bufsize", "set ratecontrol buffer size (in bits)", OFFSET(rc_buffer_size), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, A|V|E},

-{"rc_buf_aggressivity", "currently useless", OFFSET(rc_buffer_aggressivity), AV_OPT_TYPE_FLOAT, {.dbl = 1.0 }, -FLT_MAX, FLT_MAX, V|E},

-{"i_qfactor", "qp factor between P and I frames", OFFSET(i_quant_factor), AV_OPT_TYPE_FLOAT, {.dbl = -0.8 }, -FLT_MAX, FLT_MAX, V|E},

-{"i_qoffset", "qp offset between P and I frames", OFFSET(i_quant_offset), AV_OPT_TYPE_FLOAT, {.dbl = 0.0 }, -FLT_MAX, FLT_MAX, V|E},

-{"rc_init_cplx", "initial complexity for 1-pass encoding", OFFSET(rc_initial_cplx), AV_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, -FLT_MAX, FLT_MAX, V|E},

-{"dct", "DCT algorithm", OFFSET(dct_algo), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, INT_MAX, V|E, "dct"},

-{"auto", "autoselect a good one (default)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DCT_AUTO }, INT_MIN, INT_MAX, V|E, "dct"},

-{"fastint", "fast integer", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DCT_FASTINT }, INT_MIN, INT_MAX, V|E, "dct"},

-{"int", "accurate integer", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DCT_INT }, INT_MIN, INT_MAX, V|E, "dct"},

-{"mmx", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DCT_MMX }, INT_MIN, INT_MAX, V|E, "dct"},

-{"altivec", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DCT_ALTIVEC }, INT_MIN, INT_MAX, V|E, "dct"},

-{"faan", "floating point AAN DCT", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DCT_FAAN }, INT_MIN, INT_MAX, V|E, "dct"},

-{"lumi_mask", "compresses bright areas stronger than medium ones", OFFSET(lumi_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, V|E},

-{"tcplx_mask", "temporal complexity masking", OFFSET(temporal_cplx_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, V|E},

-{"scplx_mask", "spatial complexity masking", OFFSET(spatial_cplx_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, V|E},

-{"p_mask", "inter masking", OFFSET(p_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, V|E},

-{"dark_mask", "compresses dark areas stronger than medium ones", OFFSET(dark_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, V|E},

-{"idct", "select IDCT implementation", OFFSET(idct_algo), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, INT_MAX, V|E|D, "idct"},

-{"auto", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_AUTO }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"int", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_INT }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"simple", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLE }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"simplemmx", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLEMMX }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"libmpeg2mmx", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_LIBMPEG2MMX }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"mmi", NULL, 0, AV_OPT_TYPE_CONST, { .dbl = FF_IDCT_MMI }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"arm", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_ARM }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"altivec", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_ALTIVEC }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"sh4", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SH4 }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"simplearm", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLEARM }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"simplearmv5te", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLEARMV5TE }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"simplearmv6", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLEARMV6 }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"simpleneon", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLENEON }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"simplealpha", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLEALPHA }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"h264", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_H264 }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"vp3", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_VP3 }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"ipp", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_IPP }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"xvidmmx", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_XVIDMMX }, INT_MIN, INT_MAX, V|E|D, "idct"},

-{"faani", "floating point AAN IDCT", 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_FAAN }, INT_MIN, INT_MAX, V|D|E, "idct"},

-{"slice_count", NULL, OFFSET(slice_count), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"ec", "set error concealment strategy", OFFSET(error_concealment), AV_OPT_TYPE_FLAGS, {.dbl = 3 }, INT_MIN, INT_MAX, V|D, "ec"},

-{"guess_mvs", "iterative motion vector (MV) search (slow)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_EC_GUESS_MVS }, INT_MIN, INT_MAX, V|D, "ec"},

-{"deblock", "use strong deblock filter for damaged MBs", 0, AV_OPT_TYPE_CONST, {.dbl = FF_EC_DEBLOCK }, INT_MIN, INT_MAX, V|D, "ec"},

-{"bits_per_coded_sample", NULL, OFFSET(bits_per_coded_sample), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},

-{"pred", "prediction method", OFFSET(prediction_method), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "pred"},

-{"left", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PRED_LEFT }, INT_MIN, INT_MAX, V|E, "pred"},

-{"plane", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PRED_PLANE }, INT_MIN, INT_MAX, V|E, "pred"},

-{"median", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PRED_MEDIAN }, INT_MIN, INT_MAX, V|E, "pred"},

-{"aspect", "sample aspect ratio", OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, 0, 10, V|E},

-{"debug", "print specific debug info", OFFSET(debug), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, 0, INT_MAX, V|A|S|E|D, "debug"},

-{"pict", "picture info", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_PICT_INFO }, INT_MIN, INT_MAX, V|D, "debug"},

-{"rc", "rate control", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_RC }, INT_MIN, INT_MAX, V|E, "debug"},

-{"bitstream", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_BITSTREAM }, INT_MIN, INT_MAX, V|D, "debug"},

-{"mb_type", "macroblock (MB) type", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_MB_TYPE }, INT_MIN, INT_MAX, V|D, "debug"},

-{"qp", "per-block quantization parameter (QP)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_QP }, INT_MIN, INT_MAX, V|D, "debug"},

-{"mv", "motion vector", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_MV }, INT_MIN, INT_MAX, V|D, "debug"},

-{"dct_coeff", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_DCT_COEFF }, INT_MIN, INT_MAX, V|D, "debug"},

-{"skip", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_SKIP }, INT_MIN, INT_MAX, V|D, "debug"},

-{"startcode", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_STARTCODE }, INT_MIN, INT_MAX, V|D, "debug"},

-{"pts", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_PTS }, INT_MIN, INT_MAX, V|D, "debug"},

-{"er", "error recognition", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_ER }, INT_MIN, INT_MAX, V|D, "debug"},

-{"mmco", "memory management control operations (H.264)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_MMCO }, INT_MIN, INT_MAX, V|D, "debug"},

-{"bugs", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_BUGS }, INT_MIN, INT_MAX, V|D, "debug"},

-{"vis_qp", "visualize quantization parameter (QP), lower QP are tinted greener", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_VIS_QP }, INT_MIN, INT_MAX, V|D, "debug"},

-{"vis_mb_type", "visualize block types", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_VIS_MB_TYPE }, INT_MIN, INT_MAX, V|D, "debug"},

-{"buffers", "picture buffer allocations", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_BUFFERS }, INT_MIN, INT_MAX, V|D, "debug"},

-{"thread_ops", "threading operations", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_THREADS }, INT_MIN, INT_MAX, V|D, "debug"},

-{"vismv", "visualize motion vectors (MVs)", OFFSET(debug_mv), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, INT_MAX, V|D, "debug_mv"},

-{"pf", "forward predicted MVs of P-frames", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_VIS_MV_P_FOR }, INT_MIN, INT_MAX, V|D, "debug_mv"},

-{"bf", "forward predicted MVs of B-frames", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_VIS_MV_B_FOR }, INT_MIN, INT_MAX, V|D, "debug_mv"},

-{"bb", "backward predicted MVs of B-frames", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_VIS_MV_B_BACK }, INT_MIN, INT_MAX, V|D, "debug_mv"},

-{"cmp", "full pel me compare function", OFFSET(me_cmp), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"subcmp", "sub pel me compare function", OFFSET(me_sub_cmp), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"mbcmp", "macroblock compare function", OFFSET(mb_cmp), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"ildctcmp", "interlaced dct compare function", OFFSET(ildct_cmp), AV_OPT_TYPE_INT, {.dbl = FF_CMP_VSAD }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"dia_size", "diamond type & size for motion estimation", OFFSET(dia_size), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},

-{"last_pred", "amount of motion predictors from the previous frame", OFFSET(last_predictor_count), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},

-{"preme", "pre motion estimation", OFFSET(pre_me), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},

-{"precmp", "pre motion estimation compare function", OFFSET(me_pre_cmp), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"sad", "sum of absolute differences, fast (default)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_SAD }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"sse", "sum of squared errors", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_SSE }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"satd", "sum of absolute Hadamard transformed differences", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_SATD }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"dct", "sum of absolute DCT transformed differences", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_DCT }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"psnr", "sum of squared quantization errors (avoid, low quality)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_PSNR }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"bit", "number of bits needed for the block", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_BIT }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"rd", "rate distortion optimal, slow", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_RD }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"zero", "0", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_ZERO }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"vsad", "sum of absolute vertical differences", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_VSAD }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"vsse", "sum of squared vertical differences", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_VSSE }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"nsse", "noise preserving sum of squared differences", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_NSSE }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-#if CONFIG_SNOW_ENCODER

-{"w53", "5/3 wavelet, only used in snow", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_W53 }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-{"w97", "9/7 wavelet, only used in snow", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_W97 }, INT_MIN, INT_MAX, V|E, "cmp_func"},

-#endif