Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 20 Mar 2012 23:15:18 +0000 (00:15 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 21 Mar 2012 00:33:53 +0000 (01:33 +0100)
* qatar/master: (27 commits)
  avconv: free packet in write_frame() when discarding due to frame number limit
  FATE: use +/- flag option syntax for vp8 emu-edge tests
  lavf: make av_interleave_packet_per_dts() private.
  lavf: deprecate av_read_packet().
  oggdec: output correct timestamps for Vorbis
  avconv: pass input stream timestamps to audio encoders
  lavc: shrink encoded audio packet size after encoding.
  xa: set correct bit rate
  xa: do not set bit_rate, block_align, or bits_per_coded_sample
  xa: fix end-of-file handling
  xa: fix timestamp calculation
  bink: fix typo in FFALIGN() argument
  bink: align plane width to 8 when calculating bundle sizes
  doc: pass -Idoc texi2html and texi2pod
  doc: texi2pod: add -I flag
  movenc: Add a min_frag_duration option
  rtsp: Set the default delay to 0.1 s for the RTSP/SDP/RTP demuxers
  libavformat: Set the default for the max_delay option to -1
  Generate manpages for AV{Format,Codec}Context AVOptions.
  doc/avconv: remove entries for AVOptions.
  ...

Conflicts:
doc/Makefile
doc/ffmpeg.texi
doc/muxers.texi
ffmpeg.c
libavcodec/Makefile
libavcodec/options.c
libavcodec/vp8.c
libavformat/options.c
tests/fate/demux.mak
tests/ref/fate/truemotion1-15
tests/ref/fate/truemotion1-24

Merged-by: Michael Niedermayer <michaelni@gmx.at>
33 files changed:
1  2 
Makefile
doc/Makefile
doc/avtools-common-opts.texi
doc/ffmpeg.texi
doc/muxers.texi
doc/protocols.texi
ffmpeg.c
libavcodec/Makefile
libavcodec/bink.c
libavcodec/options.c
libavcodec/options_table.h
libavcodec/utils.c
libavcodec/vp8.c
libavformat/avformat.h
libavformat/avidec.c
libavformat/gxfenc.c
libavformat/id3v2.c
libavformat/internal.h
libavformat/movenc.c
libavformat/movenc.h
libavformat/mpegenc.c
libavformat/mpegtsenc.c
libavformat/options.c
libavformat/options_table.h
libavformat/rtpdec_asf.c
libavformat/rtpenc.c
libavformat/rtsp.c
libavformat/utils.c
libavformat/version.h
libavformat/xa.c
tests/fate/demux.mak
tests/ref/fate/truemotion1-15
tests/ref/fate/truemotion1-24

diff --cc Makefile
+++ b/Makefile
@@@ -8,18 -6,61 +8,18 @@@ vpath %.S    $(SRC_PATH
  vpath %.asm  $(SRC_PATH)
  vpath %.v    $(SRC_PATH)
  vpath %.texi $(SRC_PATH)
 +vpath %/fate_config.sh.template $(SRC_PATH)
  
 -ifndef V
 -Q      = @
 -ECHO   = printf "$(1)\t%s\n" $(2)
 -BRIEF  = CC AS YASM AR LD HOSTCC
 -SILENT = DEPCC YASMDEP RM RANLIB
 -MSG    = $@
 -M      = @$(call ECHO,$(TAG),$@);
 -$(foreach VAR,$(BRIEF), \
 -    $(eval override $(VAR) = @$$(call ECHO,$(VAR),$$(MSG)); $($(VAR))))
 -$(foreach VAR,$(SILENT),$(eval override $(VAR) = @$($(VAR))))
 -$(eval INSTALL = @$(call ECHO,INSTALL,$$(^:$(SRC_PATH)/%=%)); $(INSTALL))
 -endif
 -
 -ALLFFLIBS = avcodec avdevice avfilter avformat avutil swscale
 -
 -IFLAGS     := -I. -I$(SRC_PATH)
 -CPPFLAGS   := $(IFLAGS) $(CPPFLAGS)
 -CFLAGS     += $(ECFLAGS)
 -CCFLAGS     = $(CFLAGS)
 -YASMFLAGS  += $(IFLAGS) -I$(SRC_PATH)/libavutil/x86/ -Pconfig.asm
 -HOSTCFLAGS += $(IFLAGS)
 -LDFLAGS    := $(ALLFFLIBS:%=-Llib%) $(LDFLAGS)
 -
 -define COMPILE
 -      $($(1)DEP)
 -      $($(1)) $(CPPFLAGS) $($(1)FLAGS) $($(1)_DEPFLAGS) -c $($(1)_O) $<
 -endef
 -
 -COMPILE_C = $(call COMPILE,CC)
 -COMPILE_S = $(call COMPILE,AS)
 -
 -%.o: %.c
 -      $(COMPILE_C)
 -
 -%.o: %.S
 -      $(COMPILE_S)
 -
 -%.ho: %.h
 -      $(CC) $(CPPFLAGS) $(CFLAGS) -Wno-unused -c -o $@ -x c $<
 -
 -%.ver: %.v
 -      $(Q)sed 's/$$MAJOR/$($(basename $(@F))_VERSION_MAJOR)/' $^ > $@
 -
 -%.c %.h: TAG = GEN
 -
 -PROGS-$(CONFIG_AVCONV)   += avconv
 -PROGS-$(CONFIG_AVPLAY)   += avplay
 -PROGS-$(CONFIG_AVPROBE)  += avprobe
 -PROGS-$(CONFIG_AVSERVER) += avserver
 +PROGS-$(CONFIG_FFMPEG)   += ffmpeg
 +PROGS-$(CONFIG_FFPLAY)   += ffplay
 +PROGS-$(CONFIG_FFPROBE)  += ffprobe
 +PROGS-$(CONFIG_FFSERVER) += ffserver
  
  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
  
diff --cc doc/Makefile
@@@ -21,25 -15,29 +21,34 @@@ all-$(CONFIG_DOC): documentatio
  
  documentation: $(DOCS)
  
 -TEXIDEP = awk '/^@include/ { printf "$@: $(@D)/%s\n", $$2 }' <$< >$(@:%=%.d)
 +TEXIDEP = awk '/^@(verbatim)?include/ { printf "$@: $(@D)/%s\n", $$2 }' <$< >$(@:%=%.d)
 +
 +doc/%.txt: TAG = TXT
 +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 -55,7 +66,7 @@@ uninstall-man
        $(RM) $(addprefix "$(MANDIR)/man1/",$(ALLMANPAGES))
  
  clean::
-       $(RM) $(TXTPAGES) doc/*.html doc/*.pod doc/*.1 $(CLEANSUFFIXES:%=doc/%)
 -      $(RM) doc/*.html doc/*.pod doc/*.1 $(CLEANSUFFIXES:%=doc/%) doc/avoptions_*.texi
++      $(RM) $(TXTPAGES) doc/*.html doc/*.pod doc/*.1 $(CLEANSUFFIXES:%=doc/%) doc/avoptions_*.texi
  
  -include $(wildcard $(DOCS:%=%.d))
  
Simple merge
diff --cc doc/ffmpeg.texi
@@@ -353,42 -328,9 +353,24 @@@ form @var{num}:@var{den}, where @var{nu
  numerator and denominator of the aspect ratio. For example "4:3",
  "16:9", "1.3333", and "1.7777" are valid argument values.
  
 +@item -croptop @var{size}
 +@item -cropbottom @var{size}
 +@item -cropleft @var{size}
 +@item -cropright @var{size}
 +All the crop options have been removed. Use -vf
 +crop=width:height:x:y instead.
 +
 +@item -padtop @var{size}
 +@item -padbottom @var{size}
 +@item -padleft @var{size}
 +@item -padright @var{size}
 +@item -padcolor @var{hex_color}
 +All the pad options have been removed. Use -vf
 +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 -374,11 +417,14 @@@ Set pixel format. Use @code{-pix_fmts} 
  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
 +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,30 -439,6 +495,8 @@@ 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
  
  @section Subtitle options:
@@@ -945,38 -570,21 +722,34 @@@ Exit after ffmpeg has been running for 
  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 -threads @var{count}
- Thread count.
 +@item -loop_input
 +Loop over the input stream. Currently it works only for image
 +streams. This option is used for automatic FFserver testing.
 +This option is deprecated, use -loop 1.
 +@item -loop_output @var{number_of_times}
 +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 -vsync @var{parameter}
  Video sync method.
 +For compatibility reasons old values can be specified as numbers.
 +Newly added values will have to be specified as strings always.
  
  @table @option
 -@item passthrough
 +@item 0, passthrough
  Each frame is passed with its timestamp from the demuxer to the muxer.
 -@item cfr
 +@item 1, cfr
  Frames will be duplicated and dropped to achieve exactly the requested
  constant framerate.
 -@item vfr
 +@item 2, vfr
  Frames are passed through with their timestamp or dropped so as to
  prevent 2 frames from having the same timestamp.
 -@item auto
 +@item drop
 +As passthrough but destroys all timestamps, making the muxer generate
 +fresh timestamps based on frame-rate.
 +@item -1, auto
  Chooses between 1 and 2 depending on muxer capabilities. This is the
  default method.
  @end table
@@@ -1294,6 -861,19 +1067,19 @@@ ffmpeg -i test1.avi -i test2.avi -map 0
  The resulting output file @file{test12.avi} will contain first four streams from
  the input file in reverse order.
  
 -avconv -i myfile.avi -b 4000k -minrate 4000k -maxrate 4000k -bufsize 1835k out.m2v
+ @item
+ To force CBR video output:
+ @example
 -avconv -i src.ext -lmax 21*QP2LAMBDA dst.ext
++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
  
diff --cc doc/muxers.texi
@@@ -180,9 -171,16 +180,16 @@@ Create fragments that contain up to @va
  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{avconv}.)
 +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:
  
@@@ -318,11 -288,11 +318,11 @@@ Accept packets only from negotiated pee
  @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 @file{avplay}, the
 +When watching multi-bitrate Real-RTSP streams with @command{ffplay}, the
  streams to display can be chosen with @code{-vst} @var{n} and
  @code{-ast} @var{n} for video and audio respectively, and can be switched
  on the fly by pressing @code{v} and @code{a}.
diff --cc ffmpeg.c
+++ b/ffmpeg.c
@@@ -1083,6 -978,10 +1085,7 @@@ static int encode_audio_frame(AVFormatC
              exit_program(1);
          }
  
 -        if (!check_recording_time(ost))
 -            return 0;
 -
+         frame->pts = ost->sync_opts;
          ost->sync_opts += frame->nb_samples;
      }
  
@@@ -5055,17 -4523,6 +5058,17 @@@ static const OptionDef options[] = 
      { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
      { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
      { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
-     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
 +    { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
 +    { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
 +    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
 +    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
 +    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
 +    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
 +    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
 +    { "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}, "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" },
@@@ -613,12 -567,10 +613,12 @@@ OBJS-$(CONFIG_MOV_DEMUXER)             
  OBJS-$(CONFIG_MOV_MUXER)               += mpeg4audio.o mpegaudiodata.o
  OBJS-$(CONFIG_MPEGTS_MUXER)            += mpegvideo.o mpeg4audio.o
  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
 -OBJS-$(CONFIG_OGG_MUXER)               += xiph.o flacdec.o flacdata.o flac.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
  OBJS-$(CONFIG_SPDIF_DEMUXER)           += aacadtsdec.o mpeg4audio.o
  OBJS-$(CONFIG_WEBM_MUXER)              += xiph.o mpeg4audio.o \
@@@ -146,9 -146,11 +146,11 @@@ 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 >> 4) + 511) + 1;
 +    c->bundle[BINK_SRC_SUB_BLOCK_TYPES].len = av_log2(((width + 7) >> 4) + 511) + 1;
  
      c->bundle[BINK_SRC_COLORS].len = av_log2(bw*64 + 511) + 1;
  
Simple merge
index 0000000,6615ade..be4f5f4
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,401 +1,408 @@@
 - * This file is part of Libav.
+ /*
++ * Copyright (c) 2001 Fabrice Bellard
++ * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg 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
 -{"b", "set bitrate (in bits/s)", OFFSET(bit_rate), AV_OPT_TYPE_INT, {.dbl = AV_CODEC_DEFAULT_BITRATE }, INT_MIN, INT_MAX, V|A|E},
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #ifndef AVCODEC_OPTIONS_TABLE
+ #define AVCODEC_OPTIONS_TABLE
+ #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[]={
 -{"qmax", "max video quantizer scale (VBR)", OFFSET(qmax), AV_OPT_TYPE_INT, {.dbl = 31 }, -1, 69, V|E},
++{"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). 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.",
+        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). Constant of ratecontrol equation. "
+           "Recommended range for default rc_eq: 0.0-1.0",
+           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},
 -{"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BUFFER }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_EXPLODE }, INT_MIN, INT_MAX, V|D, "err_detect"},
++{"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"},
 -{"keyint_min", "minimum interval between IDR-frames (x264)", OFFSET(keyint_min), AV_OPT_TYPE_INT, {.dbl = 25 }, INT_MIN, INT_MAX, V|E},
 -{"refs", "reference frames to consider for motion compensation (Snow)", OFFSET(refs), AV_OPT_TYPE_INT, {.dbl = 1 }, INT_MIN, INT_MAX, V|E},
++{"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. When computing the expression, besides the standard functions "
+           "defined in the section 'Expression Evaluation', the following functions are available: "
+           "bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv "
+           "fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.",
+           OFFSET(rc_eq), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, V|E},
+ {"maxrate", "Set max bitrate tolerance (in bits/s). Requires bufsize to be set.", 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). Most useful in setting up a CBR encode. It is of little use elsewise.",
+             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
+ {"dctmax", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, V|E, "cmp_func"},
+ {"chroma", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_CMP_CHROMA }, INT_MIN, INT_MAX, V|E, "cmp_func"},
+ {"pre_dia_size", "diamond type & size for motion estimation pre-pass", OFFSET(pre_dia_size), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ {"subq", "sub pel motion estimation quality", OFFSET(me_subpel_quality), AV_OPT_TYPE_INT, {.dbl = 8 }, INT_MIN, INT_MAX, V|E},
+ {"dtg_active_format", NULL, OFFSET(dtg_active_format), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
+ {"me_range", "limit motion vectors range (1023 for DivX player)", OFFSET(me_range), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ {"ibias", "intra quant bias", OFFSET(intra_quant_bias), AV_OPT_TYPE_INT, {.dbl = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, V|E},
+ {"pbias", "inter quant bias", OFFSET(inter_quant_bias), AV_OPT_TYPE_INT, {.dbl = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, V|E},
+ #if FF_API_COLOR_TABLE_ID
+ {"color_table_id", NULL, OFFSET(color_table_id), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
+ #endif
+ {"global_quality", NULL, OFFSET(global_quality), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
+ {"coder", NULL, OFFSET(coder_type), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "coder"},
+ {"vlc", "variable length coder / huffman coder", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CODER_TYPE_VLC }, INT_MIN, INT_MAX, V|E, "coder"},
+ {"ac", "arithmetic coder", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CODER_TYPE_AC }, INT_MIN, INT_MAX, V|E, "coder"},
+ {"raw", "raw (no encoding)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CODER_TYPE_RAW }, INT_MIN, INT_MAX, V|E, "coder"},
+ {"rle", "run-length coder", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CODER_TYPE_RLE }, INT_MIN, INT_MAX, V|E, "coder"},
+ {"deflate", "deflate-based coder", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CODER_TYPE_DEFLATE }, INT_MIN, INT_MAX, V|E, "coder"},
+ {"context", "context model", OFFSET(context_model), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ {"slice_flags", NULL, OFFSET(slice_flags), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
+ {"xvmc_acceleration", NULL, OFFSET(xvmc_acceleration), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
+ {"mbd", "macroblock decision algorithm (high quality mode)", OFFSET(mb_decision), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "mbd"},
+ {"simple", "use mbcmp (default)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_MB_DECISION_SIMPLE }, INT_MIN, INT_MAX, V|E, "mbd"},
+ {"bits", "use fewest bits", 0, AV_OPT_TYPE_CONST, {.dbl = FF_MB_DECISION_BITS }, INT_MIN, INT_MAX, V|E, "mbd"},
+ {"rd", "use best rate distortion", 0, AV_OPT_TYPE_CONST, {.dbl = FF_MB_DECISION_RD }, INT_MIN, INT_MAX, V|E, "mbd"},
+ {"stream_codec_tag", NULL, OFFSET(stream_codec_tag), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
+ {"sc_threshold", "scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ {"lmin", "min lagrange factor (VBR)", OFFSET(lmin), AV_OPT_TYPE_INT, {.dbl =  2*FF_QP2LAMBDA }, 0, INT_MAX, V|E},
+ {"lmax", "max lagrange factor (VBR)", OFFSET(lmax), AV_OPT_TYPE_INT, {.dbl = 31*FF_QP2LAMBDA }, 0, INT_MAX, V|E},
+ {"nr", "noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ {"rc_init_occupancy", "number of bits which should be loaded into the rc buffer before decoding starts", OFFSET(rc_initial_buffer_occupancy), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ #if FF_API_INTER_THRESHOLD
+ {"inter_threshold", NULL, OFFSET(inter_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ #endif
+ {"flags2", NULL, OFFSET(flags2), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT}, 0, UINT_MAX, V|A|E|D, "flags2"},
+ {"error", NULL, OFFSET(error_rate), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ #if FF_API_MPV_GLOBAL_OPTS
+ {"qns", "deprecated, use mpegvideo private options instead", OFFSET(quantizer_noise_shaping), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ #endif
+ {"threads", NULL, OFFSET(thread_count), AV_OPT_TYPE_INT, {.dbl = 1 }, 0, INT_MAX, V|E|D, "threads"},
+ {"auto", "detect a good number of threads", 0, AV_OPT_TYPE_CONST, {.dbl = 0 }, INT_MIN, INT_MAX, V|E|D, "threads"},
+ {"me_threshold", "motion estimaton threshold", OFFSET(me_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ {"mb_threshold", "macroblock threshold", OFFSET(mb_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ {"dc", "intra_dc_precision", OFFSET(intra_dc_precision), AV_OPT_TYPE_INT, {.dbl = 0 }, INT_MIN, INT_MAX, V|E},
+ {"nssew", "nsse weight", OFFSET(nsse_weight), AV_OPT_TYPE_INT, {.dbl = 8 }, INT_MIN, INT_MAX, V|E},
+ {"skip_top", "number of macroblock rows at the top which are skipped", OFFSET(skip_top), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|D},
+ {"skip_bottom", "number of macroblock rows at the bottom which are skipped", OFFSET(skip_bottom), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|D},
+ {"profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT, {.dbl = FF_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "profile"},
+ {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "profile"},
+ {"aac_main", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_AAC_MAIN }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"aac_low", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_AAC_LOW }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"aac_ssr", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_AAC_SSR }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"aac_ltp", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_AAC_LTP }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"dts", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_DTS }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"dts_es", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_DTS_ES }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"dts_96_24", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_DTS_96_24 }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"dts_hd_hra", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_DTS_HD_HRA }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"dts_hd_ma", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_DTS_HD_MA }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"level", NULL, OFFSET(level), AV_OPT_TYPE_INT, {.dbl = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "level"},
+ {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "level"},
+ {"lowres", "decode at 1= 1/2, 2=1/4, 3=1/8 resolutions", OFFSET(lowres), AV_OPT_TYPE_INT, {.dbl = 0 }, 0, INT_MAX, V|A|D},
+ {"skip_threshold", "frame skip threshold", OFFSET(frame_skip_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ {"skip_factor", "frame skip factor", OFFSET(frame_skip_factor), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ {"skip_exp", "frame skip exponent", OFFSET(frame_skip_exp), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ {"skipcmp", "frame skip compare function", OFFSET(frame_skip_cmp), AV_OPT_TYPE_INT, {.dbl = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, V|E, "cmp_func"},
+ {"border_mask", "increases the quantizer for macroblocks close to borders", OFFSET(border_masking), AV_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, -FLT_MAX, FLT_MAX, V|E},
+ {"mblmin", "min macroblock lagrange factor (VBR)", OFFSET(mb_lmin), AV_OPT_TYPE_INT, {.dbl = FF_QP2LAMBDA * 2 }, 1, FF_LAMBDA_MAX, V|E},
+ {"mblmax", "max macroblock lagrange factor (VBR)", OFFSET(mb_lmax), AV_OPT_TYPE_INT, {.dbl = FF_QP2LAMBDA * 31 }, 1, FF_LAMBDA_MAX, V|E},
+ {"mepc", "motion estimation bitrate penalty compensation (1.0 = 256)", OFFSET(me_penalty_compensation), AV_OPT_TYPE_INT, {.dbl = 256 }, INT_MIN, INT_MAX, V|E},
+ {"skip_loop_filter", NULL, OFFSET(skip_loop_filter), AV_OPT_TYPE_INT, {.dbl = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"skip_idct"       , NULL, OFFSET(skip_idct)       , AV_OPT_TYPE_INT, {.dbl = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"skip_frame"      , NULL, OFFSET(skip_frame)      , AV_OPT_TYPE_INT, {.dbl = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"none"            , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_NONE    }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"default"         , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"noref"           , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_NONREF  }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"bidir"           , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_BIDIR   }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"nokey"           , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_NONKEY  }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"all"             , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_ALL     }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"bidir_refine", "refine the two motion vectors used in bidirectional macroblocks", OFFSET(bidir_refine), AV_OPT_TYPE_INT, {.dbl = 1 }, 0, 4, V|E},
+ {"brd_scale", "downscales frames for dynamic B-frame decision", OFFSET(brd_scale), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, 10, V|E},
 -{"request_sample_fmt", NULL, OFFSET(request_sample_fmt), AV_OPT_TYPE_INT, {.dbl = AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE, AV_SAMPLE_FMT_NB-1, A|D, "request_sample_fmt"},
++{"keyint_min", "minimum interval between IDR-frames", OFFSET(keyint_min), AV_OPT_TYPE_INT, {.dbl = 25 }, INT_MIN, INT_MAX, V|E},
++{"refs", "reference frames to consider for motion compensation", OFFSET(refs), AV_OPT_TYPE_INT, {.dbl = 1 }, INT_MIN, INT_MAX, V|E},
+ {"chromaoffset", "chroma qp offset from luma", OFFSET(chromaoffset), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+ {"trellis", "rate-distortion optimal quantization", OFFSET(trellis), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
+ #if FF_API_MPV_GLOBAL_OPTS
+ {"skiprd", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_SKIP_RD }, INT_MIN, INT_MAX, V|E, "flags2"},
+ #endif
+ {"sc_factor", "multiplied by qscale for each frame and added to scene_change_score", OFFSET(scenechange_factor), AV_OPT_TYPE_INT, {.dbl = 6 }, 0, INT_MAX, V|E},
+ {"mv0_threshold", NULL, OFFSET(mv0_threshold), AV_OPT_TYPE_INT, {.dbl = 256 }, 0, INT_MAX, V|E},
+ {"b_sensitivity", "adjusts sensitivity of b_frame_strategy 1", OFFSET(b_sensitivity), AV_OPT_TYPE_INT, {.dbl = 40 }, 1, INT_MAX, V|E},
+ {"compression_level", NULL, OFFSET(compression_level), AV_OPT_TYPE_INT, {.dbl = FF_COMPRESSION_DEFAULT }, INT_MIN, INT_MAX, V|A|E},
+ {"min_prediction_order", NULL, OFFSET(min_prediction_order), AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX, A|E},
+ {"max_prediction_order", NULL, OFFSET(max_prediction_order), AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX, A|E},
+ {"timecode_frame_start", "GOP timecode frame start number, in non drop frame format", OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.dbl = 0 }, 0, INT64_MAX, V|E},
+ #if FF_API_REQUEST_CHANNELS
+ {"request_channels", "set desired number of audio channels", OFFSET(request_channels), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, INT_MAX, A|D},
+ #endif
+ {"bits_per_raw_sample", NULL, OFFSET(bits_per_raw_sample), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
+ {"channel_layout", NULL, OFFSET(channel_layout), AV_OPT_TYPE_INT64, {.dbl = DEFAULT }, 0, INT64_MAX, A|E|D, "channel_layout"},
+ {"request_channel_layout", NULL, OFFSET(request_channel_layout), AV_OPT_TYPE_INT64, {.dbl = DEFAULT }, 0, INT64_MAX, A|D, "request_channel_layout"},
+ {"rc_max_vbv_use", NULL, OFFSET(rc_max_available_vbv_use), AV_OPT_TYPE_FLOAT, {.dbl = 1.0/3 }, 0.0, FLT_MAX, V|E},
+ {"rc_min_vbv_use", NULL, OFFSET(rc_min_vbv_overflow_use),  AV_OPT_TYPE_FLOAT, {.dbl = 3 },     0.0, FLT_MAX, V|E},
+ {"ticks_per_frame", NULL, OFFSET(ticks_per_frame), AV_OPT_TYPE_INT, {.dbl = 1 }, 1, INT_MAX, A|V|E|D},
+ {"color_primaries", NULL, OFFSET(color_primaries), AV_OPT_TYPE_INT, {.dbl = AVCOL_PRI_UNSPECIFIED }, 1, AVCOL_PRI_NB-1, V|E|D},
+ {"color_trc", NULL, OFFSET(color_trc), AV_OPT_TYPE_INT, {.dbl = AVCOL_TRC_UNSPECIFIED }, 1, AVCOL_TRC_NB-1, V|E|D},
+ {"colorspace", NULL, OFFSET(colorspace), AV_OPT_TYPE_INT, {.dbl = AVCOL_SPC_UNSPECIFIED }, 1, AVCOL_SPC_NB-1, V|E|D},
+ {"color_range", NULL, OFFSET(color_range), AV_OPT_TYPE_INT, {.dbl = AVCOL_RANGE_UNSPECIFIED }, 0, AVCOL_RANGE_NB-1, V|E|D},
+ {"chroma_sample_location", NULL, OFFSET(chroma_sample_location), AV_OPT_TYPE_INT, {.dbl = AVCHROMA_LOC_UNSPECIFIED }, 0, AVCHROMA_LOC_NB-1, V|E|D},
+ {"log_level_offset", "set the log level offset", OFFSET(log_level_offset), AV_OPT_TYPE_INT, {.dbl = 0 }, INT_MIN, INT_MAX },
+ {"slices", "number of slices, used in parallelized encoding", OFFSET(slices), AV_OPT_TYPE_INT, {.dbl = 0 }, 0, INT_MAX, V|E},
+ {"thread_type", "select multithreading type", OFFSET(thread_type), AV_OPT_TYPE_FLAGS, {.dbl = FF_THREAD_SLICE|FF_THREAD_FRAME }, 0, INT_MAX, V|E|D, "thread_type"},
+ {"slice", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_THREAD_SLICE }, INT_MIN, INT_MAX, V|E|D, "thread_type"},
+ {"frame", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_THREAD_FRAME }, INT_MIN, INT_MAX, V|E|D, "thread_type"},
+ {"audio_service_type", "audio service type", OFFSET(audio_service_type), AV_OPT_TYPE_INT, {.dbl = AV_AUDIO_SERVICE_TYPE_MAIN }, 0, AV_AUDIO_SERVICE_TYPE_NB-1, A|E, "audio_service_type"},
+ {"ma", "Main Audio Service", 0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_MAIN },              INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"ef", "Effects",            0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_EFFECTS },           INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"vi", "Visually Impaired",  0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED }, INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"hi", "Hearing Impaired",   0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED },  INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"di", "Dialogue",           0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_DIALOGUE },          INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"co", "Commentary",         0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_COMMENTARY },        INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"em", "Emergency",          0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_EMERGENCY },         INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"vo", "Voice Over",         0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_VOICE_OVER },        INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"ka", "Karaoke",            0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_KARAOKE },           INT_MIN, INT_MAX, A|E, "audio_service_type"},
++{"request_sample_fmt", "sample format audio decoders should prefer", OFFSET(request_sample_fmt), AV_OPT_TYPE_INT, {.dbl = AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE, AV_SAMPLE_FMT_NB-1, A|D, "request_sample_fmt"},
+ {"u8" , "8-bit unsigned integer", 0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_U8  }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"s16", "16-bit signed integer",  0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_S16 }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"s32", "32-bit signed integer",  0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_S32 }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"flt", "32-bit float",           0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_FLT }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"dbl", "64-bit double",          0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_DBL }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {NULL},
+ };
+ #undef A
+ #undef V
+ #undef S
+ #undef E
+ #undef D
+ #undef DEFAULT
+ #undef OFFSET
+ #endif // AVCODEC_OPTIONS_TABLE
Simple merge
@@@ -639,10 -639,9 +639,10 @@@ void decode_mb_mode(VP8Context *s, VP8M
  {
      VP56RangeCoder *c = &s->c;
  
 -    if (s->segmentation.update_map)
 -        *segment = vp8_rac_get_tree(c, vp8_segmentid_tree, s->prob->segmentid);
 -    else if (s->segmentation.enabled)
 +    if (s->segmentation.update_map) {
 +        int bit  = vp56_rac_get_prob(c, s->prob->segmentid[0]);
 +        *segment = vp56_rac_get_prob(c, s->prob->segmentid[1+bit]) + 2*bit;
-     } else
++    } else if (s->segmentation.enabled)
          *segment = ref ? *ref : *segment;
      s->segment = *segment;
  
Simple merge
Simple merge
@@@ -991,21 -936,9 +991,21 @@@ static int gxf_interleave_packet(AVForm
      if (pkt && s->streams[pkt->stream_index]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
          pkt->duration = 2; // enforce 2 fields
      return ff_audio_rechunk_interleave(s, out, pkt, flush,
-                                av_interleave_packet_per_dts, gxf_compare_field_nb);
+                                ff_interleave_packet_per_dts, gxf_compare_field_nb);
  }
  
 +static const AVOption options[] = {
 +    { AV_TIMECODE_OPTION(GXFContext, tc.str, AV_OPT_FLAG_ENCODING_PARAM) },
 +    { NULL }
 +};
 +
 +static const AVClass gxf_muxer_class = {
 +    .class_name     = "GXF muxer",
 +    .item_name      = av_default_item_name,
 +    .option         = options,
 +    .version        = LIBAVUTIL_VERSION_INT,
 +};
 +
  AVOutputFormat ff_gxf_muxer = {
      .name              = "gxf",
      .long_name         = NULL_IF_CONFIG_SMALL("GXF format"),
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 0000000,683596c..0313839
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,62 +1,73 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * This file is part of FFmpeg.
++ *
++ * FFmpeg 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #ifndef AVFORMAT_OPTIONS_TABLE
+ #define AVFORMAT_OPTIONS_TABLE
+ #define OFFSET(x) offsetof(AVFormatContext,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 E AV_OPT_FLAG_ENCODING_PARAM
+ #define D AV_OPT_FLAG_DECODING_PARAM
+ static const AVOption options[]={
+ {"probesize", "set probing size", OFFSET(probesize), AV_OPT_TYPE_INT, {.dbl = 5000000 }, 32, INT_MAX, D},
+ {"packetsize", "set packet size", OFFSET(packet_size), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, INT_MAX, E},
+ {"fflags", NULL, OFFSET(flags), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, INT_MIN, INT_MAX, D|E, "fflags"},
+ {"ignidx", "ignore index", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_IGNIDX }, INT_MIN, INT_MAX, D, "fflags"},
+ {"genpts", "generate pts", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_GENPTS }, INT_MIN, INT_MAX, D, "fflags"},
+ {"nofillin", "do not fill in missing values that can be exactly calculated", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_NOFILLIN }, INT_MIN, INT_MAX, D, "fflags"},
+ {"noparse", "disable AVParsers, this needs nofillin too", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_NOPARSE }, INT_MIN, INT_MAX, D, "fflags"},
+ {"igndts", "ignore dts", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_IGNDTS }, INT_MIN, INT_MAX, D, "fflags"},
+ {"discardcorrupt", "discard corrupted frames", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_DISCARD_CORRUPT }, INT_MIN, INT_MAX, D, "fflags"},
++{"sortdts", "try to interleave outputted packets by dts", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_SORT_DTS }, INT_MIN, INT_MAX, D, "fflags"},
++{"keepside", "dont merge side data", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_KEEP_SIDE_DATA }, INT_MIN, INT_MAX, D, "fflags"},
++{"latm", "enable RTP MP4A-LATM payload", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_MP4A_LATM }, INT_MIN, INT_MAX, E, "fflags"},
+ {"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), AV_OPT_TYPE_INT, {.dbl = 5*AV_TIME_BASE }, 0, INT_MAX, D},
+ {"cryptokey", "decryption key", OFFSET(key), AV_OPT_TYPE_BINARY, {.dbl = 0}, 0, 0, D},
+ {"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), AV_OPT_TYPE_INT, {.dbl = 1<<20 }, 0, INT_MAX, D},
+ {"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), AV_OPT_TYPE_INT, {.dbl = 3041280 }, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */
+ {"fdebug", "print specific debug info", OFFSET(debug), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, 0, INT_MAX, E|D, "fdebug"},
+ {"ts", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_FDEBUG_TS }, INT_MIN, INT_MAX, E|D, "fdebug"},
+ {"max_delay", "maximum muxing or demuxing delay in microseconds", OFFSET(max_delay), AV_OPT_TYPE_INT, {.dbl = -1 }, -1, INT_MAX, E|D},
+ {"fpsprobesize", "number of frames used to probe fps", OFFSET(fps_probe_size), AV_OPT_TYPE_INT, {.dbl = -1}, -1, INT_MAX-1, D},
++{"audio_preload", "microseconds by which audio packets should be interleaved earlier", OFFSET(audio_preload), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX-1, E},
++{"chunk_duration", "microseconds for each chunk", OFFSET(max_chunk_duration), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX-1, E},
++{"chunk_size", "size in bytes for each chunk", OFFSET(max_chunk_size), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX-1, E},
+ /* this is a crutch for avconv, since it cannot deal with identically named options in different contexts.
+  * to be removed when avconv is fixed */
+ {"f_err_detect", "set error detection flags (deprecated; use err_detect, save via avconv)", OFFSET(error_recognition), AV_OPT_TYPE_FLAGS, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, D, "err_detect"},
+ {"err_detect", "set error detection flags", OFFSET(error_recognition), AV_OPT_TYPE_FLAGS, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, D, "err_detect"},
+ {"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, D, "err_detect"},
+ {"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, D, "err_detect"},
+ {"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BUFFER }, INT_MIN, INT_MAX, D, "err_detect"},
+ {"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_EXPLODE }, INT_MIN, INT_MAX, 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, D, "err_detect"},
++{"compliant",  "consider all spec non compliancies as errors", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_COMPLIANT }, INT_MIN, INT_MAX, 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, D, "err_detect"},
+ {NULL},
+ };
+ #undef E
+ #undef D
+ #undef DEFAULT
+ #undef OFFSET
+ #endif // AVFORMAT_OPTIONS_TABLE
Simple merge
Simple merge
Simple merge
@@@ -627,15 -586,9 +639,9 @@@ int avformat_open_input(AVFormatContex
          goto fail;
      ff_id3v2_free_extra_meta(&id3v2_extra_meta);
  
-     /* queue attached pictures */
-     for (i = 0; i < s->nb_streams; i++)
-         if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC) {
-             AVPacket copy = s->streams[i]->attached_pic;
-             copy.destruct = NULL;
-             add_to_pktbuf(&s->raw_packet_buffer, &copy, &s->raw_packet_buffer_end);
-         }
+     queue_attached_pictures(s);
  
 -    if (s->pb && !s->data_offset)
 +    if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
          s->data_offset = avio_tell(s->pb);
  
      s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
@@@ -756,19 -698,16 +762,27 @@@ int ff_read_packet(AVFormatContext *s, 
      }
  }
  
+ #if FF_API_READ_PACKET
+ int av_read_packet(AVFormatContext *s, AVPacket *pkt)
+ {
+     return ff_read_packet(s, pkt);
+ }
+ #endif
  /**********************************************************/
  
 +static int determinable_frame_size(AVCodecContext *avctx)
 +{
 +    if (/*avctx->codec_id == CODEC_ID_AAC ||
 +        avctx->codec_id == CODEC_ID_MP1 ||
 +        avctx->codec_id == CODEC_ID_MP2 ||*/
 +        avctx->codec_id == CODEC_ID_MP3/* ||
 +        avctx->codec_id == CODEC_ID_CELT*/)
 +        return 1;
 +    return 0;
 +}
 +
  /**
   * Get the number of samples of an audio frame. Return -1 on error.
   */
@@@ -3354,48 -3068,21 +3384,50 @@@ static int ff_interleave_compare_dts(AV
      return comp > 0;
  }
  
- int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
+ int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
+                                  AVPacket *pkt, int flush)
+ {
      AVPacketList *pktl;
 -    int stream_count=0;
 -    int i;
 +    int stream_count=0, noninterleaved_count=0;
 +    int64_t delta_dts_max = 0;
 +    int i, ret;
  
      if(pkt){
 -        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
 +        ret = ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
 +        if (ret < 0)
 +            return ret;
      }
  
 -    for(i=0; i < s->nb_streams; i++)
 -        stream_count+= !!s->streams[i]->last_in_packet_buffer;
 +    for(i=0; i < s->nb_streams; i++) {
 +        if (s->streams[i]->last_in_packet_buffer) {
 +            ++stream_count;
 +        } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
 +            ++noninterleaved_count;
 +        }
 +    }
  
 -    if(stream_count && (s->nb_streams == stream_count || flush)){
 +    if (s->nb_streams == stream_count) {
 +        flush = 1;
 +    } else if (!flush){
 +        for(i=0; i < s->nb_streams; i++) {
 +            if (s->streams[i]->last_in_packet_buffer) {
 +                int64_t delta_dts =
 +                    av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
 +                                s->streams[i]->time_base,
 +                                AV_TIME_BASE_Q) -
 +                    av_rescale_q(s->packet_buffer->pkt.dts,
 +                                s->streams[s->packet_buffer->pkt.stream_index]->time_base,
 +                                AV_TIME_BASE_Q);
 +                delta_dts_max= FFMAX(delta_dts_max, delta_dts);
 +            }
 +        }
 +        if(s->nb_streams == stream_count+noninterleaved_count &&
 +           delta_dts_max > 20*AV_TIME_BASE) {
 +            av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
 +            flush = 1;
 +        }
 +    }
 +    if(stream_count && flush){
          pktl= s->packet_buffer;
          *out= pktl->pkt;
  
Simple merge
Simple merge
@@@ -1,95 -1,92 +1,95 @@@
 -FATE_TESTS += fate-adts-demux
 +FATE_DEMUX += fate-adts-demux
  fate-adts-demux: CMD = crc -i $(SAMPLES)/aac/ct_faac-adts.aac -acodec copy
  
 -FATE_TESTS += fate-aea-demux
 +FATE_DEMUX += fate-aea-demux
  fate-aea-demux: CMD = crc -i $(SAMPLES)/aea/chirp.aea -acodec copy
  
 -FATE_TESTS += fate-bink-demux
 +FATE_DEMUX += fate-bink-demux
  fate-bink-demux: CMD = crc -i $(SAMPLES)/bink/Snd0a7d9b58.dee -vn -acodec copy
  
 -FATE_TESTS += fate-bmv
 +FATE_DEMUX += fate-bmv
  fate-bmv: CMD = framecrc -i $(SAMPLES)/bmv/SURFING-partial.BMV -pix_fmt rgb24
  
 -FATE_TESTS += fate-caf
 +FATE_DEMUX += fate-caf
  fate-caf: CMD = crc -i $(SAMPLES)/caf/caf-pcm16.caf
  
 -FATE_TESTS += fate-cdxl-demux
 +FATE_DEMUX += fate-cdxl-demux
  fate-cdxl-demux: CMD = framecrc -i $(SAMPLES)/cdxl/mirage.cdxl -vcodec copy -acodec copy
  
 -FATE_TESTS += fate-cryo-apc
 +FATE_DEMUX += fate-cryo-apc
  fate-cryo-apc: CMD = md5 -i $(SAMPLES)/cryo-apc/cine007.APC -f s16le
  
 -FATE_TESTS += fate-d-cinema-demux
 +FATE_DEMUX += fate-d-cinema-demux
  fate-d-cinema-demux: CMD = framecrc -i $(SAMPLES)/d-cinema/THX_Science_FLT_1920-partial.302 -acodec copy -pix_fmt rgb24
  
 -FATE_TESTS += fate-funcom-iss
 +FATE_DEMUX += fate-funcom-iss
  fate-funcom-iss: CMD = md5 -i $(SAMPLES)/funcom-iss/0004010100.iss -f s16le
  
 -FATE_TESTS += fate-interplay-mve-16bit
 +FATE_DEMUX += fate-interplay-mve-16bit
  fate-interplay-mve-16bit: CMD = framecrc -i $(SAMPLES)/interplay-mve/descent3-level5-16bit-partial.mve -pix_fmt rgb24
  
 -FATE_TESTS += fate-interplay-mve-8bit
 +FATE_DEMUX += fate-interplay-mve-8bit
  fate-interplay-mve-8bit: CMD = framecrc -i $(SAMPLES)/interplay-mve/interplay-logo-2MB.mve -pix_fmt rgb24
  
 -FATE_TESTS += fate-iv8-demux
 +FATE_DEMUX += fate-iv8-demux
  fate-iv8-demux: CMD = framecrc -i $(SAMPLES)/iv8/zzz-partial.mpg -vcodec copy
  
 -FATE_TESTS += fate-lmlm4-demux
 +FATE_DEMUX += fate-lmlm4-demux
  fate-lmlm4-demux: CMD = framecrc -i $(SAMPLES)/lmlm4/LMLM4_CIFat30fps.divx -t 3 -acodec copy -vcodec copy
  
 -FATE_TESTS += fate-maxis-xa
 +FATE_DEMUX += fate-maxis-xa
- fate-maxis-xa: CMD = md5 -i $(SAMPLES)/maxis-xa/SC2KBUG.XA -f s16le
+ fate-maxis-xa: CMD = framecrc -i $(SAMPLES)/maxis-xa/SC2KBUG.XA -frames:a 30 -c:a copy
  
 -FATE_TESTS += fate-mtv
 +FATE_DEMUX += fate-mtv
  fate-mtv: CMD = framecrc -i $(SAMPLES)/mtv/comedian_auto-partial.mtv -acodec copy -pix_fmt rgb24
  
 -FATE_TESTS += fate-mxf-demux
 +FATE_DEMUX += fate-mxf-demux
  fate-mxf-demux: CMD = framecrc -i $(SAMPLES)/mxf/C0023S01.mxf -acodec copy -vcodec copy
  
 -FATE_TESTS += fate-nc-demux
 +FATE_DEMUX += fate-nc-demux
  fate-nc-demux: CMD = framecrc -i $(SAMPLES)/nc-camera/nc-sample-partial -vcodec copy
  
 -FATE_TESTS += fate-nsv-demux
 +FATE_DEMUX += fate-nsv-demux
  fate-nsv-demux: CMD = framecrc -i $(SAMPLES)/nsv/witchblade-51kbps.nsv -t 6 -vcodec copy -acodec copy
  
 -FATE_TESTS += fate-oma-demux
 +FATE_DEMUX += fate-oma-demux
  fate-oma-demux: CMD = crc -i $(SAMPLES)/oma/01-Untitled-partial.oma -acodec copy
  
 -FATE_TESTS += fate-psx-str
 +FATE_DEMUX += fate-psx-str
  fate-psx-str: CMD = framecrc -i $(SAMPLES)/psx-str/descent-partial.str
  
 -FATE_TESTS += fate-psx-str-v3-mdec
 +FATE_DEMUX += fate-psx-str-v3-mdec
  fate-psx-str-v3-mdec: CMD = framecrc -i $(SAMPLES)/psx-str/abc000_cut.str -an
  
 -FATE_TESTS += fate-pva-demux
 -fate-pva-demux: CMD = framecrc -idct simple -i $(SAMPLES)/pva/PVA_test-partial.pva -t 0.6 -acodec copy -vn
 +FATE_DEMUX += fate-pva-demux
 +fate-pva-demux: CMD = framecrc -idct simple -i $(SAMPLES)/pva/PVA_test-partial.pva -t 0.6 -acodec copy
  
 -FATE_TESTS += fate-qcp-demux
 +FATE_DEMUX += fate-qcp-demux
  fate-qcp-demux: CMD = crc -i $(SAMPLES)/qcp/0036580847.QCP -acodec copy
  
 -FATE_TESTS += fate-redcode-demux
 +FATE_DEMUX += fate-redcode-demux
  fate-redcode-demux: CMD = framecrc -i $(SAMPLES)/r3d/4MB-sample.r3d -vcodec copy -acodec copy
  
 -FATE_TESTS += fate-sierra-vmd
 +FATE_DEMUX += fate-sierra-vmd
  fate-sierra-vmd: CMD = framecrc -i $(SAMPLES)/vmd/12.vmd -pix_fmt rgb24
  
 -FATE_TESTS += fate-siff
 +FATE_DEMUX += fate-siff
  fate-siff: CMD = framecrc -i $(SAMPLES)/SIFF/INTRO_B.VB -t 3 -pix_fmt rgb24
  
 -FATE_TESTS += fate-smjpeg
 +FATE_DEMUX += fate-smjpeg
  fate-smjpeg: CMD = framecrc -i $(SAMPLES)/smjpeg/scenwin.mjpg -vcodec copy
  
 -FATE_TESTS += fate-westwood-aud
 +FATE_DEMUX += fate-westwood-aud
  fate-westwood-aud: CMD = md5 -i $(SAMPLES)/westwood-aud/excellent.aud -f s16le
  
 -FATE_TESTS += fate-wtv-demux
 +FATE_DEMUX += fate-wtv-demux
  fate-wtv-demux: CMD = framecrc -i $(SAMPLES)/wtv/law-and-order-partial.wtv -vcodec copy -acodec copy
  
 -FATE_TESTS += fate-xmv-demux
 +FATE_DEMUX += fate-xmv-demux
  fate-xmv-demux: CMD = framecrc -i $(SAMPLES)/xmv/logos1p.fmv -vcodec copy -acodec copy
  
 -FATE_TESTS += fate-xwma-demux
 +FATE_DEMUX += fate-xwma-demux
  fate-xwma-demux: CMD = crc -i $(SAMPLES)/xwma/ergon.xwma -acodec copy
 +
 +FATE_TESTS += $(FATE_DEMUX)
 +fate-demux: $(FATE_DEMUX)
  #tb 0: 1/15
  #tb 1: 1/44100
 -0,          0,          0,        1,   161280, 0x7041748d
 +0,          0,          0,        1,   161280, 0x677c9fb3
  1,          0,          0,     2708,    10832, 0xe1a811fa
  1,       2708,       2708,     2708,    10832, 0xb47841f9
 -0,          1,          1,        1,   161280, 0x3cc4dfb5
 +0,          1,          1,        1,   161280, 0xaa280e0a
  1,       5416,       5416,     2708,    10832, 0x839eedf1
 -0,          2,          2,        1,   161280, 0xca3af22d
 +0,          2,          2,        1,   161280, 0x8a4d2225
  1,       8124,       8124,     2708,    10832, 0xb48b1f60
 -0,          3,          3,        1,   161280, 0x23ad1d85
 +0,          3,          3,        1,   161280, 0xf10f46a8
  1,      10832,      10832,     2708,    10832, 0x743936c0
 -0,          4,          4,        1,   161280, 0x9c9cf364
 +0,          4,          4,        1,   161280, 0x98d9eab6
  1,      13540,      13540,     2708,    10832, 0xe1f039fb
 -0,          5,          5,        1,   161280, 0x1551d6a8
 +0,          5,          5,        1,   161280, 0xa543ae1e
  1,      16248,      16248,     2708,    10832, 0xef00751a
 -0,          6,          6,        1,   161280, 0xc39f6b95
 +0,          6,          6,        1,   161280, 0x79d717ae
  1,      18956,      18956,     2708,    10832, 0x401ed099
 -0,          7,          7,        1,   161280, 0x3b036dcc
 +0,          7,          7,        1,   161280, 0x1a87e2cb
- 1,      21664,      21664,     2708,    10832, 0x432a53bd
+ 1,      21665,      21665,     2708,    10832, 0x432a53bd
 -0,          8,          8,        1,   161280, 0xa6fac1db
 +0,          8,          8,        1,   161280, 0xe5c000ac
- 1,      24372,      24372,     2708,    10832, 0xc4276bfd
+ 1,      24373,      24373,     2708,    10832, 0xc4276bfd
 -0,          9,          9,        1,   161280, 0x67656b62
 +0,          9,          9,        1,   161280, 0xa5827077
- 1,      27080,      27080,     2708,    10832, 0x51f0fa8c
+ 1,      27081,      27081,     2708,    10832, 0x51f0fa8c
 -0,         10,         10,        1,   161280, 0xb41f47d1
 +0,         10,         10,        1,   161280, 0xfd0615ee
- 1,      29788,      29788,     2708,    10832, 0xcebae622
+ 1,      29789,      29789,     2708,    10832, 0xcebae622
 -0,         11,         11,        1,   161280, 0xc207249e
 +0,         11,         11,        1,   161280, 0xc6fdc861
- 1,      32496,      32496,     2708,    10832, 0xe9f6dc1f
- 1,      35204,      35204,     2708,    10832, 0xda087fee
+ 1,      32497,      32497,     2708,    10832, 0xe9f6dc1f
+ 1,      35205,      35205,     2708,    10832, 0xda087fee
 -0,         12,         12,        1,   161280, 0xbee8f843
 +0,         12,         12,        1,   161280, 0xaa007c7e
- 1,      37912,      37912,     2708,    10832, 0x67a621bb
+ 1,      37913,      37913,     2708,    10832, 0x67a621bb
 -0,         13,         13,        1,   161280, 0x092acf46
 +0,         13,         13,        1,   161280, 0xf15e3a96
- 1,      40620,      40620,     2708,    10832, 0xd7be207f
+ 1,      40621,      40621,     2708,    10832, 0xd7be207f
 -0,         14,         14,        1,   161280, 0x8d9e2680
 +0,         14,         14,        1,   161280, 0xce827ae1
- 1,      43328,      43328,     2708,    10832, 0x19d32507
+ 1,      43329,      43329,     2708,    10832, 0x19d32507
 -0,         15,         15,        1,   161280, 0x8becc20c
 +0,         15,         15,        1,   161280, 0xf379fc13
- 1,      46036,      46036,     2708,    10832, 0xe1a3fbfa
+ 1,      46037,      46037,     2708,    10832, 0xe1a3fbfa
 -0,         16,         16,        1,   161280, 0x655e444e
 +0,         16,         16,        1,   161280, 0x89686a0c
- 1,      48744,      48744,     2708,    10832, 0xd10df779
+ 1,      48745,      48745,     2708,    10832, 0xd10df779
 -0,         17,         17,        1,   161280, 0x5c112da0
 +0,         17,         17,        1,   161280, 0x7e8342bd
- 1,      51452,      51452,     2708,    10832, 0x4428e1a7
+ 1,      51453,      51453,     2708,    10832, 0x4428e1a7
 -0,         18,         18,        1,   161280, 0x232fa9eb
 +0,         18,         18,        1,   161280, 0x640dab86
- 1,      54160,      54160,     2708,    10832, 0x7ea9b33d
+ 1,      54161,      54161,     2708,    10832, 0x7ea9b33d
 -0,         19,         19,        1,   161280, 0x9721745d
 +0,         19,         19,        1,   161280, 0xc6a86456
- 1,      56868,      56868,     2708,    10832, 0x6852a5a5
+ 1,      56869,      56869,     2708,    10832, 0x6852a5a5
 -0,         20,         20,        1,   161280, 0x92f1d880
 +0,         20,         20,        1,   161280, 0xe360b538
- 1,      59576,      59576,     2708,    10832, 0xfeb78863
+ 1,      59578,      59578,     2708,    10832, 0xfeb78863
 -0,         21,         21,        1,   161280, 0x16233978
 +0,         21,         21,        1,   161280, 0xbcc21064
- 1,      62284,      62284,     2708,    10832, 0xf157f928
+ 1,      62286,      62286,     2708,    10832, 0xf157f928
 -0,         22,         22,        1,   161280, 0x19a27e69
 +0,         22,         22,        1,   161280, 0x95bc4e63
- 1,      64992,      64992,     2708,    10832, 0x86414b3e
+ 1,      64994,      64994,     2708,    10832, 0x86414b3e
 -0,         23,         23,        1,   161280, 0x7b6ad73a
 +0,         23,         23,        1,   161280, 0x390fa1bd
- 1,      67700,      67700,     2708,    10832, 0x2e28cdf6
- 1,      70408,      70408,     2708,    10832, 0x00212e44
+ 1,      67702,      67702,     2708,    10832, 0x2e28cdf6
+ 1,      70410,      70410,     2708,    10832, 0x00212e44
 -0,         24,         24,        1,   161280, 0xa7a674aa
 +0,         24,         24,        1,   161280, 0xa35b3bb9
- 1,      73116,      73116,     2708,    10832, 0x2d7f9378
+ 1,      73118,      73118,     2708,    10832, 0x2d7f9378
 -0,         25,         25,        1,   161280, 0x4e434abb
 +0,         25,         25,        1,   161280, 0x730b0779
- 1,      75824,      75824,     2708,    10832, 0x84cb25d7
+ 1,      75826,      75826,     2708,    10832, 0x84cb25d7
 -0,         26,         26,        1,   161280, 0xb96eea14
 +0,         26,         26,        1,   161280, 0xf3c3a3eb
- 1,      78532,      78532,     2708,    10832, 0x3aca41fa
+ 1,      78534,      78534,     2708,    10832, 0x3aca41fa
 -0,         27,         27,        1,   161280, 0x1350188c
 +0,         27,         27,        1,   161280, 0x676ecbaa
- 1,      81240,      81240,     2708,    10832, 0x27ad34b9
+ 1,      81242,      81242,     2708,    10832, 0x27ad34b9
 -0,         28,         28,        1,   161280, 0x79c6f305
 +0,         28,         28,        1,   161280, 0x06c4a4e5
- 1,      83948,      83948,     2708,    10832, 0xe665144a
+ 1,      83950,      83950,     2708,    10832, 0xe665144a
 -0,         29,         29,        1,   161280, 0xa9c7782d
 +0,         29,         29,        1,   161280, 0x177d26d9
- 1,      86656,      86656,     2708,    10832, 0xf9546626
+ 1,      86658,      86658,     2708,    10832, 0xf9546626
 -0,         30,         30,        1,   161280, 0x40a4f456
 +0,         30,         30,        1,   161280, 0xdaf69ebe
- 1,      89364,      89364,     2708,    10832, 0xe71c4f22
+ 1,      89366,      89366,     2708,    10832, 0xe71c4f22
 -0,         31,         31,        1,   161280, 0xaf291ed6
 +0,         31,         31,        1,   161280, 0xabadc296
- 1,      92072,      92072,     2708,    10832, 0x5e61869c
+ 1,      92074,      92074,     2708,    10832, 0x5e61869c
 -0,         32,         32,        1,   161280, 0xab29b4e1
 +0,         32,         32,        1,   161280, 0xec144665
- 1,      94780,      94780,     2708,    10832, 0x571d2c10
+ 1,      94782,      94782,     2708,    10832, 0x571d2c10
 -0,         33,         33,        1,   161280, 0xbfcd2712
 +0,         33,         33,        1,   161280, 0x6785aa48
- 1,      97488,      97488,     2708,    10832, 0xf0e08cd5
+ 1,      97490,      97490,     2708,    10832, 0xf0e08cd5
 -0,         34,         34,        1,   161280, 0xff22a0d7
 +0,         34,         34,        1,   161280, 0x2a0cfcaf
- 1,     100196,     100196,     2708,    10832, 0x66650e49
+ 1,     100199,     100199,     2708,    10832, 0x66650e49
 -0,         35,         35,        1,   161280, 0xb0ae88a9
 +0,         35,         35,        1,   161280, 0x9288d513
- 1,     102904,     102904,     2708,    10832, 0x4024deaf
- 1,     105612,     105612,     2708,    10832, 0xda7bdb14
+ 1,     102907,     102907,     2708,    10832, 0x4024deaf
+ 1,     105615,     105615,     2708,    10832, 0xda7bdb14
 -0,         36,         36,        1,   161280, 0x811d1259
 +0,         36,         36,        1,   161280, 0x1d295ad0
- 1,     108320,     108320,     2708,    10832, 0xc27a342f
+ 1,     108323,     108323,     2708,    10832, 0xc27a342f
 -0,         37,         37,        1,   161280, 0x593c39a1
 +0,         37,         37,        1,   161280, 0xb9fd8406
- 1,     111028,     111028,     2708,    10832, 0x574fe679
+ 1,     111031,     111031,     2708,    10832, 0x574fe679
 -0,         38,         38,        1,   161280, 0x5a5a97f8
 +0,         38,         38,        1,   161280, 0x98bced49
- 1,     113736,     113736,     2708,    10832, 0x37db464e
+ 1,     113739,     113739,     2708,    10832, 0x37db464e
 -0,         39,         39,        1,   161280, 0xa5639ecf
 +0,         39,         39,        1,   161280, 0x42e6fbae
- 1,     116444,     116444,     2708,    10832, 0xb1fa2a83
+ 1,     116447,     116447,     2708,    10832, 0xb1fa2a83
 -0,         40,         40,        1,   161280, 0x543920c6
 +0,         40,         40,        1,   161280, 0xfd218209
- 1,     119152,     119152,     2708,    10832, 0x3d98d9b7
+ 1,     119155,     119155,     2708,    10832, 0x3d98d9b7
 -0,         41,         41,        1,   161280, 0xb41689ee
 +0,         41,         41,        1,   161280, 0x21c2ef31
- 1,     121860,     121860,     2708,    10832, 0xb7c908e2
+ 1,     121863,     121863,     2708,    10832, 0xb7c908e2
 -0,         42,         42,        1,   161280, 0xc0ad83de
 +0,         42,         42,        1,   161280, 0xce4be932
- 1,     124568,     124568,     2708,    10832, 0x9f7e44d8
+ 1,     124571,     124571,     2708,    10832, 0x9f7e44d8
 -0,         43,         43,        1,   161280, 0x9e9e7456
 +0,         43,         43,        1,   161280, 0xd5c0d5fc
- 1,     127276,     127276,     2708,    10832, 0xae9b8774
+ 1,     127279,     127279,     2708,    10832, 0xae9b8774
 -0,         44,         44,        1,   161280, 0x777ccbfe
 +0,         44,         44,        1,   161280, 0xf8d13076
- 1,     129984,     129984,     2708,    10832, 0x36916e3f
+ 1,     129987,     129987,     2708,    10832, 0x36916e3f
 -0,         45,         45,        1,   161280, 0x9c2df916
 +0,         45,         45,        1,   161280, 0xdbf86007
- 1,     132692,     132692,     2708,    10832, 0xd785f5ef
+ 1,     132695,     132695,     2708,    10832, 0xd785f5ef
 -0,         46,         46,        1,   161280, 0xe0c13b35
 +0,         46,         46,        1,   161280, 0x9475a651
- 1,     135400,     135400,     2708,    10832, 0x2a3a5673
- 1,     138108,     138108,     2708,    10832, 0x7320e379
+ 1,     135403,     135403,     2708,    10832, 0x2a3a5673
+ 1,     138112,     138112,     2708,    10832, 0x7320e379
 -0,         47,         47,        1,   161280, 0x39bfa5a5
 +0,         47,         47,        1,   161280, 0x41bf1542
- 1,     140816,     140816,     2708,    10832, 0xec787be5
+ 1,     140820,     140820,     2708,    10832, 0xec787be5
 -0,         48,         48,        1,   161280, 0x35dfb264
 +0,         48,         48,        1,   161280, 0x6945297f
- 1,     143524,     143524,     2708,    10832, 0xd0d13aa0
+ 1,     143528,     143528,     2708,    10832, 0xd0d13aa0
 -0,         49,         49,        1,   161280, 0x43018613
 +0,         49,         49,        1,   161280, 0x2282025e
- 1,     146232,     146232,     2708,    10832, 0x34dfcb17
+ 1,     146236,     146236,     2708,    10832, 0x34dfcb17
 -0,         50,         50,        1,   161280, 0x43584b8a
 +0,         50,         50,        1,   161280, 0x55aace0c
- 1,     148940,     148940,     2708,    10832, 0x1a9c29f1
+ 1,     148944,     148944,     2708,    10832, 0x1a9c29f1
 -0,         51,         51,        1,   161280, 0xa5cd230a
 +0,         51,         51,        1,   161280, 0xc78aa51c
- 1,     151648,     151648,     2708,    10832, 0x3e73dcc1
+ 1,     151652,     151652,     2708,    10832, 0x3e73dcc1
 -0,         52,         52,        1,   161280, 0x6fe2cfb3
 +0,         52,         52,        1,   161280, 0xb4b84e6c
- 1,     154356,     154356,     2708,    10832, 0x7855b053
+ 1,     154360,     154360,     2708,    10832, 0x7855b053
 -0,         53,         53,        1,   161280, 0x88a7c0db
 +0,         53,         53,        1,   161280, 0x3bbb3e44
- 1,     157064,     157064,     2708,    10832, 0x5588df8f
+ 1,     157068,     157068,     2708,    10832, 0x5588df8f
 -0,         54,         54,        1,   161280, 0x476f1cd2
 +0,         54,         54,        1,   161280, 0x4dd89d80
- 1,     159772,     159772,     2708,    10832, 0x6f621299
+ 1,     159776,     159776,     2708,    10832, 0x6f621299
 -0,         55,         55,        1,   161280, 0x96401d49
 +0,         55,         55,        1,   161280, 0xa446a5c5
- 1,     162480,     162480,     2708,    10832, 0xce7f39c2
+ 1,     162484,     162484,     2708,    10832, 0xce7f39c2
 -0,         56,         56,        1,   161280, 0x7d932919
 +0,         56,         56,        1,   161280, 0x8f56b1d6
- 1,     165188,     165188,     2708,    10832, 0xd88e6552
+ 1,     165192,     165192,     2708,    10832, 0xd88e6552
 -0,         57,         57,        1,   161280, 0x06465481
 +0,         57,         57,        1,   161280, 0xa170df87
- 1,     167896,     167896,     2708,    10832, 0xddc63597
+ 1,     167900,     167900,     2708,    10832, 0xddc63597
 -0,         58,         58,        1,   161280, 0x39631520
 +0,         58,         58,        1,   161280, 0x4740a4df
- 1,     170604,     170604,     2708,    10832, 0xe3071865
- 1,     173312,     173312,     2708,    10832, 0x2a44a123
+ 1,     170608,     170608,     2708,    10832, 0xe3071865
+ 1,     173316,     173316,     2708,    10832, 0x2a44a123
 -0,         59,         59,        1,   161280, 0xc3fff780
 +0,         59,         59,        1,   161280, 0x86608ee7
- 1,     176020,     176020,     2708,    10832, 0x08d85d45
+ 1,     176024,     176024,     2708,    10832, 0x08d85d45
 -0,         60,         60,        1,   161280, 0xa81faf28
 +0,         60,         60,        1,   161280, 0x629b4543
- 1,     178728,     178728,     2708,    10832, 0x4dc5f83a
+ 1,     178733,     178733,     2708,    10832, 0x4dc5f83a
 -0,         61,         61,        1,   161280, 0x7a311f4f
 +0,         61,         61,        1,   161280, 0x697fb952
- 1,     181436,     181436,     2708,    10832, 0x89497812
+ 1,     181441,     181441,     2708,    10832, 0x89497812
 -0,         62,         62,        1,   161280, 0x52f9b931
 +0,         62,         62,        1,   161280, 0x98e84a51
- 1,     184144,     184144,     2708,    10832, 0x9ee1db54
+ 1,     184149,     184149,     2708,    10832, 0x9ee1db54
 -0,         63,         63,        1,   161280, 0x938cf016
 +0,         63,         63,        1,   161280, 0x97949a90
- 1,     186852,     186852,     2708,    10832, 0x5277d611
+ 1,     186857,     186857,     2708,    10832, 0x5277d611
 -0,         64,         64,        1,   161280, 0xf8f6e19c
 +0,         64,         64,        1,   161280, 0x6a8c9b96
- 1,     189560,     189560,     2708,    10832, 0x570a619c
+ 1,     189565,     189565,     2708,    10832, 0x570a619c
 -0,         65,         65,        1,   161280, 0xca90561b
 +0,         65,         65,        1,   161280, 0xafa714ab
- 1,     192268,     192268,     2708,    10832, 0xa217d70f
+ 1,     192273,     192273,     2708,    10832, 0xa217d70f
 -0,         66,         66,        1,   161280, 0x8594d06b
 +0,         66,         66,        1,   161280, 0x0cf39314
- 1,     194976,     194976,     2708,    10832, 0x6f0ecbf4
+ 1,     194981,     194981,     2708,    10832, 0x6f0ecbf4
 -0,         67,         67,        1,   161280, 0xea32bf3b
 +0,         67,         67,        1,   161280, 0x9ccc8171
- 1,     197684,     197684,     2708,    10832, 0x2704b114
+ 1,     197689,     197689,     2708,    10832, 0x2704b114
 -0,         68,         68,        1,   161280, 0x4646111a
 +0,         68,         68,        1,   161280, 0x8232d5a8
- 1,     200392,     200392,     2708,    10832, 0xf24e679f
+ 1,     200397,     200397,     2708,    10832, 0xf24e679f
 -0,         69,         69,        1,   161280, 0xee891162
 +0,         69,         69,        1,   161280, 0x250dd5cb
- 1,     203100,     203100,     2708,    10832, 0x05572099
+ 1,     203105,     203105,     2708,    10832, 0x05572099
 -0,         70,         70,        1,   161280, 0xcfc32082
 +0,         70,         70,        1,   161280, 0xf764e43a
- 1,     205808,     205808,     2708,    10832, 0x33942d0c
- 1,     208516,     208516,     2708,    10832, 0xa77ea674
+ 1,     205813,     205813,     2708,    10832, 0x33942d0c
+ 1,     208521,     208521,     2708,    10832, 0xa77ea674
 -0,         71,         71,        1,   161280, 0x863c281a
 +0,         71,         71,        1,   161280, 0x2f4bec00
- 1,     211224,     211224,     2708,    10832, 0xeba663bc
+ 1,     211229,     211229,     2708,    10832, 0xeba663bc
 -0,         72,         72,        1,   161280, 0x01b591aa
 +0,         72,         72,        1,   161280, 0x76f1598b
- 1,     213932,     213932,     2708,    10832, 0x1338524a
+ 1,     213937,     213937,     2708,    10832, 0x1338524a
 -0,         73,         73,        1,   161280, 0x211fbc62
 +0,         73,         73,        1,   161280, 0xa91b84da
- 1,     216640,     216640,     2708,    10832, 0x6182b0b3
+ 1,     216645,     216645,     2708,    10832, 0x6182b0b3
 -0,         74,         74,        1,   161280, 0xae2bafe2
 +0,         74,         74,        1,   161280, 0x011a77fb
- 1,     219348,     219348,     2708,    10832, 0xa410a364
+ 1,     219354,     219354,     2708,    10832, 0xa410a364
 -0,         75,         75,        1,   161280, 0xcfe46dca
 +0,         75,         75,        1,   161280, 0xdbf5341c
- 1,     222056,     222056,     2708,    10832, 0x2f4374b0
+ 1,     222062,     222062,     2708,    10832, 0x2f4374b0
 -0,         76,         76,        1,   161280, 0xcf8fe8a3
 +0,         76,         76,        1,   161280, 0x40d5abfa
- 1,     224764,     224764,     2708,    10832, 0xf41f3a07
+ 1,     224770,     224770,     2708,    10832, 0xf41f3a07
 -0,         77,         77,        1,   161280, 0x3f8474eb
 +0,         77,         77,        1,   161280, 0x9fb8360c
- 1,     227472,     227472,     2708,    10832, 0x2b1c50c6
+ 1,     227478,     227478,     2708,    10832, 0x2b1c50c6
 -0,         78,         78,        1,   161280, 0x06da345a
 +0,         78,         78,        1,   161280, 0xabc5fba8
- 1,     230180,     230180,     2708,    10832, 0x3692ac89
+ 1,     230186,     230186,     2708,    10832, 0x3692ac89
 -0,         79,         79,        1,   161280, 0xbd4d3280
 +0,         79,         79,        1,   161280, 0x98090909
- 1,     232888,     232888,     2708,    10832, 0x5d6bc87e
+ 1,     232894,     232894,     2708,    10832, 0x5d6bc87e
 -0,         80,         80,        1,   161280, 0xb5e70fea
 +0,         80,         80,        1,   161280, 0x9a3613bd
- 1,     235596,     235596,     2708,    10832, 0x1b1cda0c
+ 1,     235602,     235602,     2708,    10832, 0x1b1cda0c
 -0,         81,         81,        1,   161280, 0x0c99c804
 +0,         81,         81,        1,   161280, 0x9071024f
- 1,     238304,     238304,     2708,    10832, 0x11eaa15f
- 1,     241012,     241012,     2708,    10832, 0x73c7d7ef
+ 1,     238310,     238310,     2708,    10832, 0x11eaa15f
+ 1,     241018,     241018,     2708,    10832, 0x73c7d7ef
 -0,         82,         82,        1,   161280, 0x19841ed4
 +0,         82,         82,        1,   161280, 0x4df39487
- 1,     243720,     243720,     2708,    10832, 0x65d7e3be
+ 1,     243726,     243726,     2708,    10832, 0x65d7e3be
 -0,         83,         83,        1,   161280, 0xf81dea50
 +0,         83,         83,        1,   161280, 0x17658524
- 1,     246428,     246428,     2708,    10832, 0xb9c00688
+ 1,     246434,     246434,     2708,    10832, 0xb9c00688
 -0,         84,         84,        1,   161280, 0x7777d81c
 +0,         84,         84,        1,   161280, 0xbcd794df
- 1,     249136,     249136,     2708,    10832, 0x0b98c125
+ 1,     249142,     249142,     2708,    10832, 0x0b98c125
 -0,         85,         85,        1,   161280, 0x0497cfd8
 +0,         85,         85,        1,   161280, 0x2a14ae05
- 1,     251844,     251844,     2708,    10832, 0x331ed413
+ 1,     251850,     251850,     2708,    10832, 0x331ed413
 -0,         86,         86,        1,   161280, 0x50b6eb64
 +0,         86,         86,        1,   161280, 0x664feab2
- 1,     254552,     254552,     2708,    10832, 0x9b68f485
+ 1,     254558,     254558,     2708,    10832, 0x9b68f485
 -0,         87,         87,        1,   161280, 0x5071fc07
 +0,         87,         87,        1,   161280, 0xf6b721f4
- 1,     257260,     257260,     2708,    10832, 0x1b865c55
+ 1,     257267,     257267,     2708,    10832, 0x1b865c55
 -0,         88,         88,        1,   161280, 0xbb7527fb
 +0,         88,         88,        1,   161280, 0xfec565f3
- 1,     259968,     259968,     2708,    10832, 0x68cef565
+ 1,     259975,     259975,     2708,    10832, 0x68cef565
 -0,         89,         89,        1,   161280, 0x13054f1f
 +0,         89,         89,        1,   161280, 0xd39aabee
- 1,     262676,     262676,     2708,    10832, 0x3a605f15
+ 1,     262683,     262683,     2708,    10832, 0x3a605f15
 -0,         90,         90,        1,   161280, 0x4b78fb27
 +0,         90,         90,        1,   161280, 0x1f3d5de7
- 1,     265384,     265384,     2708,    10832, 0xd72ff22e
+ 1,     265391,     265391,     2708,    10832, 0xd72ff22e
 -0,         91,         91,        1,   161280, 0xf504968f
 +0,         91,         91,        1,   161280, 0xaf97f50c
- 1,     268092,     268092,     2708,    10832, 0x1c672b67
+ 1,     268099,     268099,     2708,    10832, 0x1c672b67
 -0,         92,         92,        1,   161280, 0x555b10b7
 +0,         92,         92,        1,   161280, 0xe34b6b6a
- 1,     270800,     270800,     2708,    10832, 0xfd1a7e7e
+ 1,     270807,     270807,     2708,    10832, 0xfd1a7e7e
 -0,         93,         93,        1,   161280, 0xcc0dde40
 +0,         93,         93,        1,   161280, 0x4117371e
- 1,     273508,     273508,     2708,    10832, 0x9bf20ead
- 1,     276216,     276216,     2708,    10832, 0x00000000
+ 1,     273515,     273515,     2708,    10832, 0x9bf20ead
+ 1,     276223,     276223,     2708,    10832, 0x00000000
 -0,         94,         94,        1,   161280, 0xcc0dde40
 +0,         94,         94,        1,   161280, 0x4117371e
- 1,     278924,     278924,     2708,    10832, 0x00000000
+ 1,     278931,     278931,     2708,    10832, 0x00000000
 -0,         95,         95,        1,   161280, 0x367f60c8
 +0,         95,         95,        1,   161280, 0xe555b55e
- 1,     281632,     281632,     2708,    10832, 0x00000000
+ 1,     281639,     281639,     2708,    10832, 0x00000000
 -0,         96,         96,        1,   161280, 0x367f60c8
 +0,         96,         96,        1,   161280, 0xe555b55e
- 1,     284340,     284340,     2708,    10832, 0x00000000
+ 1,     284347,     284347,     2708,    10832, 0x00000000
 -0,         97,         97,        1,   161280, 0x367f60c8
 +0,         97,         97,        1,   161280, 0xe555b55e
- 1,     287048,     287048,     2708,    10832, 0x00000000
+ 1,     287055,     287055,     2708,    10832, 0x00000000
 -0,         98,         98,        1,   161280, 0x367f60c8
 +0,         98,         98,        1,   161280, 0xe555b55e
- 1,     289756,     289756,     2708,    10832, 0x00000000
+ 1,     289763,     289763,     2708,    10832, 0x00000000
 -0,         99,         99,        1,   161280, 0x367f60c8
 +0,         99,         99,        1,   161280, 0xe555b55e
- 1,     292464,     292464,     2708,    10832, 0x00000000
+ 1,     292471,     292471,     2708,    10832, 0x00000000
 -0,        100,        100,        1,   161280, 0x367f60c8
 +0,        100,        100,        1,   161280, 0xe555b55e
- 1,     295172,     295172,     2708,    10832, 0x00000000
+ 1,     295179,     295179,     2708,    10832, 0x00000000
 -0,        101,        101,        1,   161280, 0x367f60c8
 +0,        101,        101,        1,   161280, 0xe555b55e
- 1,     297880,     297880,     2708,    10832, 0x00000000
+ 1,     297888,     297888,     2708,    10832, 0x00000000
 -0,        102,        102,        1,   161280, 0x367f60c8
 +0,        102,        102,        1,   161280, 0xe555b55e
- 1,     300588,     300588,     2708,    10832, 0x00000000
+ 1,     300596,     300596,     2708,    10832, 0x00000000
 -0,        103,        103,        1,   161280, 0x367f60c8
 +0,        103,        103,        1,   161280, 0xe555b55e
- 1,     303296,     303296,     2708,    10832, 0x00000000
+ 1,     303304,     303304,     2708,    10832, 0x00000000
 -0,        104,        104,        1,   161280, 0x367f60c8
 +0,        104,        104,        1,   161280, 0xe555b55e
  0,          6,          6,        1,    69120, 0x433bb6f6
  1,      18956,      18956,     2708,    10832, 0x88f5271a
  0,          7,          7,        1,    69120, 0xdbac8bee
- 1,      21664,      21664,     2708,    10832, 0x55c6bbe5
+ 1,      21665,      21665,     2708,    10832, 0x55c6bbe5
  0,          8,          8,        1,    69120, 0x88e2a799
- 1,      24372,      24372,     2708,    10832, 0x9b51ae82
+ 1,      24373,      24373,     2708,    10832, 0x9b51ae82
  0,          9,          9,        1,    69120, 0x49617b26
- 1,      27080,      27080,     2708,    10832, 0xcdf2409b
+ 1,      27081,      27081,     2708,    10832, 0xcdf2409b
  0,         10,         10,        1,    69120, 0xeb44ca01
- 1,      29788,      29788,     2708,    10832, 0x0933b1a4
+ 1,      29789,      29789,     2708,    10832, 0x0933b1a4
  0,         11,         11,        1,    69120, 0x6fea37e8
- 1,      32496,      32496,     2708,    10832, 0x24b77006
- 1,      35204,      35204,     2708,    10832, 0xf612fa8a
+ 1,      32497,      32497,     2708,    10832, 0x24b77006
+ 1,      35205,      35205,     2708,    10832, 0xf612fa8a
  0,         12,         12,        1,    69120, 0xf55d74c7
- 1,      37912,      37912,     2708,    10832, 0x99884b06
+ 1,      37913,      37913,     2708,    10832, 0x99884b06
  0,         13,         13,        1,    69120, 0xb5082ca7
- 1,      40620,      40620,     2708,    10832, 0x3c746fbe
+ 1,      40621,      40621,     2708,    10832, 0x3c746fbe
  0,         14,         14,        1,    69120, 0x5876d758
- 1,      43328,      43328,     2708,    10832, 0x05f3b08a
+ 1,      43329,      43329,     2708,    10832, 0x05f3b08a
 +0,         15,         15,        1,    69120, 0x45e7dd5c
- 1,      46036,      46036,     2708,    10832, 0xa6560483
- 1,      48744,      48744,     2708,    10832, 0xd98a8e19
- 1,      51452,      51452,     2708,    10832, 0xf98a0b2e
- 1,      54160,      54160,     2708,    10832, 0xb1039582
- 1,      56868,      56868,     2708,    10832, 0x85dd5c3f
- 1,      59576,      59576,     2708,    10832, 0x19fc801a
- 1,      62284,      62284,     2708,    10832, 0x95805089
- 1,      64992,      64992,     2708,    10832, 0x576fdec3
- 1,      67700,      67700,     2708,    10832, 0x704a0905
- 1,      70408,      70408,     2708,    10832, 0xf87ce1fa
- 1,      73116,      73116,     2708,    10832, 0xfc0076b9
+ 1,      46037,      46037,     2708,    10832, 0xa6560483
+ 1,      48745,      48745,     2708,    10832, 0xd98a8e19
+ 1,      51453,      51453,     2708,    10832, 0xf98a0b2e
+ 1,      54161,      54161,     2708,    10832, 0xb1039582
+ 1,      56869,      56869,     2708,    10832, 0x85dd5c3f
+ 1,      59578,      59578,     2708,    10832, 0x19fc801a
+ 1,      62286,      62286,     2708,    10832, 0x95805089
+ 1,      64994,      64994,     2708,    10832, 0x576fdec3
+ 1,      67702,      67702,     2708,    10832, 0x704a0905
+ 1,      70410,      70410,     2708,    10832, 0xf87ce1fa
+ 1,      73118,      73118,     2708,    10832, 0xfc0076b9