33 #define X264_API_IMPORTS 1 106 static const int level_map[] = {
113 if (level < 0 || level > X264_LOG_DEBUG)
116 av_vlog(p, level_map[level], fmt, args);
121 const x264_nal_t *nals,
int nnal)
130 for (i = 0; i < nnal; i++)
131 size += nals[i].i_payload;
150 for (i = 0; i < nnal; i++){
151 memcpy(p, nals[i].p_payload, nals[i].i_payload);
152 p += nals[
i].i_payload;
190 x264_encoder_reconfig(x4->
enc, &x4->
params);
195 x264_encoder_reconfig(x4->
enc, &x4->
params);
202 x264_encoder_reconfig(x4->
enc, &x4->
params);
205 if (x4->
params.rc.i_rc_method == X264_RC_ABR &&
208 x264_encoder_reconfig(x4->
enc, &x4->
params);
212 x4->
params.rc.i_rc_method == X264_RC_CRF &&
213 x4->
params.rc.f_rf_constant != x4->
crf) {
215 x264_encoder_reconfig(x4->
enc, &x4->
params);
218 if (x4->
params.rc.i_rc_method == X264_RC_CQP &&
220 x4->
params.rc.i_qp_constant != x4->
cqp) {
222 x264_encoder_reconfig(x4->
enc, &x4->
params);
228 x264_encoder_reconfig(x4->
enc, &x4->
params);
237 switch (stereo->
type) {
256 #if X264_BUILD >= 145 269 "Ignoring unsupported inverted stereo value %d\n", fpa_type);
273 if (fpa_type != x4->
params.i_frame_packing) {
274 x4->
params.i_frame_packing = fpa_type;
275 x264_encoder_reconfig(x4->
enc, &x4->
params);
286 x264_picture_t pic_out = {0};
292 x264_picture_init( &x4->
pic );
294 #if X264_BUILD >= 153 295 bit_depth = x4->
params.i_bitdepth;
297 bit_depth = x264_bit_depth;
300 x4->
pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
304 for (i = 0; i < x4->
pic.img.i_plane; i++) {
309 x4->
pic.i_pts = frame->
pts;
319 : X264_TYPE_KEYFRAME;
322 x4->
pic.i_type = X264_TYPE_P;
325 x4->
pic.i_type = X264_TYPE_B;
328 x4->
pic.i_type = X264_TYPE_AUTO;
340 }
else if (sei_data) {
341 x4->
pic.extra_sei.payloads =
av_mallocz(
sizeof(x4->
pic.extra_sei.payloads[0]));
342 if (x4->
pic.extra_sei.payloads ==
NULL) {
348 x4->
pic.extra_sei.payloads[0].payload_size =
sei_size;
349 x4->
pic.extra_sei.payloads[0].payload = sei_data;
350 x4->
pic.extra_sei.num_payloads = 1;
351 x4->
pic.extra_sei.payloads[0].payload_type = 4;
358 if (x4->
params.rc.i_aq_mode == X264_AQ_NONE) {
359 av_log(ctx,
AV_LOG_WARNING,
"Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
364 int qp_range = 51 + 6 * (bit_depth - 8);
372 if (!roi_size || sd->
size % roi_size != 0) {
376 nb_rois = sd->
size / roi_size;
384 for (
int i = nb_rois - 1; i >= 0; i--) {
385 int startx, endx, starty, endy;
401 qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
403 for (
int y = starty; y < endy; y++) {
404 for (
int x = startx; x < endx; x++) {
405 qoffsets[x + y*mbx] = qoffset;
410 x4->
pic.prop.quant_offsets = qoffsets;
413 av_log(ctx,
AV_LOG_WARNING,
"interlaced_frame not supported for ROI encoding yet, skipping ROI.\n");
420 if (x264_encoder_encode(x4->
enc, &nal, &nnal, frame? &x4->
pic:
NULL, &pic_out) < 0)
426 }
while (!ret && !frame && x264_encoder_delayed_frames(x4->
enc));
428 pkt->
pts = pic_out.i_pts;
429 pkt->
dts = pic_out.i_dts;
431 out_opaque = pic_out.opaque;
440 switch (pic_out.i_type) {
455 #if FF_API_CODED_FRAME 465 #if FF_API_CODED_FRAME 485 x264_encoder_close(x4->
enc);
492 #define OPT_STR(opt, param) \ 495 if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) { \ 496 if(ret == X264_PARAM_BAD_NAME) \ 497 av_log(avctx, AV_LOG_ERROR, \ 498 "bad option '%s': '%s'\n", opt, param); \ 500 av_log(avctx, AV_LOG_ERROR, \ 501 "bad value for '%s': '%s'\n", opt, param); \ 520 #if CONFIG_LIBX264RGB_ENCODER 522 return X264_CSP_BGRA;
543 #define PARSE_X264_OPT(name, var)\ 544 if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\ 545 av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\ 546 return AVERROR(EINVAL);\ 558 #if CONFIG_LIBX262_ENCODER 561 x264_param_default_mpeg2(&x4->
params);
564 x264_param_default(&x4->
params);
573 for (i = 0; x264_preset_names[
i]; i++)
577 for (i = 0; x264_tune_names[
i]; i++)
583 if (avctx->
level > 0)
587 x4->
params.p_log_private = avctx;
588 x4->
params.i_log_level = X264_LOG_DEBUG;
590 #if X264_BUILD >= 153 598 x4->
params.rc.i_rc_method = X264_RC_ABR;
604 x4->
params.rc.b_stat_read = 1;
607 x4->
params.rc.i_rc_method = X264_RC_CRF;
609 }
else if (x4->
cqp >= 0) {
610 x4->
params.rc.i_rc_method = X264_RC_CQP;
620 x4->
params.rc.f_vbv_buffer_init =
631 #if FF_API_PRIVATE_OPT 645 #if FF_API_PRIVATE_OPT 654 if (avctx->
qmin >= 0)
656 if (avctx->
qmax >= 0)
660 if (avctx->
qblur >= 0)
664 if (avctx->
refs >= 0)
666 else if (x4->
level) {
671 int scale = X264_BUILD < 129 ? 384 : 1;
673 if (!strcmp(x4->
level,
"1b")) {
675 }
else if (strlen(x4->
level) <= 3){
683 for (i = 0; i<x264_levels[
i].level_idc; i++)
684 if (x264_levels[i].
level_idc == level_id)
685 x4->
params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->
params.i_frame_reference);
692 #if FF_API_PRIVATE_OPT 702 #if FF_API_PRIVATE_OPT 710 #if FF_API_CODER_TYPE 744 x4->
params.b_vfr_input = 0;
747 #if X264_BUILD >= 142 751 "x264 too old for AVC Intra, at least version 142 needed\n");
753 if (x4->
b_bias != INT_MIN)
774 x264_param_apply_fastfirstpass(&x4->
params);
814 if (x264_param_apply_profile(&x4->
params, x4->
profile) < 0) {
818 for (i = 0; x264_profile_names[
i]; i++)
827 x4->
params.vui.i_sar_width = sw;
828 x4->
params.vui.i_sar_height = sh;
864 x4->
params.b_repeat_headers = 0;
869 char param[4096]={0},
val[4096]={0};
870 if(sscanf(p,
"%4095[^:=]=%4095[^:]", param,
val) == 1){
887 "Error parsing option '%s = %s'.\n",
897 x4->
params.i_bframe_pyramid ? 2 : 1 : 0;
903 x4->
enc = x264_encoder_open(&x4->
params);
912 s = x264_encoder_headers(x4->
enc, &nal, &nnal);
917 for (i = 0; i < nnal; i++) {
919 if (nal[i].i_type == NAL_SEI) {
925 memcpy(x4->
sei, nal[i].p_payload, nal[i].i_payload);
928 memcpy(p, nal[i].p_payload, nal[i].i_payload);
929 p += nal[
i].i_payload;
1000 #if CONFIG_LIBX264RGB_ENCODER 1011 #if X264_BUILD < 153 1012 if (x264_bit_depth == 8)
1014 else if (x264_bit_depth == 9)
1016 else if (x264_bit_depth == 10)
1023 #define OFFSET(x) offsetof(X264Context, x) 1024 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 1036 {
"crf_max",
"In CRF mode, prevents VBV from lowering quality beyond this point.",
OFFSET(
crf_max),
AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
1037 {
"qp",
"Constant quantization parameter rate control method",
OFFSET(
cqp),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
1040 {
"variance",
"Variance AQ (complexity mask)", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX,
VE,
"aq_mode" },
1041 {
"autovariance",
"Auto-variance AQ", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX,
VE,
"aq_mode" },
1042 #if X264_BUILD >= 144 1043 {
"autovariance-biased",
"Auto-variance AQ with bias to dark scenes", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE_BIASED}, INT_MIN, INT_MAX,
VE,
"aq_mode" },
1060 {
"strict",
"Strictly hierarchical pyramid", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX,
VE,
"b_pyramid" },
1061 {
"normal",
"Non-strict (not Blu-ray compatible)", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX,
VE,
"b_pyramid" },
1062 {
"mixed-refs",
"One reference per partition, as opposed to one reference per macroblock",
OFFSET(
mixed_refs),
AV_OPT_TYPE_BOOL, { .i64 = -1}, -1, 1, VE },
1069 {
"partitions",
"A comma-separated list of partitions to consider. " 1070 "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all",
OFFSET(
partitions),
AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1078 {
"nal-hrd",
"Signal HRD information (requires vbv-bufsize; " 1112 {
"i_qfactor",
"-1" },
1113 {
"b_qfactor",
"-1" },
1121 #if FF_API_PRIVATE_OPT 1122 {
"sc_threshold",
"-1" },
1124 {
"trellis",
"-1" },
1125 #if FF_API_PRIVATE_OPT 1128 {
"me_range",
"-1" },
1130 #if FF_API_PRIVATE_OPT 1131 {
"b_strategy",
"-1" },
1133 {
"keyint_min",
"-1" },
1134 #if FF_API_CODER_TYPE 1139 {
"thread_type",
"0" },
1140 {
"flags",
"+cgop" },
1141 {
"rc_init_occupancy",
"-1" },
1145 #if CONFIG_LIBX264_ENCODER 1146 static const AVClass x264_class = {
1164 .priv_class = &x264_class,
1168 .wrapper_name =
"libx264",
1172 #if CONFIG_LIBX264RGB_ENCODER 1173 static const AVClass rgbclass = {
1181 .
name =
"libx264rgb",
1191 .priv_class = &rgbclass,
1194 .wrapper_name =
"libx264",
1198 #if CONFIG_LIBX262_ENCODER 1199 static const AVClass X262_class = {
1217 .priv_class = &X262_class,
1221 .wrapper_name =
"libx264",
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
#define FF_PROFILE_H264_MAIN
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
const char const char void * val
static enum AVPixelFormat pix_fmt
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
static int avfmt2_num_planes(int avfmt)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
float qblur
amount of qscale smoothing over time (0.0-1.0)
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define AV_LOG_WARNING
Something somehow does not look correct.
int64_t bit_rate
the average bitrate
#define LIBAVUTIL_VERSION_INT
packed RGB 8:8:8, 24bpp, RGBRGB...
Memory handling functions.
static av_cold int init(AVCodecContext *avctx)
int max_bitrate
Maximum bitrate of the stream, in bits per second.
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
AVCodec ff_libx262_encoder
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
const char * av_default_item_name(void *ptr)
Return the context name.
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 AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int next_reordered_opaque
static void X264_log(void *p, int level, const char *fmt, va_list args)
Views are next to each other.
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
static av_cold int X264_init(AVCodecContext *avctx)
AVRational qoffset
Quantisation offset.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
#define AV_PIX_FMT_GRAY10
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This codec takes the reordered_opaque field from input AVFrames and returns it in the corresponding f...
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_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
#define FF_PROFILE_H264_BASELINE
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
int me_range
maximum motion estimation search range in subpel units If 0 then no limit.
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
int me_cmp
motion estimation comparison function
Structure to hold side data for an AVFrame.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
int interlaced_frame
The content of the picture is interlaced.
int64_t * reordered_opaque
Video is not stereoscopic (and metadata has to be there).
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
static enum AVPixelFormat pix_fmts_all[]
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
#define i(width, name, range_min, range_max)
static enum AVPixelFormat pix_fmts_10bit[]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int has_b_frames
Size of the frame reordering buffer in the decoder.
int flags
Additional information about the frame packing.
int qmax
maximum quantizer
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Views are packed per line, as if interlaced.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
#define FF_PROFILE_H264_HIGH_422
#define FF_PROFILE_H264_HIGH
int flags
AV_CODEC_FLAG_*.
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
#define AV_PIX_FMT_YUV444P10
static const AVCodecDefault defaults[]
int flags
A combination of AV_PKT_FLAG values.
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int rc_buffer_size
decoder bitstream buffer size
Views are alternated temporally.
common internal API header
as above, but U and V bytes are swapped
int refs
number of reference frames
static enum AVPixelFormat pix_fmts_9bit[]
#define PARSE_X264_OPT(name, var)
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
enum AVPictureType pict_type
Picture type of the frame.
#define OPT_STR(opt, param)
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
int width
picture width / height.
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
attribute_deprecated int noise_reduction
const char AVS_Value args
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Structure describing a single Region Of Interest.
int scenechange_threshold
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
packed RGB 8:8:8, 24bpp, BGRBGR...
int max_qdiff
maximum quantizer difference between frames
#define AV_PIX_FMT_YUV444P9
attribute_deprecated int coder_type
preferred ID for MPEG-1/2 video decoding
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
the normal 2^n-1 "JPEG" YUV ranges
static enum AVPixelFormat pix_fmts_8bit[]
static const AVCodecDefault x264_defaults[]
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
This structure describes the bitrate properties of an encoded bitstream.
enum AVStereo3DType type
How views are packed within the video.
#define AV_LOG_INFO
Standard information.
Views are packed in a checkerboard-like structure per pixel.
char * av_strdup(const char *s)
Duplicate a string.
Libavcodec external API header.
Views are on top of each other.
static av_cold int X264_close(AVCodecContext *avctx)
attribute_deprecated int scenechange_threshold
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
attribute_deprecated int b_frame_strategy
main external API structure.
static const AVOption options[]
int qmin
minimum quantizer
#define AV_PIX_FMT_YUV420P10
int64_t reordered_opaque
reordered opaque 64 bits (generally an integer or a double precision float PTS but can be anything)...
Describe the class of an AVClass context structure.
enum AVColorSpace colorspace
YUV colorspace type.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
void av_vlog(void *avcl, int level, const char *fmt, va_list vl)
Send the specified message to the log if the level is less than or equal to the current av_log_level...
static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, const x264_nal_t *nals, int nnal)
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
#define FF_PROFILE_H264_HIGH_444
#define AV_PIX_FMT_YUV420P9
attribute_deprecated int chromaoffset
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
static enum AVPixelFormat pix_fmts[]
int global_quality
Global quality for codecs which cannot change it per frame.
#define AV_PIX_FMT_YUV422P10
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
static av_cold void X264_init_static(AVCodec *codec)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Views are packed per column.
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int trellis
trellis RD quantization
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
int slices
Number of slices.
#define FF_ENABLE_DEPRECATION_WARNINGS
int top_field_first
If the content is interlaced, is top field displayed first.
int avg_bitrate
Average bitrate of the stream, in bits per second.
AVCodec ff_libx264rgb_encoder
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
AVCodec ff_libx264_encoder
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len, void **data, size_t *sei_size)
Check AVFrame for A53 side data and allocate and fill SEI message with A53 info.
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
int depth
Number of bits in the component.
#define FF_PROFILE_H264_HIGH_10
Stereoscopic 3d metadata.
#define AVERROR_EXTERNAL
Generic error in an external library.
AVPixelFormat
Pixel format.
This structure stores compressed data.
int me_subpel_quality
subpel ME quality
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int thread_type
Which multithreading methods to use.
int64_t rc_max_rate
maximum bitrate
simple arithmetic expression evaluator
#define AV_CEIL_RSHIFT(a, b)
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
int keyint_min
minimum GOP size