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
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
$(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))
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
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.
@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:
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
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
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:
@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}.
exit_program(1);
}
- if (!check_recording_time(ost))
- return 0;
-
+ frame->pts = ost->sync_opts;
ost->sync_opts += frame->nb_samples;
}
{ "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" },
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 \
*/
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;
--- /dev/null
- * 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
{
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;
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"),
--- /dev/null
- * 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
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, ©, &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;
}
}
+ #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.
*/
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;
-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
OSDN Git Service
