Go to the documentation of this file.
22 #include "config_components.h"
41 #define X264_API_IMPORTS 1
126 static const int level_map[] = {
133 if (level < 0 || level > X264_LOG_DEBUG)
141 const x264_nal_t *nals,
int nnal)
151 for (
int i = 0;
i < nnal;
i++) {
152 size += nals[
i].i_payload;
156 #if INT_MAX > INT64_MAX / INT_MAX - 1
157 if ((int64_t)
size < 0)
178 memcpy(p, nals[0].p_payload,
size);
215 x264_encoder_reconfig(x4->
enc, &x4->
params);
217 if (x4->
params.vui.i_sar_height*
ctx->sample_aspect_ratio.num !=
ctx->sample_aspect_ratio.den * x4->
params.vui.i_sar_width) {
218 x4->
params.vui.i_sar_height =
ctx->sample_aspect_ratio.den;
219 x4->
params.vui.i_sar_width =
ctx->sample_aspect_ratio.num;
220 x264_encoder_reconfig(x4->
enc, &x4->
params);
223 if (x4->
params.rc.i_vbv_buffer_size !=
ctx->rc_buffer_size / 1000 ||
224 x4->
params.rc.i_vbv_max_bitrate !=
ctx->rc_max_rate / 1000) {
225 x4->
params.rc.i_vbv_buffer_size =
ctx->rc_buffer_size / 1000;
226 x4->
params.rc.i_vbv_max_bitrate =
ctx->rc_max_rate / 1000;
227 x264_encoder_reconfig(x4->
enc, &x4->
params);
230 if (x4->
params.rc.i_rc_method == X264_RC_ABR &&
233 x264_encoder_reconfig(x4->
enc, &x4->
params);
237 x4->
params.rc.i_rc_method == X264_RC_CRF &&
238 x4->
params.rc.f_rf_constant != x4->
crf) {
240 x264_encoder_reconfig(x4->
enc, &x4->
params);
243 if (x4->
params.rc.i_rc_method == X264_RC_CQP &&
245 x4->
params.rc.i_qp_constant != x4->
cqp) {
247 x264_encoder_reconfig(x4->
enc, &x4->
params);
253 x264_encoder_reconfig(x4->
enc, &x4->
params);
262 switch (stereo->
type) {
281 #if X264_BUILD >= 145
294 "Ignoring unsupported inverted stereo value %d\n", fpa_type);
298 if (fpa_type != x4->
params.i_frame_packing) {
299 x4->
params.i_frame_packing = fpa_type;
300 x264_encoder_reconfig(x4->
enc, &x4->
params);
308 x264_picture_t *pic = &x4->
pic;
310 for (
int i = 0;
i < pic->extra_sei.num_payloads;
i++)
311 av_free(pic->extra_sei.payloads[
i].payload);
314 pic->extra_sei.num_payloads = 0;
323 x264_picture_t pic_out = {0};
326 int64_t wallclock = 0;
330 x264_picture_init( &x4->
pic );
332 #if X264_BUILD >= 153
338 x4->
pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
342 x264_sei_t *
sei = &x4->
pic.extra_sei;
343 unsigned int sei_data_size = 0;
345 for (
i = 0;
i < x4->
pic.img.i_plane;
i++) {
360 switch (
frame->pict_type) {
363 : X264_TYPE_KEYFRAME;
366 x4->
pic.i_type = X264_TYPE_P;
369 x4->
pic.i_type = X264_TYPE_B;
372 x4->
pic.i_type = X264_TYPE_AUTO;
384 }
else if (sei_data) {
385 x4->
pic.extra_sei.payloads =
av_mallocz(
sizeof(x4->
pic.extra_sei.payloads[0]));
386 if (x4->
pic.extra_sei.payloads ==
NULL) {
392 x4->
pic.extra_sei.payloads[0].payload_size = sei_size;
393 x4->
pic.extra_sei.payloads[0].payload = sei_data;
394 x4->
pic.extra_sei.num_payloads = 1;
395 x4->
pic.extra_sei.payloads[0].payload_type = 4;
402 if (x4->
params.rc.i_aq_mode == X264_AQ_NONE) {
408 if (
frame->interlaced_frame == 0) {
419 if (!roi_size || sd->
size % roi_size != 0) {
424 nb_rois = sd->
size / roi_size;
426 qoffsets =
av_calloc(mbx * mby,
sizeof(*qoffsets));
433 for (
int i = nb_rois - 1;
i >= 0;
i--) {
434 int startx, endx, starty, endy;
451 qoffset =
av_clipf(qoffset * qp_range, -qp_range, +qp_range);
453 for (
int y = starty; y < endy; y++) {
454 for (
int x = startx; x < endx; x++) {
455 qoffsets[x + y*mbx] = qoffset;
460 x4->
pic.prop.quant_offsets = qoffsets;
472 for (
int j = 0; j <
frame->nb_side_data; j++) {
475 x264_sei_payload_t *sei_payload;
485 sei_payload = &
sei->payloads[
sei->num_payloads];
487 if (!sei_payload->payload) {
491 sei_payload->payload_size = side_data->
size;
499 if (x264_encoder_encode(x4->
enc, &nal, &nnal,
frame? &x4->
pic:
NULL, &pic_out) < 0)
505 }
while (!
ret && !
frame && x264_encoder_delayed_frames(x4->
enc));
513 out_opaque = pic_out.opaque;
520 ctx->reordered_opaque = 0;
523 switch (pic_out.i_type) {
558 #if X264_BUILD >= 161
559 x264_param_cleanup(&x4->
params);
563 x264_encoder_close(x4->
enc);
575 if ((
ret = x264_param_parse(&x4->
params, opt, param)) < 0) {
576 if (
ret == X264_PARAM_BAD_NAME) {
578 "bad option '%s': '%s'\n", opt, param);
580 #if X264_BUILD >= 161
581 }
else if (
ret == X264_PARAM_ALLOC_FAILED) {
583 "out of memory parsing option '%s': '%s'\n", opt, param);
588 "bad value for '%s': '%s'\n", opt, param);
611 return X264_CSP_BGRA;
631 #define PARSE_X264_OPT(name, var)\
632 if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
633 av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
634 return AVERROR(EINVAL);\
647 #if CONFIG_LIBX262_ENCODER
650 x264_param_default_mpeg2(&x4->
params);
653 x264_param_default(&x4->
params);
662 for (
i = 0; x264_preset_names[
i];
i++)
666 for (
i = 0; x264_tune_names[
i];
i++)
672 if (avctx->
level > 0)
676 x4->
params.p_log_private = avctx;
677 x4->
params.i_log_level = X264_LOG_DEBUG;
679 #if X264_BUILD >= 153
687 av_log(avctx,
AV_LOG_ERROR,
"bit_rate and rc_max_rate > %d000 not supported by libx264\n", INT_MAX);
691 x4->
params.rc.i_rc_method = X264_RC_ABR;
697 x4->
params.rc.b_stat_read = 1;
700 x4->
params.rc.i_rc_method = X264_RC_CRF;
702 }
else if (x4->
cqp >= 0) {
703 x4->
params.rc.i_rc_method = X264_RC_CQP;
713 x4->
params.rc.f_vbv_buffer_init =
735 if (avctx->
qmin >= 0)
737 if (avctx->
qmax >= 0)
741 if (avctx->
qblur >= 0)
745 if (avctx->
refs >= 0)
747 else if (x4->
params.i_level_idc > 0) {
750 int scale = X264_BUILD < 129 ? 384 : 1;
752 for (
i = 0;
i<x264_levels[
i].level_idc;
i++)
795 x4->
params.b_vfr_input = 0;
798 #if X264_BUILD >= 142
802 "x264 too old for AVC Intra, at least version 142 needed\n");
808 "x264 too old for AVC Intra 300/480, at least version 164 needed\n");
812 x4->
params.i_avcintra_flavor = X264_AVCINTRA_FLAVOR_SONY;
816 if (x4->
b_bias != INT_MIN)
837 x264_param_apply_fastfirstpass(&x4->
params);
877 if (x264_param_apply_profile(&x4->
params, x4->
profile) < 0) {
881 for (
i = 0; x264_profile_names[
i];
i++)
890 x4->
params.vui.i_sar_width = sw;
891 x4->
params.vui.i_sar_height = sh;
919 x4->
params.vui.b_fullrange = 1;
931 x4->
params.b_repeat_headers = 0;
936 char param[4096]={0},
val[4096]={0};
937 if(sscanf(p,
"%4095[^:=]=%4095[^:]", param,
val) == 1){
951 #if X264_BUILD >= 142
954 x4->
params.b_repeat_headers = 1;
962 "Error parsing option '%s = %s'.\n",
964 #if X264_BUILD >= 161
965 if (
ret == X264_PARAM_ALLOC_FAILED)
974 x4->
params.i_bframe_pyramid ? 2 : 1 : 0;
980 x4->
enc = x264_encoder_open(&x4->
params);
989 s = x264_encoder_headers(x4->
enc, &nal, &nnal);
994 for (
i = 0;
i < nnal;
i++) {
996 if (nal[
i].i_type == NAL_SEI) {
1002 memcpy(x4->
sei, nal[
i].p_payload, nal[
i].i_payload);
1005 memcpy(p, nal[
i].p_payload, nal[
i].i_payload);
1006 p += nal[
i].i_payload;
1038 #ifdef X264_CSP_NV21
1064 #ifdef X264_CSP_NV21
1071 #ifdef X264_CSP_I400
1077 #if CONFIG_LIBX264RGB_ENCODER
1086 #if X264_BUILD < 153
1089 if (x264_bit_depth == 8)
1091 else if (x264_bit_depth == 9)
1093 else if (x264_bit_depth == 10)
1098 #define OFFSET(x) offsetof(X264Context, x)
1099 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1104 {
"fastfirstpass",
"Use fast settings when encoding first pass",
OFFSET(fastfirstpass),
AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1,
VE},
1110 {
"crf",
"Select the quality for constant quality mode",
OFFSET(crf),
AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX,
VE },
1111 {
"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 },
1112 {
"qp",
"Constant quantization parameter rate control method",
OFFSET(cqp),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE },
1115 {
"variance",
"Variance AQ (complexity mask)", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX,
VE,
"aq_mode" },
1116 {
"autovariance",
"Auto-variance AQ", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX,
VE,
"aq_mode" },
1117 #if X264_BUILD >= 144
1118 {
"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" },
1120 {
"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},
1122 {
"psy-rd",
"Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.",
OFFSET(psy_rd),
AV_OPT_TYPE_STRING, {0 }, 0, 0,
VE},
1123 {
"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 },
1125 {
"weightp",
"Weighted prediction analysis method.",
OFFSET(weightp),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE,
"weightp" },
1130 {
"intra-refresh",
"Use Periodic Intra Refresh instead of IDR frames.",
OFFSET(intra_refresh),
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1,
VE },
1131 {
"bluray-compat",
"Bluray compatibility workarounds.",
OFFSET(bluray_compat) ,
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1,
VE },
1132 {
"b-bias",
"Influences how often B-frames are used",
OFFSET(b_bias),
AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX,
VE },
1133 {
"b-pyramid",
"Keep some B-frames as references.",
OFFSET(b_pyramid),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE,
"b_pyramid" },
1135 {
"strict",
"Strictly hierarchical pyramid", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX,
VE,
"b_pyramid" },
1136 {
"normal",
"Non-strict (not Blu-ray compatible)", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX,
VE,
"b_pyramid" },
1137 {
"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 },
1143 {
"cplxblur",
"Reduce fluctuations in QP (before curve compression)",
OFFSET(cplxblur),
AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX,
VE},
1144 {
"partitions",
"A comma-separated list of partitions to consider. "
1145 "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all",
OFFSET(partitions),
AV_OPT_TYPE_STRING, { 0 }, 0, 0,
VE},
1146 {
"direct-pred",
"Direct MV prediction mode",
OFFSET(direct_pred),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE,
"direct-pred" },
1151 {
"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 },
1153 {
"nal-hrd",
"Signal HRD information (requires vbv-bufsize; "
1158 {
"avcintra-class",
"AVC-Intra class 50/100/200/300/480",
OFFSET(avcintra_class),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 480 ,
VE},
1159 {
"me_method",
"Set motion estimation method",
OFFSET(motion_est),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA,
VE,
"motion-est"},
1160 {
"motion-est",
"Set motion estimation method",
OFFSET(motion_est),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA,
VE,
"motion-est"},
1166 {
"forced-idr",
"If forcing keyframes, force them as IDR frames.",
OFFSET(forced_idr),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1,
VE },
1173 {
"b_strategy",
"Strategy to choose between I/P/B-frames",
OFFSET(b_frame_strategy),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2,
VE },
1174 {
"chromaoffset",
"QP difference between chroma and luma",
OFFSET(chroma_offset),
AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX,
VE },
1175 {
"sc_threshold",
"Scene change threshold",
OFFSET(scenechange_threshold),
AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX,
VE },
1176 {
"noise_reduction",
"Noise reduction",
OFFSET(noise_reduction),
AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX,
VE },
1177 {
"udu_sei",
"Use user data unregistered SEI if available",
OFFSET(udu_sei),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
VE },
1178 {
"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 },
1187 {
"i_qfactor",
"-1" },
1188 {
"b_qfactor",
"-1" },
1196 {
"trellis",
"-1" },
1197 {
"me_range",
"-1" },
1199 {
"keyint_min",
"-1" },
1202 {
"thread_type",
"0" },
1203 {
"flags",
"+cgop" },
1204 {
"rc_init_occupancy",
"-1" },
1208 #if CONFIG_LIBX264_ENCODER
1209 static const AVClass x264_class = {
1216 #if X264_BUILD >= 153
1219 FFCodec ff_libx264_encoder = {
1220 .
p.
name =
"libx264",
1227 .p.priv_class = &x264_class,
1228 .p.wrapper_name =
"libx264",
1234 #if X264_BUILD < 153
1240 #if X264_BUILD >= 158
1247 #if CONFIG_LIBX264RGB_ENCODER
1248 static const AVClass rgbclass = {
1256 .
p.
name =
"libx264rgb",
1263 .p.pix_fmts = pix_fmts_8bit_rgb,
1264 .p.priv_class = &rgbclass,
1265 .p.wrapper_name =
"libx264",
1272 #if X264_BUILD >= 158
1279 #if CONFIG_LIBX262_ENCODER
1280 static const AVClass X262_class = {
1288 .
p.
name =
"libx262",
1296 .p.priv_class = &X262_class,
1297 .p.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.
AVPixelFormat
Pixel format.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
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.
const FFCodec ff_libx264rgb_encoder
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.
static av_cold void X264_init_static(FFCodec *codec)
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
AVCodec p
The public AVCodec.
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
int flags
AV_CODEC_FLAG_*.
#define FF_PROFILE_H264_HIGH
static double val(void *priv, double ch)
static av_always_inline float scale(float x, float s)
#define FF_CODEC_ENCODE_CB(func)
#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.
#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
@ 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)
@ 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
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...
#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.
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.
static const FFCodecDefault x264_defaults[]
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
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)
#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.
const FFCodec ff_libx262_encoder
#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
@ SEI_TYPE_USER_DATA_UNREGISTERED
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...
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
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.