36 #define X264_API_IMPORTS 1 120 static const int level_map[] = {
127 if (level < 0 || level > X264_LOG_DEBUG)
130 av_vlog(p, level_map[level], fmt, args);
135 const x264_nal_t *nals,
int nnal)
144 for (i = 0; i < nnal; i++)
145 size += nals[i].i_payload;
164 for (i = 0; i < nnal; i++){
165 memcpy(p, nals[i].p_payload, nals[i].i_payload);
166 p += nals[
i].i_payload;
204 x264_encoder_reconfig(x4->
enc, &x4->
params);
209 x264_encoder_reconfig(x4->
enc, &x4->
params);
216 x264_encoder_reconfig(x4->
enc, &x4->
params);
219 if (x4->
params.rc.i_rc_method == X264_RC_ABR &&
222 x264_encoder_reconfig(x4->
enc, &x4->
params);
226 x4->
params.rc.i_rc_method == X264_RC_CRF &&
227 x4->
params.rc.f_rf_constant != x4->
crf) {
229 x264_encoder_reconfig(x4->
enc, &x4->
params);
232 if (x4->
params.rc.i_rc_method == X264_RC_CQP &&
234 x4->
params.rc.i_qp_constant != x4->
cqp) {
236 x264_encoder_reconfig(x4->
enc, &x4->
params);
242 x264_encoder_reconfig(x4->
enc, &x4->
params);
251 switch (stereo->
type) {
270 #if X264_BUILD >= 145 283 "Ignoring unsupported inverted stereo value %d\n", fpa_type);
287 if (fpa_type != x4->
params.i_frame_packing) {
288 x4->
params.i_frame_packing = fpa_type;
289 x264_encoder_reconfig(x4->
enc, &x4->
params);
300 x264_picture_t pic_out = {0};
307 x264_picture_init( &x4->
pic );
309 #if X264_BUILD >= 153 310 bit_depth = x4->
params.i_bitdepth;
312 bit_depth = x264_bit_depth;
315 x4->
pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
319 for (i = 0; i < x4->
pic.img.i_plane; i++) {
324 x4->
pic.i_pts = frame->
pts;
337 : X264_TYPE_KEYFRAME;
340 x4->
pic.i_type = X264_TYPE_P;
343 x4->
pic.i_type = X264_TYPE_B;
346 x4->
pic.i_type = X264_TYPE_AUTO;
358 }
else if (sei_data) {
359 x4->
pic.extra_sei.payloads =
av_mallocz(
sizeof(x4->
pic.extra_sei.payloads[0]));
360 if (x4->
pic.extra_sei.payloads ==
NULL) {
366 x4->
pic.extra_sei.payloads[0].payload_size = sei_size;
367 x4->
pic.extra_sei.payloads[0].payload = sei_data;
368 x4->
pic.extra_sei.num_payloads = 1;
369 x4->
pic.extra_sei.payloads[0].payload_type = 4;
376 if (x4->
params.rc.i_aq_mode == X264_AQ_NONE) {
379 av_log(ctx,
AV_LOG_WARNING,
"Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
385 int qp_range = 51 + 6 * (bit_depth - 8);
393 if (!roi_size || sd->
size % roi_size != 0) {
397 nb_rois = sd->
size / roi_size;
405 for (
int i = nb_rois - 1; i >= 0; i--) {
406 int startx, endx, starty, endy;
422 qoffset =
av_clipf(qoffset * qp_range, -qp_range, +qp_range);
424 for (
int y = starty; y < endy; y++) {
425 for (
int x = startx; x < endx; x++) {
426 qoffsets[x + y*mbx] = qoffset;
431 x4->
pic.prop.quant_offsets = qoffsets;
436 av_log(ctx,
AV_LOG_WARNING,
"interlaced_frame not supported for ROI encoding yet, skipping ROI.\n");
444 if (x264_encoder_encode(x4->
enc, &nal, &nnal, frame? &x4->
pic:
NULL, &pic_out) < 0)
450 }
while (!ret && !frame && x264_encoder_delayed_frames(x4->
enc));
455 pkt->
pts = pic_out.i_pts;
456 pkt->
dts = pic_out.i_dts;
458 out_opaque = pic_out.opaque;
468 switch (pic_out.i_type) {
484 #if FF_API_CODED_FRAME 496 #if FF_API_CODED_FRAME 515 #if X264_BUILD >= 161 516 x264_param_cleanup(&x4->
params);
520 x264_encoder_close(x4->
enc);
532 if ((ret = x264_param_parse(&x4->
params, opt, param)) < 0) {
533 if (ret == X264_PARAM_BAD_NAME) {
535 "bad option '%s': '%s'\n", opt, param);
537 #if X264_BUILD >= 161 538 }
else if (ret == X264_PARAM_ALLOC_FAILED) {
540 "out of memory parsing option '%s': '%s'\n", opt, param);
545 "bad value for '%s': '%s'\n", opt, param);
567 #if CONFIG_LIBX264RGB_ENCODER 569 return X264_CSP_BGRA;
590 #define PARSE_X264_OPT(name, var)\ 591 if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\ 592 av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\ 593 return AVERROR(EINVAL);\ 606 #if CONFIG_LIBX262_ENCODER 609 x264_param_default_mpeg2(&x4->
params);
612 x264_param_default(&x4->
params);
621 for (i = 0; x264_preset_names[
i]; i++)
625 for (i = 0; x264_tune_names[
i]; i++)
631 if (avctx->
level > 0)
635 x4->
params.p_log_private = avctx;
636 x4->
params.i_log_level = X264_LOG_DEBUG;
638 #if X264_BUILD >= 153 646 av_log(avctx,
AV_LOG_ERROR,
"bit_rate and rc_max_rate > %d000 not supported by libx264\n", INT_MAX);
650 x4->
params.rc.i_rc_method = X264_RC_ABR;
656 x4->
params.rc.b_stat_read = 1;
659 x4->
params.rc.i_rc_method = X264_RC_CRF;
661 }
else if (x4->
cqp >= 0) {
662 x4->
params.rc.i_rc_method = X264_RC_CQP;
672 x4->
params.rc.f_vbv_buffer_init =
683 #if FF_API_PRIVATE_OPT 697 #if FF_API_PRIVATE_OPT 706 if (avctx->
qmin >= 0)
708 if (avctx->
qmax >= 0)
712 if (avctx->
qblur >= 0)
716 if (avctx->
refs >= 0)
718 else if (x4->
params.i_level_idc > 0) {
721 int scale = X264_BUILD < 129 ? 384 : 1;
723 for (i = 0; i<x264_levels[
i].level_idc; i++)
725 x4->
params.i_frame_reference =
av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->
params.i_frame_reference);
732 #if FF_API_PRIVATE_OPT 742 #if FF_API_PRIVATE_OPT 750 #if FF_API_CODER_TYPE 784 x4->
params.b_vfr_input = 0;
787 #if X264_BUILD >= 142 791 "x264 too old for AVC Intra, at least version 142 needed\n");
793 if (x4->
b_bias != INT_MIN)
814 x264_param_apply_fastfirstpass(&x4->
params);
854 if (x264_param_apply_profile(&x4->
params, x4->
profile) < 0) {
858 for (i = 0; x264_profile_names[
i]; i++)
867 x4->
params.vui.i_sar_width = sw;
868 x4->
params.vui.i_sar_height = sh;
904 x4->
params.b_repeat_headers = 0;
909 char param[4096]={0},
val[4096]={0};
910 if(sscanf(p,
"%4095[^:=]=%4095[^:]", param,
val) == 1){
928 if ((ret = x264_param_parse(&x4->
params, en->
key, en->
value)) < 0) {
930 "Error parsing option '%s = %s'.\n",
932 #if X264_BUILD >= 161 933 if (ret == X264_PARAM_ALLOC_FAILED)
942 x4->
params.i_bframe_pyramid ? 2 : 1 : 0;
948 x4->
enc = x264_encoder_open(&x4->
params);
957 s = x264_encoder_headers(x4->
enc, &nal, &nnal);
962 for (i = 0; i < nnal; i++) {
964 if (nal[i].i_type == NAL_SEI) {
970 memcpy(x4->
sei, nal[i].p_payload, nal[i].i_payload);
973 memcpy(p, nal[i].p_payload, nal[i].i_payload);
974 p += nal[
i].i_payload;
1006 #ifdef X264_CSP_NV21 1032 #ifdef X264_CSP_NV21 1039 #ifdef X264_CSP_I400 1045 #if CONFIG_LIBX264RGB_ENCODER 1056 #if X264_BUILD < 153 1057 if (x264_bit_depth == 8)
1059 else if (x264_bit_depth == 9)
1061 else if (x264_bit_depth == 10)
1068 #define OFFSET(x) offsetof(X264Context, x) 1069 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 1074 {
"fastfirstpass",
"Use fast settings when encoding first pass",
OFFSET(fastfirstpass),
AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1,
VE},
1078 {
"a53cc",
"Use A53 Closed Captions (if available)",
OFFSET(a53_cc),
AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VE},
1080 {
"crf",
"Select the quality for constant quality mode",
OFFSET(crf),
AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
1081 {
"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 },
1082 {
"qp",
"Constant quantization parameter rate control method",
OFFSET(cqp),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
1085 {
"variance",
"Variance AQ (complexity mask)", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX,
VE,
"aq_mode" },
1086 {
"autovariance",
"Auto-variance AQ", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX,
VE,
"aq_mode" },
1087 #if X264_BUILD >= 144 1088 {
"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" },
1090 {
"aq-strength",
"AQ strength. Reduces blocking and blurring in flat and textured areas.",
OFFSET(aq_strength),
AV_OPT_TYPE_FLOAT, {.dbl = -1}, -1, FLT_MAX, VE},
1092 {
"psy-rd",
"Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.",
OFFSET(psy_rd),
AV_OPT_TYPE_STRING, {0 }, 0, 0, VE},
1093 {
"rc-lookahead",
"Number of frames to look ahead for frametype and ratecontrol",
OFFSET(rc_lookahead),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
1094 {
"weightb",
"Weighted prediction for B-frames.",
OFFSET(weightb),
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1095 {
"weightp",
"Weighted prediction analysis method.",
OFFSET(weightp),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE,
"weightp" },
1100 {
"intra-refresh",
"Use Periodic Intra Refresh instead of IDR frames.",
OFFSET(intra_refresh),
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1101 {
"bluray-compat",
"Bluray compatibility workarounds.",
OFFSET(bluray_compat) ,
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1102 {
"b-bias",
"Influences how often B-frames are used",
OFFSET(b_bias),
AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX, VE },
1103 {
"b-pyramid",
"Keep some B-frames as references.",
OFFSET(b_pyramid),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE,
"b_pyramid" },
1105 {
"strict",
"Strictly hierarchical pyramid", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX,
VE,
"b_pyramid" },
1106 {
"normal",
"Non-strict (not Blu-ray compatible)", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX,
VE,
"b_pyramid" },
1107 {
"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 },
1111 {
"mbtree",
"Use macroblock tree ratecontrol.",
OFFSET(mbtree),
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1112 {
"deblock",
"Loop filter parameters, in <alpha:beta> form.",
OFFSET(deblock),
AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1113 {
"cplxblur",
"Reduce fluctuations in QP (before curve compression)",
OFFSET(cplxblur),
AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},
1114 {
"partitions",
"A comma-separated list of partitions to consider. " 1115 "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all",
OFFSET(partitions),
AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1116 {
"direct-pred",
"Direct MV prediction mode",
OFFSET(direct_pred),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE,
"direct-pred" },
1121 {
"slice-max-size",
"Limit the size of each slice in bytes",
OFFSET(slice_max_size),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
1123 {
"nal-hrd",
"Signal HRD information (requires vbv-bufsize; " 1128 {
"avcintra-class",
"AVC-Intra class 50/100/200",
OFFSET(avcintra_class),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 200 , VE},
1129 {
"me_method",
"Set motion estimation method",
OFFSET(motion_est),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA,
VE,
"motion-est"},
1130 {
"motion-est",
"Set motion estimation method",
OFFSET(motion_est),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA,
VE,
"motion-est"},
1136 {
"forced-idr",
"If forcing keyframes, force them as IDR frames.",
OFFSET(forced_idr),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1, VE },
1143 {
"b_strategy",
"Strategy to choose between I/P/B-frames",
OFFSET(b_frame_strategy),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
1144 {
"chromaoffset",
"QP difference between chroma and luma",
OFFSET(chroma_offset),
AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, VE },
1145 {
"sc_threshold",
"Scene change threshold",
OFFSET(scenechange_threshold),
AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1146 {
"noise_reduction",
"Noise reduction",
OFFSET(noise_reduction),
AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1148 {
"x264-params",
"Override the x264 configuration using a :-separated list of key=value parameters",
OFFSET(x264_params),
AV_OPT_TYPE_DICT, { 0 }, 0, 0, VE },
1157 {
"i_qfactor",
"-1" },
1158 {
"b_qfactor",
"-1" },
1166 #if FF_API_PRIVATE_OPT 1167 {
"sc_threshold",
"-1" },
1169 {
"trellis",
"-1" },
1170 #if FF_API_PRIVATE_OPT 1173 {
"me_range",
"-1" },
1175 #if FF_API_PRIVATE_OPT 1176 {
"b_strategy",
"-1" },
1178 {
"keyint_min",
"-1" },
1179 #if FF_API_CODER_TYPE 1184 {
"thread_type",
"0" },
1185 {
"flags",
"+cgop" },
1186 {
"rc_init_occupancy",
"-1" },
1190 #if CONFIG_LIBX264_ENCODER 1191 static const AVClass x264_class = {
1209 .priv_class = &x264_class,
1212 #
if X264_BUILD >= 158
1217 .wrapper_name =
"libx264",
1221 #if CONFIG_LIBX264RGB_ENCODER 1222 static const AVClass rgbclass = {
1230 .
name =
"libx264rgb",
1240 .priv_class = &rgbclass,
1243 #
if X264_BUILD >= 158
1248 .wrapper_name =
"libx264",
1252 #if CONFIG_LIBX262_ENCODER 1253 static const AVClass X262_class = {
1271 .priv_class = &X262_class,
1275 .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)
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
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
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)
int roi_warned
If the encoder does not support ROI then warn the first time we encounter a frame with ROI side data...
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
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame...
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.
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[]
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_PKT_FLAG_KEY
The packet contains a keyframe.
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.
static void dct8x8(int16_t *coef, int bit_depth)
static __device__ float fabs(float a)
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_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...
#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...
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
X264Opaque * reordered_opaque
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.
AVDictionary * x264_params
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)
static av_cold void init_static_data(void)
attribute_deprecated int noise_reduction
#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.
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#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() ...
static enum AVPixelFormat pix_fmts_8bit[]
int64_t av_gettime(void)
Get the current time in microseconds.
static const AVCodecDefault x264_defaults[]
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
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
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 ...
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
#define AV_CODEC_EXPORT_DATA_PRFT
Export encoder Producer Reference Time through packet side data.
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)
static int parse_opts(AVCodecContext *avctx, const char *opt, const char *param)
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 ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
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...
#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
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
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.
static double val(void *priv, double ch)
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)
int keyint_min
minimum GOP size