66 #define OFFSET(x) offsetof(AVCodecContext,x)
67 #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
69 #define V AV_OPT_FLAG_VIDEO_PARAM
70 #define A AV_OPT_FLAG_AUDIO_PARAM
71 #define S AV_OPT_FLAG_SUBTITLE_PARAM
72 #define E AV_OPT_FLAG_ENCODING_PARAM
73 #define D AV_OPT_FLAG_DECODING_PARAM
75 #define AV_CODEC_DEFAULT_BITRATE 200*1000
83 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
84 {
"obmc",
"use overlapped block motion compensation (h263+)", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_OBMC }, INT_MIN, INT_MAX,
V|
E,
"flags"},
90 {
"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"},
91 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
92 {
"part",
"use data partitioning", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_PART }, INT_MIN, INT_MAX,
V|
E,
"flags"},
97 #if FF_API_MJPEG_GLOBAL_OPTS
98 {
"extern_huff",
"use external huffman table (for mjpeg)", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_EXTERN_HUFF }, INT_MIN, INT_MAX, 0,
"flags"},
107 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
108 {
"alt",
"enable alternate scantable (mpeg2/mpeg4)", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_ALT_SCAN }, INT_MIN, INT_MAX,
V|
E,
"flags"},
113 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
114 {
"umv",
"use unlimited motion vectors", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_H263P_UMV }, INT_MIN, INT_MAX,
V|
E,
"flags"},
118 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
119 {
"aiv",
"h263 alternative inter vlc", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_H263P_AIV }, INT_MIN, INT_MAX,
V|
E,
"flags"},
120 {
"slice",
NULL, 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_H263P_SLICE_STRUCT }, INT_MIN, INT_MAX,
V|
E,
"flags"},
123 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
124 {
"scan_offset",
"will reserve space for svcd scan offset user data", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_SVCD_SCAN_OFFSET }, INT_MIN, INT_MAX,
V|
E,
"flags"},
136 {
"esa",
"esa motion estimation (alias for full)", 0,
AV_OPT_TYPE_CONST, {.dbl =
ME_FULL }, INT_MIN, INT_MAX,
V|
E,
"me_method" },
138 {
"dia",
"dia motion estimation (alias for epzs)", 0,
AV_OPT_TYPE_CONST, {.dbl =
ME_EPZS }, INT_MIN, INT_MAX,
V|
E,
"me_method" },
147 {
"g",
"set the group of picture size",
OFFSET(gop_size),
AV_OPT_TYPE_INT, {.dbl = 12 }, INT_MIN, INT_MAX,
V|
E},
154 {
"qcomp",
"video quantizer scale compression (VBR)",
OFFSET(qcompress),
AV_OPT_TYPE_FLOAT, {.dbl = 0.5 }, -FLT_MAX, FLT_MAX,
V|
E},
158 {
"qdiff",
"max difference between the quantizer scale (VBR)",
OFFSET(max_qdiff),
AV_OPT_TYPE_INT, {.dbl = 3 }, INT_MIN, INT_MAX,
V|
E},
160 {
"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},
162 {
"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},
163 #if FF_API_X264_GLOBAL_OPTS
164 {
"wpredp",
"weighted prediction analysis method",
OFFSET(weighted_p_pred),
AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX,
V|
E},
192 {
"ms",
"workaround various bugs in microsofts broken decoders", 0,
AV_OPT_TYPE_CONST, {.dbl =
FF_BUG_MS }, INT_MIN, INT_MAX,
V|
D,
"bug"},
194 {
"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},
195 {
"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},
202 {
"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},
209 {
"explode",
"abort decoding on error recognition", 0,
AV_OPT_TYPE_CONST, {.dbl = FF_ER_EXPLODE }, INT_MIN, INT_MAX,
V|
D,
"er"},
218 #if FF_API_PARSE_FRAME
222 {
"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},
230 {
"rc_buf_aggressivity",
"currently useless",
OFFSET(rc_buffer_aggressivity),
AV_OPT_TYPE_FLOAT, {.dbl = 1.0 }, -FLT_MAX, FLT_MAX,
V|
E},
231 {
"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},
232 {
"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},
242 {
"lumi_mask",
"compresses bright areas stronger than medium ones",
OFFSET(lumi_masking),
AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX,
V|
E},
243 {
"tcplx_mask",
"temporal complexity masking",
OFFSET(temporal_cplx_masking),
AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX,
V|
E},
244 {
"scplx_mask",
"spatial complexity masking",
OFFSET(spatial_cplx_masking),
AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX,
V|
E},
246 {
"dark_mask",
"compresses dark areas stronger than medium ones",
OFFSET(dark_masking),
AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX,
V|
E},
292 {
"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"},
305 {
"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},
308 {
"sad",
"sum of absolute differences, fast (default)", 0,
AV_OPT_TYPE_CONST, {.dbl =
FF_CMP_SAD }, INT_MIN, INT_MAX,
V|
E,
"cmp_func"},
312 {
"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"},
314 {
"rd",
"rate distortion optimal, slow", 0,
AV_OPT_TYPE_CONST, {.dbl =
FF_CMP_RD }, INT_MIN, INT_MAX,
V|
E,
"cmp_func"},
319 #if CONFIG_SNOW_ENCODER
320 {
"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"},
321 {
"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"},
325 {
"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},
326 {
"subq",
"sub pel motion estimation quality",
OFFSET(me_subpel_quality),
AV_OPT_TYPE_INT, {.dbl = 8 }, INT_MIN, INT_MAX,
V|
E},
342 {
"mbd",
"macroblock decision algorithm (high quality mode)",
OFFSET(mb_decision),
AV_OPT_TYPE_INT, {.dbl =
DEFAULT }, INT_MIN, INT_MAX,
V|
E,
"mbd"},
351 {
"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},
353 #if FF_API_X264_GLOBAL_OPTS
354 #define X264_DEFAULTS CODEC_FLAG2_FASTPSKIP|CODEC_FLAG2_PSY|CODEC_FLAG2_MBTREE
356 #define X264_DEFAULTS 0
358 #if FF_API_LAME_GLOBAL_OPTS
359 #define LAME_DEFAULTS CODEC_FLAG2_BIT_RESERVOIR
361 #define LAME_DEFAULTS 0
365 #if FF_API_ANTIALIAS_ALGO
374 {
"auto",
"detect a good number of threads", 0,
AV_OPT_TYPE_CONST, {.dbl = 0 }, INT_MIN, INT_MAX,
V|
E|
D,
"threads"},
379 {
"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},
380 {
"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},
394 {
"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},
399 {
"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},
402 {
"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},
414 #if FF_API_X264_GLOBAL_OPTS
416 {
"cqp",
"constant quantization parameter rate control method",
OFFSET(cqp),
AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX,
V|
E},
418 {
"keyint_min",
"minimum interval between IDR-frames (x264)",
OFFSET(keyint_min),
AV_OPT_TYPE_INT, {.dbl = 25 }, INT_MIN, INT_MAX,
V|
E},
419 {
"refs",
"reference frames to consider for motion compensation (Snow)",
OFFSET(refs),
AV_OPT_TYPE_INT, {.dbl = 1 }, INT_MIN, INT_MAX,
V|
E},
421 #if FF_API_X264_GLOBAL_OPTS
425 #if FF_API_X264_GLOBAL_OPTS
426 {
"directpred",
"direct mv prediction mode - 0 (none), 1 (spatial), 2 (temporal), 3 (auto)",
OFFSET(directpred),
AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX,
V|
E},
427 {
"bpyramid",
"allows B-frames to be used as references for predicting", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_BPYRAMID }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
428 {
"wpred",
"weighted biprediction for b-frames (H.264)", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_WPRED }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
429 {
"mixed_refs",
"one reference per partition, as opposed to one reference per macroblock", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_MIXED_REFS }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
430 {
"dct8x8",
"high profile 8x8 transform (H.264)", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_8X8DCT }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
431 {
"fastpskip",
"fast pskip (H.264)", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_FASTPSKIP }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
432 {
"aud",
"access unit delimiters (H.264)", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_AUD }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
435 #if FF_API_X264_GLOBAL_OPTS
436 {
"complexityblur",
"reduce fluctuations in qp (before curve compression)",
OFFSET(complexityblur),
AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX,
V|
E},
446 {
"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},
448 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
449 {
"ivlc",
"intra vlc table", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_INTRA_VLC }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
451 {
"b_sensitivity",
"adjusts sensitivity of b_frame_strategy 1",
OFFSET(b_sensitivity),
AV_OPT_TYPE_INT, {.dbl = 40 }, 1, INT_MAX,
V|
E},
455 #if FF_API_FLAC_GLOBAL_OPTS
456 {
"lpc_coeff_precision",
"deprecated, use flac-specific options",
OFFSET(lpc_coeff_precision),
AV_OPT_TYPE_INT, {.dbl =
DEFAULT }, 0, INT_MAX,
A|
E},
457 {
"prediction_order_method",
"deprecated, use flac-specific options",
OFFSET(prediction_order_method),
AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX,
A|
E},
458 {
"min_partition_order",
"deprecated, use flac-specific options",
OFFSET(min_partition_order),
AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX,
A|
E},
459 {
"max_partition_order",
"deprecated, use flac-specific options",
OFFSET(max_partition_order),
AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX,
A|
E},
461 {
"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},
462 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
463 {
"drop_frame_timecode",
NULL, 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_DROP_FRAME_TIMECODE }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
464 {
"non_linear_q",
"use non linear quantizer", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_NON_LINEAR_QUANT }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
466 #if FF_API_REQUEST_CHANNELS
470 {
"drc_scale",
"percentage of dynamic range compression to apply",
OFFSET(drc_scale),
AV_OPT_TYPE_FLOAT, {.dbl = 0.0 }, 0.0, 1.0,
A|
D},
472 #if FF_API_LAME_GLOBAL_OPTS
473 {
"reservoir",
"use bit reservoir", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_BIT_RESERVOIR }, INT_MIN, INT_MAX,
A|
E,
"flags2"},
475 #if FF_API_X264_GLOBAL_OPTS
476 {
"mbtree",
"use macroblock tree ratecontrol (x264 only)", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_MBTREE }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
489 #if FF_API_X264_GLOBAL_OPTS
490 {
"psy",
"use psycho visual optimization", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_PSY }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
492 {
"psy_trellis",
"specify psycho visual trellis",
OFFSET(psy_trellis),
AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX,
V|
E},
495 {
"rc_lookahead",
"specify number of frames to look ahead for frametype",
OFFSET(rc_lookahead),
AV_OPT_TYPE_INT, {.dbl = -1 }, -1, INT_MAX,
V|
E},
496 {
"ssim",
"ssim will be calculated during encoding", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_SSIM }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
497 {
"intra_refresh",
"use periodic insertion of intra blocks instead of keyframes", 0,
AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_INTRA_REFRESH }, INT_MIN, INT_MAX,
V|
E,
"flags2"},
500 {
"log_level_offset",
"set the log level offset",
OFFSET(log_level_offset),
AV_OPT_TYPE_INT, {.dbl = 0 }, INT_MIN, INT_MAX },
501 #if FF_API_FLAC_GLOBAL_OPTS
502 {
"lpc_type",
"deprecated, use flac-specific options",
OFFSET(lpc_type),
AV_OPT_TYPE_INT, {.dbl = AV_LPC_TYPE_DEFAULT }, AV_LPC_TYPE_DEFAULT, AV_LPC_TYPE_NB-1,
A|
E},
507 {
"lpc_passes",
"deprecated, use flac-specific options",
OFFSET(lpc_passes),
AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX,
A|
E},
509 {
"slices",
"number of slices, used in parallelized encoding",
OFFSET(slices),
AV_OPT_TYPE_INT, {.dbl = 0 }, 0, INT_MAX,
V|
E},
544 .log_level_offset_offset =
OFFSET(log_level_offset),
549 #if FF_API_ALLOC_CONTEXT
614 #if FF_API_ALLOC_CONTEXT
620 avcodec_get_context_defaults2(avctx, codec_type);
638 "Tried to copy AVCodecContext %p into already-initialized %p\n",
642 memcpy(dest, src,
sizeof(*dest));
664 #define alloc_and_copy_or_fail(obj, size, pad) \
665 if (src->obj && size > 0) { \
666 dest->obj = av_malloc(size + pad); \
669 memcpy(dest->obj, src->obj, size); \
671 memset(((uint8_t *) dest->obj) + size, 0, pad); \
678 #undef alloc_and_copy_or_fail
#define FF_IDCT_SIMPLEARMV5TE
#define CODEC_FLAG_GMC
Use GMC.
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
#define FF_DEBUG_VIS_MB_TYPE
Number of sample formats. DO NOT USE if linking dynamically.
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
int(* get_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called at the beginning of each frame to get a buffer for it.
enum PixelFormat pix_fmt
Pixel format, see PIX_FMT_xxx.
#define CODEC_FLAG2_LOCAL_HEADER
Place global headers at every keyframe instead of in extradata.
#define CODEC_FLAG_MV0
Always try a MB with MV=<0,0>.
#define FF_BUG_XVID_ILACE
#define FF_COMPRESSION_DEFAULT
#define FF_MB_DECISION_BITS
chooses the one which needs the fewest bits
#define AV_CODEC_DEFAULT_BITRATE
#define CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
#define FF_IDCT_SIMPLEALPHA
AVCodecContext * avcodec_alloc_context3(AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
static const AVOption options[]
#define CODEC_FLAG_CBP_RD
Use rate distortion optimization for cbp.
static int workaround_bugs
enum PixelFormat(* get_format)(struct AVCodecContext *s, const enum PixelFormat *fmt)
callback to negotiate the pixelFormat
#define FF_PROFILE_DTS_HD_HRA
#define FF_COMPLIANCE_VERY_STRICT
Strictly conform to an older more strict version of the spec or reference software.
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
#define FF_DEBUG_BITSTREAM
#define FF_BUG_HPEL_CHROMA
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
enum AVMediaType codec_type
discard all bidirectional frames
static int bidir_refine(MpegEncContext *s, int mb_x, int mb_y)
#define FF_PROFILE_AAC_MAIN
enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat *fmt)
int avcodec_is_open(AVCodecContext *s)
#define FF_DEBUG_VIS_MV_B_FOR
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
int(* reget_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called at the beginning of a frame to get cr buffer for it.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
#define FF_BUG_MS
Work around various bugs in Microsoft's broken decoders.
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static const AVClass av_codec_context_class
struct AVHWAccel * hwaccel
Hardware accelerator in use.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define CODEC_FLAG_INPUT_PRESERVED
The parent program guarantees that the input for B-frames containing streams is not written to for at...
enum AVColorTransferCharacteristic color_trc
enum AVSampleFormat sample_fmt
audio sample format
#define FF_DEBUG_PICT_INFO
#define FF_DEBUG_VIS_MV_B_BACK
enum AVColorRange color_range
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
const AVClass * av_class
information on struct for av_log
#define CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
enhanced predictive zonal search
#define FF_PROFILE_AAC_LTP
#define FF_BUG_QPEL_CHROMA2
#define CODEC_FLAG2_SKIP_RD
RD optimal MB level residual skipping.
#define FF_IDCT_SIMPLEARM
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
#define FF_BUG_DIRECT_BLOCKSIZE
#define CODEC_FLAG_NORMALIZE_AQP
Normalize adaptive quantization.
const AVCodecDefault * defaults
Private codec-specific defaults.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
static uint16_t * inter_matrix
#define CODEC_FLAG_QP_RD
Use rate distortion optimization for qp selectioon.
#define FF_CODER_TYPE_DEFLATE
#define FF_PROFILE_DTS_ES
static void * codec_child_next(void *obj, void *prev)
static enum AVDiscard skip_idct
enum AVColorPrimaries color_primaries
#define FF_BUG_NO_PADDING
simple assert() macros that are a bit more flexible than ISO C assert().
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
const char * rc_eq
rate control equation
#define CODEC_FLAG_TRUNCATED
void * thread_opaque
thread opaque Can be used by execute() to store some per AVCodecContext stuff.
#define FF_BUG_OLD_MSMPEG4
#define CODEC_FLAG_AC_PRED
H.263 advanced intra coding / MPEG-4 AC prediction.
static const char * context_to_name(void *ptr)
#define CODEC_FLAG_EMU_EDGE
Don't draw edges.
struct AVRational AVRational
rational number numerator/denominator
int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src)
Copy the settings of the source AVCodecContext into the destination AVCodecContext.
#define FF_THREAD_FRAME
Decode more than one frame at once.
int avcodec_get_context_defaults3(AVCodecContext *s, AVCodec *codec)
Set the fields of the given AVCodecContext to default values corresponding to the given codec (defaul...
#define FF_IDCT_SIMPLEARMV6
#define FF_PROFILE_AAC_LOW
#define FF_PROFILE_UNKNOWN
static const AVClass * codec_child_class_next(const AVClass *prev)
#define FF_MB_DECISION_SIMPLE
uses mb_cmp
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
#define FF_BUG_AC_VLC
Will be removed, libavcodec can now handle these non-compliant files by default.
#define CODEC_FLAG_LOOP_FILTER
loop filter
int64_t reordered_opaque
opaque 64bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
Usually treated as AVMEDIA_TYPE_DATA.
#define FF_BUG_QPEL_CHROMA
int avcodec_default_execute2(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2, int, int), void *arg, int *ret, int count)
RcOverride * rc_override
ratecontrol override, see RcOverride
#define FF_PROFILE_DTS_96_24
#define CODEC_FLAG_LOW_DELAY
Force low delay.
enum AVMediaType codec_type
char * av_strdup(const char *s)
Duplicate the string s.
#define FF_IDCT_SIMPLENEON
discard all non reference
main external API structure.
void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic)
int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic)
#define CODEC_FLAG_QSCALE
Use fixed qscale.
#define FF_DEFAULT_QUANT_BIAS
int avcodec_default_execute(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define CODEC_FLAG_QPEL
Use qpel MC.
static int error_recognition
#define FF_PROFILE_AAC_SSR
uint16_t * intra_matrix
custom intra quantization matrix
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Describe the class of an AVClass context structure.
#define FF_CODER_TYPE_VLC
#define CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
#define FF_COMPLIANCE_NORMAL
#define FF_DEBUG_DCT_COEFF
#define FF_MB_DECISION_RD
rate distortion
transformed exhaustive search algorithm
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
uint16_t * inter_matrix
custom inter quantization matrix
#define FF_BUG_AUTODETECT
autodetection
discard useless packets like 0 size packets in avi
const AVClass * priv_class
AVClass for the private context.
#define CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
#define CODEC_FLAG_CLOSED_GOP
common internal api header.
#define CODEC_FLAG2_NO_OUTPUT
Skip bitstream encoding.
static int intra_dc_precision
no search, that is use 0,0 vector whenever one is needed
uneven multi-hexagon search
#define FF_CODER_TYPE_RAW
#define FF_DEBUG_VIS_MV_P_FOR
int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic)
AVCodec * av_codec_next(AVCodec *c)
If c is NULL, returns the first registered codec, if c is non-NULL, returns the next registered codec...
#define FF_IDCT_SIMPLEMMX
#define FF_DEBUG_STARTCODE
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
#define alloc_and_copy_or_fail(obj, size, pad)
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
struct AVCodecInternal * internal
Private context used for internal data.
#define FF_CODER_TYPE_RLE
static int error_concealment
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
#define CODEC_FLAG2_FAST
Allow non spec compliant speedup tricks.
int * slice_offset
slice offsets in the frame in bytes
#define FF_IDCT_LIBMPEG2MMX
#define CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
discard all frames except keyframes
enum AVColorSpace colorspace
#define FF_PROFILE_DTS_HD_MA
#define CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
static enum AVDiscard skip_loop_filter
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
#define AV_NOPTS_VALUE
Undefined timestamp value.
static enum AVDiscard skip_frame
#define CODEC_FLAG2_STRICT_GOP
Strictly enforce GOP size.
static uint16_t * intra_matrix