Go to the documentation of this file.
38 #define X264_API_IMPORTS 1
123 static const int level_map[] = {
130 if (level < 0 || level > X264_LOG_DEBUG)
138 const x264_nal_t *nals,
int nnal)
148 for (
int i = 0;
i < nnal;
i++) {
149 size += nals[
i].i_payload;
153 #if INT_MAX > INT64_MAX / INT_MAX - 1
154 if ((int64_t)
size < 0)
175 memcpy(p, nals[0].p_payload,
size);
212 x264_encoder_reconfig(x4->
enc, &x4->
params);
214 if (x4->
params.vui.i_sar_height*
ctx->sample_aspect_ratio.num !=
ctx->sample_aspect_ratio.den * x4->
params.vui.i_sar_width) {
215 x4->
params.vui.i_sar_height =
ctx->sample_aspect_ratio.den;
216 x4->
params.vui.i_sar_width =
ctx->sample_aspect_ratio.num;
217 x264_encoder_reconfig(x4->
enc, &x4->
params);
220 if (x4->
params.rc.i_vbv_buffer_size !=
ctx->rc_buffer_size / 1000 ||
221 x4->
params.rc.i_vbv_max_bitrate !=
ctx->rc_max_rate / 1000) {
222 x4->
params.rc.i_vbv_buffer_size =
ctx->rc_buffer_size / 1000;
223 x4->
params.rc.i_vbv_max_bitrate =
ctx->rc_max_rate / 1000;
224 x264_encoder_reconfig(x4->
enc, &x4->
params);
227 if (x4->
params.rc.i_rc_method == X264_RC_ABR &&
230 x264_encoder_reconfig(x4->
enc, &x4->
params);
234 x4->
params.rc.i_rc_method == X264_RC_CRF &&
235 x4->
params.rc.f_rf_constant != x4->
crf) {
237 x264_encoder_reconfig(x4->
enc, &x4->
params);
240 if (x4->
params.rc.i_rc_method == X264_RC_CQP &&
242 x4->
params.rc.i_qp_constant != x4->
cqp) {
244 x264_encoder_reconfig(x4->
enc, &x4->
params);
250 x264_encoder_reconfig(x4->
enc, &x4->
params);
259 switch (stereo->
type) {
278 #if X264_BUILD >= 145
291 "Ignoring unsupported inverted stereo value %d\n", fpa_type);
295 if (fpa_type != x4->
params.i_frame_packing) {
296 x4->
params.i_frame_packing = fpa_type;
297 x264_encoder_reconfig(x4->
enc, &x4->
params);
305 x264_picture_t *pic = &x4->
pic;
307 for (
int i = 0;
i < pic->extra_sei.num_payloads;
i++)
308 av_free(pic->extra_sei.payloads[
i].payload);
311 pic->extra_sei.num_payloads = 0;
320 x264_picture_t pic_out = {0};
323 int64_t wallclock = 0;
327 x264_picture_init( &x4->
pic );
329 #if X264_BUILD >= 153
335 x4->
pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
339 x264_sei_t *
sei = &x4->
pic.extra_sei;
340 unsigned int sei_data_size = 0;
342 for (
i = 0;
i < x4->
pic.img.i_plane;
i++) {
357 switch (
frame->pict_type) {
360 : X264_TYPE_KEYFRAME;
363 x4->
pic.i_type = X264_TYPE_P;
366 x4->
pic.i_type = X264_TYPE_B;
369 x4->
pic.i_type = X264_TYPE_AUTO;
381 }
else if (sei_data) {
382 x4->
pic.extra_sei.payloads =
av_mallocz(
sizeof(x4->
pic.extra_sei.payloads[0]));
383 if (x4->
pic.extra_sei.payloads ==
NULL) {
389 x4->
pic.extra_sei.payloads[0].payload_size = sei_size;
390 x4->
pic.extra_sei.payloads[0].payload = sei_data;
391 x4->
pic.extra_sei.num_payloads = 1;
392 x4->
pic.extra_sei.payloads[0].payload_type = 4;
399 if (x4->
params.rc.i_aq_mode == X264_AQ_NONE) {
405 if (
frame->interlaced_frame == 0) {
416 if (!roi_size || sd->
size % roi_size != 0) {
421 nb_rois = sd->
size / roi_size;
423 qoffsets =
av_calloc(mbx * mby,
sizeof(*qoffsets));
430 for (
int i = nb_rois - 1;
i >= 0;
i--) {
431 int startx, endx, starty, endy;
448 qoffset =
av_clipf(qoffset * qp_range, -qp_range, +qp_range);
450 for (
int y = starty; y < endy; y++) {
451 for (
int x = startx; x < endx; x++) {
452 qoffsets[x + y*mbx] = qoffset;
457 x4->
pic.prop.quant_offsets = qoffsets;
469 for (
int j = 0; j <
frame->nb_side_data; j++) {
472 x264_sei_payload_t *sei_payload;
482 sei_payload = &
sei->payloads[
sei->num_payloads];
484 if (!sei_payload->payload) {
488 sei_payload->payload_size = side_data->
size;
496 if (x264_encoder_encode(x4->
enc, &nal, &nnal,
frame? &x4->
pic:
NULL, &pic_out) < 0)
502 }
while (!
ret && !
frame && x264_encoder_delayed_frames(x4->
enc));
510 out_opaque = pic_out.opaque;
517 ctx->reordered_opaque = 0;
520 switch (pic_out.i_type) {
555 #if X264_BUILD >= 161
556 x264_param_cleanup(&x4->
params);
560 x264_encoder_close(x4->
enc);
572 if ((
ret = x264_param_parse(&x4->
params, opt, param)) < 0) {
573 if (
ret == X264_PARAM_BAD_NAME) {
575 "bad option '%s': '%s'\n", opt, param);
577 #if X264_BUILD >= 161
578 }
else if (
ret == X264_PARAM_ALLOC_FAILED) {
580 "out of memory parsing option '%s': '%s'\n", opt, param);
585 "bad value for '%s': '%s'\n", opt, param);
608 return X264_CSP_BGRA;
628 #define PARSE_X264_OPT(name, var)\
629 if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
630 av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
631 return AVERROR(EINVAL);\
644 #if CONFIG_LIBX262_ENCODER
647 x264_param_default_mpeg2(&x4->
params);
650 x264_param_default(&x4->
params);
659 for (
i = 0; x264_preset_names[
i];
i++)
663 for (
i = 0; x264_tune_names[
i];
i++)
669 if (avctx->
level > 0)
673 x4->
params.p_log_private = avctx;
674 x4->
params.i_log_level = X264_LOG_DEBUG;
676 #if X264_BUILD >= 153
684 av_log(avctx,
AV_LOG_ERROR,
"bit_rate and rc_max_rate > %d000 not supported by libx264\n", INT_MAX);
688 x4->
params.rc.i_rc_method = X264_RC_ABR;
694 x4->
params.rc.b_stat_read = 1;
697 x4->
params.rc.i_rc_method = X264_RC_CRF;
699 }
else if (x4->
cqp >= 0) {
700 x4->
params.rc.i_rc_method = X264_RC_CQP;
710 x4->
params.rc.f_vbv_buffer_init =
732 if (avctx->
qmin >= 0)
734 if (avctx->
qmax >= 0)
738 if (avctx->
qblur >= 0)
742 if (avctx->
refs >= 0)
744 else if (x4->
params.i_level_idc > 0) {
747 int scale = X264_BUILD < 129 ? 384 : 1;
749 for (
i = 0;
i<x264_levels[
i].level_idc;
i++)
792 x4->
params.b_vfr_input = 0;
795 #if X264_BUILD >= 142
799 "x264 too old for AVC Intra, at least version 142 needed\n");
805 "x264 too old for AVC Intra 300/480, at least version 164 needed\n");
809 x4->
params.i_avcintra_flavor = X264_AVCINTRA_FLAVOR_SONY;
813 if (x4->
b_bias != INT_MIN)
834 x264_param_apply_fastfirstpass(&x4->
params);
874 if (x264_param_apply_profile(&x4->
params, x4->
profile) < 0) {
878 for (
i = 0; x264_profile_names[
i];
i++)
887 x4->
params.vui.i_sar_width = sw;
888 x4->
params.vui.i_sar_height = sh;
916 x4->
params.vui.b_fullrange = 1;
928 x4->
params.b_repeat_headers = 0;
933 char param[4096]={0},
val[4096]={0};
934 if(sscanf(p,
"%4095[^:=]=%4095[^:]", param,
val) == 1){
948 #if X264_BUILD >= 142
951 x4->
params.b_repeat_headers = 1;
959 "Error parsing option '%s = %s'.\n",
961 #if X264_BUILD >= 161
962 if (
ret == X264_PARAM_ALLOC_FAILED)
971 x4->
params.i_bframe_pyramid ? 2 : 1 : 0;
977 x4->
enc = x264_encoder_open(&x4->
params);
986 s = x264_encoder_headers(x4->
enc, &nal, &nnal);
991 for (
i = 0;
i < nnal;
i++) {
993 if (nal[
i].i_type == NAL_SEI) {
999 memcpy(x4->
sei, nal[
i].p_payload, nal[
i].i_payload);
1002 memcpy(p, nal[
i].p_payload, nal[
i].i_payload);
1003 p += nal[
i].i_payload;
1035 #ifdef X264_CSP_NV21
1061 #ifdef X264_CSP_NV21
1068 #ifdef X264_CSP_I400
1074 #if CONFIG_LIBX264RGB_ENCODER
1083 #if X264_BUILD < 153
1086 if (x264_bit_depth == 8)
1088 else if (x264_bit_depth == 9)
1090 else if (x264_bit_depth == 10)
1095 #define OFFSET(x) offsetof(X264Context, x)
1096 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1101 {
"fastfirstpass",
"Use fast settings when encoding first pass",
OFFSET(fastfirstpass),
AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1,
VE},
1107 {
"crf",
"Select the quality for constant quality mode",
OFFSET(crf),
AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX,
VE },
1108 {
"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 },
1109 {
"qp",
"Constant quantization parameter rate control method",
OFFSET(cqp),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE },
1112 {
"variance",
"Variance AQ (complexity mask)", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX,
VE,
"aq_mode" },
1113 {
"autovariance",
"Auto-variance AQ", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX,
VE,
"aq_mode" },
1114 #if X264_BUILD >= 144
1115 {
"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" },
1117 {
"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},
1119 {
"psy-rd",
"Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.",
OFFSET(psy_rd),
AV_OPT_TYPE_STRING, {0 }, 0, 0,
VE},
1120 {
"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 },
1122 {
"weightp",
"Weighted prediction analysis method.",
OFFSET(weightp),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE,
"weightp" },
1127 {
"intra-refresh",
"Use Periodic Intra Refresh instead of IDR frames.",
OFFSET(intra_refresh),
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1,
VE },
1128 {
"bluray-compat",
"Bluray compatibility workarounds.",
OFFSET(bluray_compat) ,
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1,
VE },
1129 {
"b-bias",
"Influences how often B-frames are used",
OFFSET(b_bias),
AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX,
VE },
1130 {
"b-pyramid",
"Keep some B-frames as references.",
OFFSET(b_pyramid),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE,
"b_pyramid" },
1132 {
"strict",
"Strictly hierarchical pyramid", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX,
VE,
"b_pyramid" },
1133 {
"normal",
"Non-strict (not Blu-ray compatible)", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX,
VE,
"b_pyramid" },
1134 {
"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 },
1140 {
"cplxblur",
"Reduce fluctuations in QP (before curve compression)",
OFFSET(cplxblur),
AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX,
VE},
1141 {
"partitions",
"A comma-separated list of partitions to consider. "
1142 "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all",
OFFSET(partitions),
AV_OPT_TYPE_STRING, { 0 }, 0, 0,
VE},
1143 {
"direct-pred",
"Direct MV prediction mode",
OFFSET(direct_pred),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE,
"direct-pred" },
1148 {
"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 },
1150 {
"nal-hrd",
"Signal HRD information (requires vbv-bufsize; "
1155 {
"avcintra-class",
"AVC-Intra class 50/100/200/300/480",
OFFSET(avcintra_class),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 480 ,
VE},
1156 {
"me_method",
"Set motion estimation method",
OFFSET(motion_est),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA,
VE,
"motion-est"},
1157 {
"motion-est",
"Set motion estimation method",
OFFSET(motion_est),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA,
VE,
"motion-est"},
1163 {
"forced-idr",
"If forcing keyframes, force them as IDR frames.",
OFFSET(forced_idr),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1,
VE },
1170 {
"b_strategy",
"Strategy to choose between I/P/B-frames",
OFFSET(b_frame_strategy),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2,
VE },
1171 {
"chromaoffset",
"QP difference between chroma and luma",
OFFSET(chroma_offset),
AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX,
VE },
1172 {
"sc_threshold",
"Scene change threshold",
OFFSET(scenechange_threshold),
AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX,
VE },
1173 {
"noise_reduction",
"Noise reduction",
OFFSET(noise_reduction),
AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX,
VE },
1174 {
"udu_sei",
"Use user data unregistered SEI if available",
OFFSET(udu_sei),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
VE },
1175 {
"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 },
1184 {
"i_qfactor",
"-1" },
1185 {
"b_qfactor",
"-1" },
1193 {
"trellis",
"-1" },
1194 {
"me_range",
"-1" },
1196 {
"keyint_min",
"-1" },
1199 {
"thread_type",
"0" },
1200 {
"flags",
"+cgop" },
1201 {
"rc_init_occupancy",
"-1" },
1205 #if CONFIG_LIBX264_ENCODER
1206 static const AVClass x264_class = {
1213 #if X264_BUILD >= 153
1216 AVCodec ff_libx264_encoder = {
1228 .priv_class = &x264_class,
1230 #
if X264_BUILD < 153
1236 #
if X264_BUILD >= 158
1240 .wrapper_name =
"libx264",
1244 #if CONFIG_LIBX264RGB_ENCODER
1245 static const AVClass rgbclass = {
1253 .
name =
"libx264rgb",
1264 .priv_class = &rgbclass,
1268 #
if X264_BUILD >= 158
1272 .wrapper_name =
"libx264",
1276 #if CONFIG_LIBX262_ENCODER
1277 static const AVClass X262_class = {
1296 .priv_class = &X262_class,
1300 .wrapper_name =
"libx264",
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.
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.
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
#define AV_LOG_WARNING
Something somehow does not look correct.
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
AVPixelFormat
Pixel format.
int keyint_min
minimum GOP size
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
enum AVColorSpace colorspace
YUV colorspace type.
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
#define FF_PROFILE_H264_BASELINE
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
static void X264_log(void *p, int level, const char *fmt, va_list args)
This structure describes decoded (raw) audio or video data.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
@ AVCOL_RANGE_JPEG
Full range content.
int depth
Number of bits in the component.
#define AV_PIX_FMT_YUV420P10
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
int qmax
maximum quantizer
int me_subpel_quality
subpel ME quality
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
int roi_warned
If the encoder does not support ROI then warn the first time we encounter a frame with ROI side data.
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
static av_cold int X264_init(AVCodecContext *avctx)
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
static av_cold void init_static_data(void)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
int refs
number of reference frames
static const AVCodecDefault defaults[]
int flags
AV_CODEC_FLAG_*.
#define FF_PROFILE_H264_HIGH
static double val(void *priv, double ch)
const AVCodec ff_libx262_encoder
static av_always_inline float scale(float x, float s)
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
#define AV_PIX_FMT_YUV444P10
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
@ AV_STEREO3D_FRAMESEQUENCE
Views are alternated temporally.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static enum AVPixelFormat pix_fmts_10bit[]
Structure describing a single Region Of Interest.
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
int has_b_frames
Size of the frame reordering buffer in the decoder.
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
@ AV_STEREO3D_LINES
Views are packed per line, as if interlaced.
int global_quality
Global quality for codecs which cannot change it per frame.
#define AV_CEIL_RSHIFT(a, b)
#define AV_CODEC_EXPORT_DATA_PRFT
Export encoder Producer Reference Time through packet side data.
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
static enum AVPixelFormat pix_fmts_all[]
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This codec takes the reordered_opaque field from input AVFrames and returns it in the corresponding f...
int thread_type
Which multithreading methods to use.
static enum AVPixelFormat pix_fmts[]
#define AV_PIX_FMT_YUV420P9
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static enum AVPixelFormat pix_fmt
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
int64_t rc_max_rate
maximum bitrate
This structure describes the bitrate properties of an encoded bitstream.
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
int flags
Additional information about the frame packing.
#define AV_PIX_FMT_GRAY10
int rc_buffer_size
decoder bitstream buffer size
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
static __device__ float fabs(float a)
static enum AVPixelFormat pix_fmts_9bit[]
enum AVColorRange color_range
MPEG vs JPEG YUV range.
float qblur
amount of qscale smoothing over time (0.0-1.0)
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
int64_t bit_rate
the average bitrate
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
const char * av_default_item_name(void *ptr)
Return the context name.
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
int me_cmp
motion estimation comparison function
#define AV_PIX_FMT_YUV422P10
int trellis
trellis RD quantization
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
@ AVCOL_RANGE_UNSPECIFIED
@ SEI_TYPE_USER_DATA_UNREGISTERED
@ AV_FRAME_DATA_SEI_UNREGISTERED
User data unregistered metadata associated with a video frame.
static void dct8x8(int16_t *coef, int bit_depth)
AVDictionary * x264_params
#define PARSE_X264_OPT(name, var)
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
static enum AVPixelFormat pix_fmts_8bit[]
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
@ AV_STEREO3D_CHECKERBOARD
Views are packed in a checkerboard-like structure per pixel.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
const AVCodec ff_libx264rgb_encoder
static av_cold int X264_close(AVCodecContext *avctx)
#define FF_PROFILE_H264_HIGH_422
static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, const x264_nal_t *nals, int nnal)
int me_range
maximum motion estimation search range in subpel units If 0 then no limit.
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
@ AVCHROMA_LOC_UNSPECIFIED
@ AV_PIX_FMT_NV16
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
#define AVERROR_EXTERNAL
Generic error in an external library.
int flags
A combination of AV_PKT_FLAG values.
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
#define AV_LOG_INFO
Standard information.
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...
static const AVCodecDefault x264_defaults[]
#define i(width, name, range_min, range_max)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
#define av_malloc_array(a, b)
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
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.
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
static const AVOption options[]
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void * av_calloc(size_t nmemb, size_t size)
static av_cold void X264_init_static(AVCodec *codec)
#define AV_PIX_FMT_YUV444P9
#define AV_CODEC_FLAG_CLOSED_GOP
X264Opaque * reordered_opaque
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
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
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
@ AV_STEREO3D_COLUMNS
Views are packed per column.
enum AVStereo3DType type
How views are packed within the video.
#define FF_PROFILE_H264_HIGH_444
int next_reordered_opaque
int scenechange_threshold
#define AV_INPUT_BUFFER_PADDING_SIZE
int max_qdiff
maximum quantizer difference between frames
main external API structure.
static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
int qmin
minimum quantizer
enum AVFrameSideDataType type
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define FF_PROFILE_H264_MAIN
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
int64_t av_gettime(void)
Get the current time in microseconds.
char * av_strdup(const char *s)
Duplicate a string.
@ AV_PICTURE_TYPE_P
Predicted.
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
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...
Structure to hold side data for an AVFrame.
static int parse_opts(AVCodecContext *avctx, const char *opt, const char *param)
int slices
Number of slices.
This structure stores compressed data.
static int avfmt2_num_planes(int avfmt)
#define FF_PROFILE_H264_HIGH_10
int width
picture width / height.
@ AV_FRAME_DATA_REGIONS_OF_INTEREST
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
AVRational qoffset
Quantisation offset.
static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
void * priv_data
Format private data.
static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
static void free_picture(AVCodecContext *ctx)
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.