#include "libavutil/mem.h"
#include "libavutil/pixdesc.h"
#include "libavutil/stereo3d.h"
+#include "libavutil/time.h"
#include "libavutil/intreadwrite.h"
#include "avcodec.h"
#include "internal.h"
+#include "packet_internal.h"
+#include "atsc_a53.h"
#if defined(_MSC_VER)
#define X264_API_IMPORTS 1
// blocks of pixels (with respect to the luma plane)
#define MB_SIZE 16
+typedef struct X264Opaque {
+ int64_t reordered_opaque;
+ int64_t wallclock;
+} X264Opaque;
+
typedef struct X264Context {
AVClass *class;
x264_param_t params;
int scenechange_threshold;
int noise_reduction;
- char *x264_params;
+ AVDictionary *x264_params;
int nb_reordered_opaque, next_reordered_opaque;
- int64_t *reordered_opaque;
+ X264Opaque *reordered_opaque;
+
+ /**
+ * If the encoder does not support ROI then warn the first time we
+ * encounter a frame with ROI side data.
+ */
+ int roi_warned;
} X264Context;
static void X264_log(void *p, int level, const char *fmt, va_list args)
AVFrameSideData *side_data;
- if (x4->avcintra_class < 0) {
- if (x4->params.b_interlaced && x4->params.b_tff != frame->top_field_first) {
+ if (x4->avcintra_class < 0) {
+ if (x4->params.b_interlaced && x4->params.b_tff != frame->top_field_first) {
- x4->params.b_tff = frame->top_field_first;
- x264_encoder_reconfig(x4->enc, &x4->params);
- }
- if (x4->params.vui.i_sar_height*ctx->sample_aspect_ratio.num != ctx->sample_aspect_ratio.den * x4->params.vui.i_sar_width) {
- x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den;
- x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num;
- x264_encoder_reconfig(x4->enc, &x4->params);
- }
+ x4->params.b_tff = frame->top_field_first;
+ x264_encoder_reconfig(x4->enc, &x4->params);
+ }
+ if (x4->params.vui.i_sar_height*ctx->sample_aspect_ratio.num != ctx->sample_aspect_ratio.den * x4->params.vui.i_sar_width) {
+ x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den;
+ x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num;
+ x264_encoder_reconfig(x4->enc, &x4->params);
+ }
- if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 ||
- x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate / 1000) {
- x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000;
- x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate / 1000;
- x264_encoder_reconfig(x4->enc, &x4->params);
- }
+ if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 ||
+ x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate / 1000) {
+ x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000;
+ x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate / 1000;
+ x264_encoder_reconfig(x4->enc, &x4->params);
+ }
- if (x4->params.rc.i_rc_method == X264_RC_ABR &&
- x4->params.rc.i_bitrate != ctx->bit_rate / 1000) {
- x4->params.rc.i_bitrate = ctx->bit_rate / 1000;
- x264_encoder_reconfig(x4->enc, &x4->params);
- }
+ if (x4->params.rc.i_rc_method == X264_RC_ABR &&
+ x4->params.rc.i_bitrate != ctx->bit_rate / 1000) {
+ x4->params.rc.i_bitrate = ctx->bit_rate / 1000;
+ x264_encoder_reconfig(x4->enc, &x4->params);
+ }
- if (x4->crf >= 0 &&
- x4->params.rc.i_rc_method == X264_RC_CRF &&
- x4->params.rc.f_rf_constant != x4->crf) {
- x4->params.rc.f_rf_constant = x4->crf;
- x264_encoder_reconfig(x4->enc, &x4->params);
- }
+ if (x4->crf >= 0 &&
+ x4->params.rc.i_rc_method == X264_RC_CRF &&
+ x4->params.rc.f_rf_constant != x4->crf) {
+ x4->params.rc.f_rf_constant = x4->crf;
+ x264_encoder_reconfig(x4->enc, &x4->params);
+ }
- if (x4->params.rc.i_rc_method == X264_RC_CQP &&
- x4->cqp >= 0 &&
- x4->params.rc.i_qp_constant != x4->cqp) {
- x4->params.rc.i_qp_constant = x4->cqp;
- x264_encoder_reconfig(x4->enc, &x4->params);
- }
+ if (x4->params.rc.i_rc_method == X264_RC_CQP &&
+ x4->cqp >= 0 &&
+ x4->params.rc.i_qp_constant != x4->cqp) {
+ x4->params.rc.i_qp_constant = x4->cqp;
+ x264_encoder_reconfig(x4->enc, &x4->params);
+ }
- if (x4->crf_max >= 0 &&
- x4->params.rc.f_rf_constant_max != x4->crf_max) {
- x4->params.rc.f_rf_constant_max = x4->crf_max;
- x264_encoder_reconfig(x4->enc, &x4->params);
+ if (x4->crf_max >= 0 &&
+ x4->params.rc.f_rf_constant_max != x4->crf_max) {
+ x4->params.rc.f_rf_constant_max = x4->crf_max;
+ x264_encoder_reconfig(x4->enc, &x4->params);
+ }
}
- }
side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_STEREO3D);
if (side_data) {
x264_picture_t pic_out = {0};
int pict_type;
int bit_depth;
- int64_t *out_opaque;
+ int64_t wallclock = 0;
+ X264Opaque *out_opaque;
AVFrameSideData *sd;
x264_picture_init( &x4->pic );
x4->pic.i_pts = frame->pts;
- x4->reordered_opaque[x4->next_reordered_opaque] = frame->reordered_opaque;
+ x4->reordered_opaque[x4->next_reordered_opaque].reordered_opaque = frame->reordered_opaque;
+ x4->reordered_opaque[x4->next_reordered_opaque].wallclock = wallclock;
+ if (ctx->export_side_data & AV_CODEC_EXPORT_DATA_PRFT)
+ x4->reordered_opaque[x4->next_reordered_opaque].wallclock = av_gettime();
x4->pic.opaque = &x4->reordered_opaque[x4->next_reordered_opaque];
x4->next_reordered_opaque++;
x4->next_reordered_opaque %= x4->nb_reordered_opaque;
sd = av_frame_get_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST);
if (sd) {
if (x4->params.rc.i_aq_mode == X264_AQ_NONE) {
- av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
+ if (!x4->roi_warned) {
+ x4->roi_warned = 1;
+ av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
+ }
} else {
if (frame->interlaced_frame == 0) {
int mbx = (frame->width + MB_SIZE - 1) / MB_SIZE;
x4->pic.prop.quant_offsets = qoffsets;
x4->pic.prop.quant_offsets_free = av_free;
} else {
- av_log(ctx, AV_LOG_WARNING, "interlaced_frame not supported for ROI encoding yet, skipping ROI.\n");
+ if (!x4->roi_warned) {
+ x4->roi_warned = 1;
+ av_log(ctx, AV_LOG_WARNING, "interlaced_frame not supported for ROI encoding yet, skipping ROI.\n");
+ }
}
}
}
return ret;
} while (!ret && !frame && x264_encoder_delayed_frames(x4->enc));
+ if (!ret)
+ return 0;
+
pkt->pts = pic_out.i_pts;
pkt->dts = pic_out.i_dts;
out_opaque = pic_out.opaque;
if (out_opaque >= x4->reordered_opaque &&
out_opaque < &x4->reordered_opaque[x4->nb_reordered_opaque]) {
- ctx->reordered_opaque = *out_opaque;
+ ctx->reordered_opaque = out_opaque->reordered_opaque;
+ wallclock = out_opaque->wallclock;
} else {
// Unexpected opaque pointer on picture output
ctx->reordered_opaque = 0;
pict_type = AV_PICTURE_TYPE_B;
break;
default:
- pict_type = AV_PICTURE_TYPE_NONE;
+ av_log(ctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
+ return AVERROR_EXTERNAL;
}
-#if FF_API_CODED_FRAME
-FF_DISABLE_DEPRECATION_WARNINGS
- ctx->coded_frame->pict_type = pict_type;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe;
if (ret) {
ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA, NULL, 0, pict_type);
-
-#if FF_API_CODED_FRAME
-FF_DISABLE_DEPRECATION_WARNINGS
- ctx->coded_frame->quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
+ if (wallclock)
+ ff_side_data_set_prft(pkt, wallclock);
}
*got_packet = ret;
av_freep(&x4->sei);
av_freep(&x4->reordered_opaque);
+#if X264_BUILD >= 161
+ x264_param_cleanup(&x4->params);
+#endif
+
if (x4->enc) {
x264_encoder_close(x4->enc);
x4->enc = NULL;
return 0;
}
-#define OPT_STR(opt, param) \
- do { \
- int ret; \
- if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) { \
- if(ret == X264_PARAM_BAD_NAME) \
- av_log(avctx, AV_LOG_ERROR, \
- "bad option '%s': '%s'\n", opt, param); \
- else \
- av_log(avctx, AV_LOG_ERROR, \
- "bad value for '%s': '%s'\n", opt, param); \
- return -1; \
- } \
- } while (0)
+static int parse_opts(AVCodecContext *avctx, const char *opt, const char *param)
+{
+ X264Context *x4 = avctx->priv_data;
+ int ret;
+
+ if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) {
+ if (ret == X264_PARAM_BAD_NAME) {
+ av_log(avctx, AV_LOG_ERROR,
+ "bad option '%s': '%s'\n", opt, param);
+ ret = AVERROR(EINVAL);
+#if X264_BUILD >= 161
+ } else if (ret == X264_PARAM_ALLOC_FAILED) {
+ av_log(avctx, AV_LOG_ERROR,
+ "out of memory parsing option '%s': '%s'\n", opt, param);
+ ret = AVERROR(ENOMEM);
+#endif
+ } else {
+ av_log(avctx, AV_LOG_ERROR,
+ "bad value for '%s': '%s'\n", opt, param);
+ ret = AVERROR(EINVAL);
+ }
+ }
+
+ return ret;
+}
static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
{
X264Context *x4 = avctx->priv_data;
AVCPBProperties *cpb_props;
int sw,sh;
+ int ret;
if (avctx->global_quality > 0)
av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n");
if (avctx->b_quant_factor > 0)
x4->params.rc.f_pb_factor = avctx->b_quant_factor;
-#if FF_API_PRIVATE_OPT
-FF_DISABLE_DEPRECATION_WARNINGS
- if (avctx->chromaoffset >= 0)
- x4->chroma_offset = avctx->chromaoffset;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
- if (x4->chroma_offset >= 0)
+ if (x4->chroma_offset)
x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;
if (avctx->gop_size >= 0)
if (avctx->max_b_frames >= 0)
x4->params.i_bframe = avctx->max_b_frames;
-#if FF_API_PRIVATE_OPT
-FF_DISABLE_DEPRECATION_WARNINGS
- if (avctx->scenechange_threshold >= 0)
- x4->scenechange_threshold = avctx->scenechange_threshold;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
if (x4->scenechange_threshold >= 0)
x4->params.i_scenecut_threshold = x4->scenechange_threshold;
x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
if (avctx->refs >= 0)
x4->params.i_frame_reference = avctx->refs;
- else if (x4->level) {
+ else if (x4->params.i_level_idc > 0) {
int i;
int mbn = AV_CEIL_RSHIFT(avctx->width, 4) * AV_CEIL_RSHIFT(avctx->height, 4);
- int level_id = -1;
- char *tail;
int scale = X264_BUILD < 129 ? 384 : 1;
- if (!strcmp(x4->level, "1b")) {
- level_id = 9;
- } else if (strlen(x4->level) <= 3){
- level_id = av_strtod(x4->level, &tail) * 10 + 0.5;
- if (*tail)
- level_id = -1;
- }
- if (level_id <= 0)
- av_log(avctx, AV_LOG_WARNING, "Failed to parse level\n");
-
for (i = 0; i<x264_levels[i].level_idc; i++)
- if (x264_levels[i].level_idc == level_id)
+ if (x264_levels[i].level_idc == x4->params.i_level_idc)
x4->params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->params.i_frame_reference);
}
x4->params.analyse.i_trellis = avctx->trellis;
if (avctx->me_range >= 0)
x4->params.analyse.i_me_range = avctx->me_range;
-#if FF_API_PRIVATE_OPT
- FF_DISABLE_DEPRECATION_WARNINGS
- if (avctx->noise_reduction >= 0)
- x4->noise_reduction = avctx->noise_reduction;
- FF_ENABLE_DEPRECATION_WARNINGS
-#endif
if (x4->noise_reduction >= 0)
x4->params.analyse.i_noise_reduction = x4->noise_reduction;
if (avctx->me_subpel_quality >= 0)
x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
-#if FF_API_PRIVATE_OPT
-FF_DISABLE_DEPRECATION_WARNINGS
- if (avctx->b_frame_strategy >= 0)
- x4->b_frame_strategy = avctx->b_frame_strategy;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
if (avctx->keyint_min >= 0)
x4->params.i_keyint_min = avctx->keyint_min;
-#if FF_API_CODER_TYPE
-FF_DISABLE_DEPRECATION_WARNINGS
- if (avctx->coder_type >= 0)
- x4->coder = avctx->coder_type == FF_CODER_TYPE_AC;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
if (avctx->me_cmp >= 0)
x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
while(p){
char param[4096]={0}, val[4096]={0};
if(sscanf(p, "%4095[^:=]=%4095[^:]", param, val) == 1){
- OPT_STR(param, "1");
- }else
- OPT_STR(param, val);
+ ret = parse_opts(avctx, param, "1");
+ if (ret < 0)
+ return ret;
+ } else {
+ ret = parse_opts(avctx, param, val);
+ if (ret < 0)
+ return ret;
+ }
p= strchr(p, ':');
p+=!!p;
}
}
- if (x4->x264_params) {
- AVDictionary *dict = NULL;
- AVDictionaryEntry *en = NULL;
-
- if (!av_dict_parse_string(&dict, x4->x264_params, "=", ":", 0)) {
- while ((en = av_dict_get(dict, "", en, AV_DICT_IGNORE_SUFFIX))) {
- if (x264_param_parse(&x4->params, en->key, en->value) < 0)
- av_log(avctx, AV_LOG_WARNING,
- "Error parsing option '%s = %s'.\n",
- en->key, en->value);
- }
- av_dict_free(&dict);
+ {
+ AVDictionaryEntry *en = NULL;
+ while (en = av_dict_get(x4->x264_params, "", en, AV_DICT_IGNORE_SUFFIX)) {
+ if ((ret = x264_param_parse(&x4->params, en->key, en->value)) < 0) {
+ av_log(avctx, AV_LOG_WARNING,
+ "Error parsing option '%s = %s'.\n",
+ en->key, en->value);
+#if X264_BUILD >= 161
+ if (ret == X264_PARAM_ALLOC_FAILED)
+ return AVERROR(ENOMEM);
+#endif
+ }
}
}
};
#endif
+#if X264_BUILD < 153
static av_cold void X264_init_static(AVCodec *codec)
{
-#if X264_BUILD < 153
if (x264_bit_depth == 8)
codec->pix_fmts = pix_fmts_8bit;
else if (x264_bit_depth == 9)
codec->pix_fmts = pix_fmts_9bit;
else if (x264_bit_depth == 10)
codec->pix_fmts = pix_fmts_10bit;
-#else
- codec->pix_fmts = pix_fmts_all;
-#endif
}
+#endif
#define OFFSET(x) offsetof(X264Context, x)
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
{ "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
{ "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
{ "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
- { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
+ { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, VE },
{ "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
{ "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
- { "x264-params", "Override the x264 configuration using a :-separated list of key=value parameters", OFFSET(x264_params), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
+ { "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 },
{ NULL },
};
{ "qcomp", "-1" },
// { "rc_lookahead", "-1" },
{ "refs", "-1" },
-#if FF_API_PRIVATE_OPT
- { "sc_threshold", "-1" },
-#endif
{ "trellis", "-1" },
-#if FF_API_PRIVATE_OPT
- { "nr", "-1" },
-#endif
{ "me_range", "-1" },
{ "subq", "-1" },
-#if FF_API_PRIVATE_OPT
- { "b_strategy", "-1" },
-#endif
{ "keyint_min", "-1" },
-#if FF_API_CODER_TYPE
- { "coder", "-1" },
-#endif
{ "cmp", "-1" },
{ "threads", AV_STRINGIFY(X264_THREADS_AUTO) },
{ "thread_type", "0" },
.version = LIBAVUTIL_VERSION_INT,
};
+#if X264_BUILD >= 153
+const
+#endif
AVCodec ff_libx264_encoder = {
.name = "libx264",
.long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
.init = X264_init,
.encode2 = X264_frame,
.close = X264_close,
- .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
+ .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS |
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
+ .caps_internal = FF_CODEC_CAP_AUTO_THREADS,
.priv_class = &x264_class,
.defaults = x264_defaults,
+#if X264_BUILD < 153
.init_static_data = X264_init_static,
- .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
+#else
+ .pix_fmts = pix_fmts_all,
+#endif
+ .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS
+#if X264_BUILD >= 158
+ | FF_CODEC_CAP_INIT_THREADSAFE
+#endif
+ ,
.wrapper_name = "libx264",
};
#endif
.version = LIBAVUTIL_VERSION_INT,
};
-AVCodec ff_libx264rgb_encoder = {
+const AVCodec ff_libx264rgb_encoder = {
.name = "libx264rgb",
.long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
.type = AVMEDIA_TYPE_VIDEO,
.init = X264_init,
.encode2 = X264_frame,
.close = X264_close,
- .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
+ .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS |
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
.priv_class = &rgbclass,
.defaults = x264_defaults,
.pix_fmts = pix_fmts_8bit_rgb,
+ .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS
+#if X264_BUILD >= 158
+ | FF_CODEC_CAP_INIT_THREADSAFE
+#endif
+ ,
.wrapper_name = "libx264",
};
#endif
.version = LIBAVUTIL_VERSION_INT,
};
-AVCodec ff_libx262_encoder = {
+const AVCodec ff_libx262_encoder = {
.name = "libx262",
.long_name = NULL_IF_CONFIG_SMALL("libx262 MPEG2VIDEO"),
.type = AVMEDIA_TYPE_VIDEO,
.init = X264_init,
.encode2 = X264_frame,
.close = X264_close,
- .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
+ .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS |
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
.priv_class = &X262_class,
.defaults = x264_defaults,
.pix_fmts = pix_fmts_8bit,
- .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
+ .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS,
.wrapper_name = "libx264",
};
#endif