36 #define X264_API_IMPORTS 1
120 static const int level_map[] = {
127 if (level < 0 || level > X264_LOG_DEBUG)
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);
206 if (x4->
params.vui.i_sar_height*
ctx->sample_aspect_ratio.num !=
ctx->sample_aspect_ratio.den * x4->
params.vui.i_sar_width) {
207 x4->
params.vui.i_sar_height =
ctx->sample_aspect_ratio.den;
208 x4->
params.vui.i_sar_width =
ctx->sample_aspect_ratio.num;
209 x264_encoder_reconfig(x4->
enc, &x4->
params);
212 if (x4->
params.rc.i_vbv_buffer_size !=
ctx->rc_buffer_size / 1000 ||
213 x4->
params.rc.i_vbv_max_bitrate !=
ctx->rc_max_rate / 1000) {
214 x4->
params.rc.i_vbv_buffer_size =
ctx->rc_buffer_size / 1000;
215 x4->
params.rc.i_vbv_max_bitrate =
ctx->rc_max_rate / 1000;
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};
303 int64_t wallclock = 0;
307 x264_picture_init( &x4->
pic );
309 #if X264_BUILD >= 153
315 x4->
pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
319 for (
i = 0;
i < x4->
pic.img.i_plane;
i++) {
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) {
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;
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));
458 out_opaque = pic_out.opaque;
465 ctx->reordered_opaque = 0;
468 switch (pic_out.i_type) {
484 #if FF_API_CODED_FRAME
486 ctx->coded_frame->pict_type = pict_type;
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
1054 #if X264_BUILD < 153
1057 if (x264_bit_depth == 8)
1059 else if (x264_bit_depth == 9)
1061 else if (x264_bit_depth == 10)
1066 #define OFFSET(x) offsetof(X264Context, x)
1067 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1072 {
"fastfirstpass",
"Use fast settings when encoding first pass",
OFFSET(fastfirstpass),
AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1,
VE},
1078 {
"crf",
"Select the quality for constant quality mode",
OFFSET(crf),
AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX,
VE },
1079 {
"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 },
1080 {
"qp",
"Constant quantization parameter rate control method",
OFFSET(cqp),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE },
1083 {
"variance",
"Variance AQ (complexity mask)", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX,
VE,
"aq_mode" },
1084 {
"autovariance",
"Auto-variance AQ", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX,
VE,
"aq_mode" },
1085 #if X264_BUILD >= 144
1086 {
"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" },
1088 {
"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},
1090 {
"psy-rd",
"Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.",
OFFSET(psy_rd),
AV_OPT_TYPE_STRING, {0 }, 0, 0,
VE},
1091 {
"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 },
1093 {
"weightp",
"Weighted prediction analysis method.",
OFFSET(weightp),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE,
"weightp" },
1098 {
"intra-refresh",
"Use Periodic Intra Refresh instead of IDR frames.",
OFFSET(intra_refresh),
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1,
VE },
1099 {
"bluray-compat",
"Bluray compatibility workarounds.",
OFFSET(bluray_compat) ,
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1,
VE },
1100 {
"b-bias",
"Influences how often B-frames are used",
OFFSET(b_bias),
AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX,
VE },
1101 {
"b-pyramid",
"Keep some B-frames as references.",
OFFSET(b_pyramid),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE,
"b_pyramid" },
1103 {
"strict",
"Strictly hierarchical pyramid", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX,
VE,
"b_pyramid" },
1104 {
"normal",
"Non-strict (not Blu-ray compatible)", 0,
AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX,
VE,
"b_pyramid" },
1105 {
"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 {
"cplxblur",
"Reduce fluctuations in QP (before curve compression)",
OFFSET(cplxblur),
AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX,
VE},
1112 {
"partitions",
"A comma-separated list of partitions to consider. "
1113 "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all",
OFFSET(partitions),
AV_OPT_TYPE_STRING, { 0 }, 0, 0,
VE},
1114 {
"direct-pred",
"Direct MV prediction mode",
OFFSET(direct_pred),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX,
VE,
"direct-pred" },
1119 {
"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 },
1121 {
"nal-hrd",
"Signal HRD information (requires vbv-bufsize; "
1126 {
"avcintra-class",
"AVC-Intra class 50/100/200",
OFFSET(avcintra_class),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 200 ,
VE},
1127 {
"me_method",
"Set motion estimation method",
OFFSET(motion_est),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA,
VE,
"motion-est"},
1128 {
"motion-est",
"Set motion estimation method",
OFFSET(motion_est),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA,
VE,
"motion-est"},
1134 {
"forced-idr",
"If forcing keyframes, force them as IDR frames.",
OFFSET(forced_idr),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1,
VE },
1141 {
"b_strategy",
"Strategy to choose between I/P/B-frames",
OFFSET(b_frame_strategy),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2,
VE },
1142 {
"chromaoffset",
"QP difference between chroma and luma",
OFFSET(chroma_offset),
AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX,
VE },
1143 {
"sc_threshold",
"Scene change threshold",
OFFSET(scenechange_threshold),
AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX,
VE },
1144 {
"noise_reduction",
"Noise reduction",
OFFSET(noise_reduction),
AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX,
VE },
1146 {
"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 },
1155 {
"i_qfactor",
"-1" },
1156 {
"b_qfactor",
"-1" },
1164 #if FF_API_PRIVATE_OPT
1165 {
"sc_threshold",
"-1" },
1167 {
"trellis",
"-1" },
1168 #if FF_API_PRIVATE_OPT
1171 {
"me_range",
"-1" },
1173 #if FF_API_PRIVATE_OPT
1174 {
"b_strategy",
"-1" },
1176 {
"keyint_min",
"-1" },
1177 #if FF_API_CODER_TYPE
1182 {
"thread_type",
"0" },
1183 {
"flags",
"+cgop" },
1184 {
"rc_init_occupancy",
"-1" },
1188 #if CONFIG_LIBX264_ENCODER
1189 static const AVClass x264_class = {
1208 .priv_class = &x264_class,
1210 #
if X264_BUILD < 153
1216 #
if X264_BUILD >= 158
1220 .wrapper_name =
"libx264",
1224 #if CONFIG_LIBX264RGB_ENCODER
1225 static const AVClass rgbclass = {
1233 .
name =
"libx264rgb",
1243 .priv_class = &rgbclass,
1247 #
if X264_BUILD >= 158
1251 .wrapper_name =
"libx264",
1255 #if CONFIG_LIBX262_ENCODER
1256 static const AVClass X262_class = {
1274 .priv_class = &X262_class,
1278 .wrapper_name =
"libx264",
static double val(void *priv, double ch)
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
AVCodec ff_libx262_encoder
AVCodec ff_libx264_encoder
AVCodec ff_libx264rgb_encoder
static const AVCodecDefault defaults[]
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.
Libavcodec external API header.
#define FF_PROFILE_H264_HIGH
#define FF_PROFILE_H264_HIGH_444
#define FF_PROFILE_H264_HIGH_422
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
#define FF_PROFILE_H264_MAIN
#define FF_PROFILE_H264_HIGH_10
#define FF_PROFILE_H264_BASELINE
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
static av_cold int init(AVCodecContext *avctx)
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
#define AV_CEIL_RSHIFT(a, b)
static __device__ float fabs(float a)
static enum AVPixelFormat pix_fmt
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
simple arithmetic expression evaluator
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This codec takes the reordered_opaque field from input AVFrames and returns it in the corresponding f...
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
#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 AV_CODEC_EXPORT_DATA_PRFT
Export encoder Producer Reference Time through packet side data.
#define AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
#define AVERROR_EXTERNAL
Generic error in an external library.
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
@ AV_FRAME_DATA_REGIONS_OF_INTEREST
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
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.
const char * av_default_item_name(void *ptr)
Return the context name.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
char * av_strdup(const char *s)
Duplicate a string.
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PICTURE_TYPE_P
Predicted.
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
#define LIBAVUTIL_VERSION_INT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
@ AV_STEREO3D_COLUMNS
Views are packed per column.
@ AV_STEREO3D_LINES
Views are packed per line, as if interlaced.
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
@ AV_STEREO3D_CHECKERBOARD
Views are packed in a checkerboard-like structure per pixel.
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
@ AV_STEREO3D_FRAMESEQUENCE
Views are alternated temporally.
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
#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_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define FF_DISABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
static enum AVPixelFormat pix_fmts[]
static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
static enum AVPixelFormat pix_fmts_10bit[]
static av_cold int X264_close(AVCodecContext *avctx)
static enum AVPixelFormat pix_fmts_9bit[]
static const AVOption options[]
#define PARSE_X264_OPT(name, var)
static av_cold int X264_init(AVCodecContext *avctx)
static av_cold void X264_init_static(AVCodec *codec)
static int parse_opts(AVCodecContext *avctx, const char *opt, const char *param)
static const AVCodecDefault x264_defaults[]
static void X264_log(void *p, int level, const char *fmt, va_list args)
static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
static enum AVPixelFormat pix_fmts_8bit[]
static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, const x264_nal_t *nals, int nnal)
static enum AVPixelFormat pix_fmts_all[]
static int avfmt2_num_planes(int avfmt)
static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
Memory handling functions.
static av_cold void init_static_data(void)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV420P10
@ AVCOL_RANGE_JPEG
Full range content.
#define AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV420P9
AVPixelFormat
Pixel format.
@ 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...
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
@ AV_PIX_FMT_NV16
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
#define AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_YUV444P10
This structure describes the bitrate properties of an encoded bitstream.
int avg_bitrate
Average bitrate of the stream, in bits per second.
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
int trellis
trellis RD quantization
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int max_qdiff
maximum quantizer difference between frames
int width
picture width / height.
int rc_buffer_size
decoder bitstream buffer size
int me_cmp
motion estimation comparison function
int global_quality
Global quality for codecs which cannot change it per frame.
attribute_deprecated int coder_type
attribute_deprecated int scenechange_threshold
enum AVColorRange color_range
MPEG vs JPEG YUV range.
attribute_deprecated int chromaoffset
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
int me_subpel_quality
subpel ME quality
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...
int qmin
minimum quantizer
int keyint_min
minimum GOP size
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...
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
int has_b_frames
Size of the frame reordering buffer in the decoder.
int64_t bit_rate
the average bitrate
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
int thread_type
Which multithreading methods to use.
enum AVColorSpace colorspace
YUV colorspace type.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
int refs
number of reference frames
int64_t rc_max_rate
maximum bitrate
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
int qmax
maximum quantizer
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
int flags
AV_CODEC_FLAG_*.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
float qblur
amount of qscale smoothing over time (0.0-1.0)
int me_range
maximum motion estimation search range in subpel units If 0 then no limit.
attribute_deprecated int noise_reduction
attribute_deprecated int b_frame_strategy
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
int slices
Number of slices.
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
const char * name
Name of the codec implementation.
int depth
Number of bits in the component.
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
void * priv_data
Format private data.
Structure to hold side data for an AVFrame.
This structure describes decoded (raw) audio or video data.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int top_field_first
If the content is interlaced, is top field displayed first.
int interlaced_frame
The content of the picture is interlaced.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
int64_t reordered_opaque
reordered opaque 64 bits (generally an integer or a double precision float PTS but can be anything).
enum AVPictureType pict_type
Picture type of the frame.
This structure stores compressed data.
int flags
A combination of AV_PKT_FLAG values.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Structure describing a single Region Of Interest.
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
AVRational qoffset
Quantisation offset.
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
enum AVStereo3DType type
How views are packed within the video.
int flags
Additional information about the frame packing.
int next_reordered_opaque
AVDictionary * x264_params
X264Opaque * reordered_opaque
int scenechange_threshold
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_malloc_array(a, b)
static void dct8x8(int16_t *coef, int bit_depth)
int64_t av_gettime(void)
Get the current time in microseconds.
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)