4 * Copyright (c) 2013-2014 Derek Buitenhuis
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #define X265_API_IMPORTS 1
30 #include "libavutil/avassert.h"
31 #include "libavutil/buffer.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/common.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixdesc.h"
37 #include "codec_internal.h"
40 #include "packet_internal.h"
44 typedef struct ReorderedData {
45 #if FF_API_REORDERED_OPAQUE
46 int64_t reordered_opaque;
51 AVBufferRef *frame_opaque_ref;
56 typedef struct libx265Context {
59 x265_encoder *encoder;
69 AVDictionary *x265_opts;
80 * If the encoder does not support ROI then warn the first time we
81 * encounter a frame with ROI side data.
86 static int is_keyframe(NalUnitType naltype)
89 case NAL_UNIT_CODED_SLICE_BLA_W_LP:
90 case NAL_UNIT_CODED_SLICE_BLA_W_RADL:
91 case NAL_UNIT_CODED_SLICE_BLA_N_LP:
92 case NAL_UNIT_CODED_SLICE_IDR_W_RADL:
93 case NAL_UNIT_CODED_SLICE_IDR_N_LP:
94 case NAL_UNIT_CODED_SLICE_CRA:
101 static int rd_get(libx265Context *ctx)
108 for (int i = 0; i < ctx->nb_rd; i++)
109 if (!ctx->rd[i].in_use) {
110 ctx->rd[i].in_use = 1;
114 tmp = av_realloc_array(ctx->rd, ctx->nb_rd + add, sizeof(*ctx->rd));
116 return AVERROR(ENOMEM);
117 memset(tmp + ctx->nb_rd, 0, sizeof(*tmp) * add);
122 idx = ctx->nb_rd - add;
123 ctx->rd[idx].in_use = 1;
128 static void rd_release(libx265Context *ctx, int idx)
130 av_assert0(idx >= 0 && idx < ctx->nb_rd);
131 av_buffer_unref(&ctx->rd[idx].frame_opaque_ref);
132 memset(&ctx->rd[idx], 0, sizeof(ctx->rd[idx]));
135 static av_cold int libx265_encode_close(AVCodecContext *avctx)
137 libx265Context *ctx = avctx->priv_data;
139 ctx->api->param_free(ctx->params);
140 av_freep(&ctx->sei_data);
142 for (int i = 0; i < ctx->nb_rd; i++)
147 ctx->api->encoder_close(ctx->encoder);
152 static av_cold int libx265_param_parse_float(AVCodecContext *avctx,
153 const char *key, float value)
155 libx265Context *ctx = avctx->priv_data;
158 snprintf(buf, sizeof(buf), "%2.2f", value);
159 if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
160 av_log(avctx, AV_LOG_ERROR, "Invalid value %2.2f for param \"%s\".\n", value, key);
161 return AVERROR(EINVAL);
167 static av_cold int libx265_param_parse_int(AVCodecContext *avctx,
168 const char *key, int value)
170 libx265Context *ctx = avctx->priv_data;
173 snprintf(buf, sizeof(buf), "%d", value);
174 if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
175 av_log(avctx, AV_LOG_ERROR, "Invalid value %d for param \"%s\".\n", value, key);
176 return AVERROR(EINVAL);
182 static av_cold int libx265_encode_init(AVCodecContext *avctx)
184 libx265Context *ctx = avctx->priv_data;
185 AVCPBProperties *cpb_props = NULL;
186 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
189 ctx->api = x265_api_get(desc->comp[0].depth);
191 ctx->api = x265_api_get(0);
193 ctx->params = ctx->api->param_alloc();
195 av_log(avctx, AV_LOG_ERROR, "Could not allocate x265 param structure.\n");
196 return AVERROR(ENOMEM);
199 if (ctx->api->param_default_preset(ctx->params, ctx->preset, ctx->tune) < 0) {
202 av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", ctx->preset, ctx->tune);
203 av_log(avctx, AV_LOG_INFO, "Possible presets:");
204 for (i = 0; x265_preset_names[i]; i++)
205 av_log(avctx, AV_LOG_INFO, " %s", x265_preset_names[i]);
207 av_log(avctx, AV_LOG_INFO, "\n");
208 av_log(avctx, AV_LOG_INFO, "Possible tunes:");
209 for (i = 0; x265_tune_names[i]; i++)
210 av_log(avctx, AV_LOG_INFO, " %s", x265_tune_names[i]);
212 av_log(avctx, AV_LOG_INFO, "\n");
214 return AVERROR(EINVAL);
217 ctx->params->frameNumThreads = avctx->thread_count;
218 if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
219 ctx->params->fpsNum = avctx->framerate.num;
220 ctx->params->fpsDenom = avctx->framerate.den;
222 ctx->params->fpsNum = avctx->time_base.den;
223 FF_DISABLE_DEPRECATION_WARNINGS
224 ctx->params->fpsDenom = avctx->time_base.num
225 #if FF_API_TICKS_PER_FRAME
226 * avctx->ticks_per_frame
229 FF_ENABLE_DEPRECATION_WARNINGS
231 ctx->params->sourceWidth = avctx->width;
232 ctx->params->sourceHeight = avctx->height;
233 ctx->params->bEnablePsnr = !!(avctx->flags & AV_CODEC_FLAG_PSNR);
234 ctx->params->bOpenGOP = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
236 /* Tune the CTU size based on input resolution. */
237 if (ctx->params->sourceWidth < 64 || ctx->params->sourceHeight < 64)
238 ctx->params->maxCUSize = 32;
239 if (ctx->params->sourceWidth < 32 || ctx->params->sourceHeight < 32)
240 ctx->params->maxCUSize = 16;
241 if (ctx->params->sourceWidth < 16 || ctx->params->sourceHeight < 16) {
242 av_log(avctx, AV_LOG_ERROR, "Image size is too small (%dx%d).\n",
243 ctx->params->sourceWidth, ctx->params->sourceHeight);
244 return AVERROR(EINVAL);
248 ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
250 if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED)
251 ctx->params->vui.bEnableVideoFullRangeFlag =
252 avctx->color_range == AVCOL_RANGE_JPEG;
254 ctx->params->vui.bEnableVideoFullRangeFlag =
255 (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
256 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
257 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
258 avctx->pix_fmt == AV_PIX_FMT_YUVJ444P;
260 if ((avctx->color_primaries <= AVCOL_PRI_SMPTE432 &&
261 avctx->color_primaries != AVCOL_PRI_UNSPECIFIED) ||
262 (avctx->color_trc <= AVCOL_TRC_ARIB_STD_B67 &&
263 avctx->color_trc != AVCOL_TRC_UNSPECIFIED) ||
264 (avctx->colorspace <= AVCOL_SPC_ICTCP &&
265 avctx->colorspace != AVCOL_SPC_UNSPECIFIED)) {
267 ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
269 // x265 validates the parameters internally
270 ctx->params->vui.colorPrimaries = avctx->color_primaries;
271 ctx->params->vui.transferCharacteristics = avctx->color_trc;
272 #if X265_BUILD >= 159
273 if (avctx->color_trc == AVCOL_TRC_ARIB_STD_B67)
274 ctx->params->preferredTransferCharacteristics = ctx->params->vui.transferCharacteristics;
276 ctx->params->vui.matrixCoeffs = avctx->colorspace;
279 // chroma sample location values are to be ignored in case of non-4:2:0
280 // according to the specification, so we only write them out in case of
281 // 4:2:0 (log2_chroma_{w,h} == 1).
282 ctx->params->vui.bEnableChromaLocInfoPresentFlag =
283 avctx->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED &&
284 desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1;
286 if (ctx->params->vui.bEnableChromaLocInfoPresentFlag) {
287 ctx->params->vui.chromaSampleLocTypeTopField =
288 ctx->params->vui.chromaSampleLocTypeBottomField =
289 avctx->chroma_sample_location - 1;
292 if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
294 int sar_num, sar_den;
296 av_reduce(&sar_num, &sar_den,
297 avctx->sample_aspect_ratio.num,
298 avctx->sample_aspect_ratio.den, 65535);
299 snprintf(sar, sizeof(sar), "%d:%d", sar_num, sar_den);
300 if (ctx->api->param_parse(ctx->params, "sar", sar) == X265_PARAM_BAD_VALUE) {
301 av_log(avctx, AV_LOG_ERROR, "Invalid SAR: %d:%d.\n", sar_num, sar_den);
302 return AVERROR_INVALIDDATA;
306 switch (desc->log2_chroma_w) {
310 if (desc->nb_components == 1) {
311 if (ctx->api->api_build_number < 85) {
312 av_log(avctx, AV_LOG_ERROR,
313 "libx265 version is %d, must be at least 85 for gray encoding.\n",
314 ctx->api->api_build_number);
315 return AVERROR_INVALIDDATA;
317 ctx->params->internalCsp = X265_CSP_I400;
321 // set identity matrix for RGB
322 if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
323 ctx->params->vui.matrixCoeffs = AVCOL_SPC_RGB;
324 ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
325 ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
328 ctx->params->internalCsp = X265_CSP_I444;
332 ctx->params->internalCsp = desc->log2_chroma_h == 1 ?
333 X265_CSP_I420 : X265_CSP_I422;
336 av_log(avctx, AV_LOG_ERROR,
337 "Pixel format '%s' cannot be mapped to a libx265 CSP!\n",
345 snprintf(crf, sizeof(crf), "%2.2f", ctx->crf);
346 if (ctx->api->param_parse(ctx->params, "crf", crf) == X265_PARAM_BAD_VALUE) {
347 av_log(avctx, AV_LOG_ERROR, "Invalid crf: %2.2f.\n", ctx->crf);
348 return AVERROR(EINVAL);
350 } else if (avctx->bit_rate > 0) {
351 ctx->params->rc.bitrate = avctx->bit_rate / 1000;
352 ctx->params->rc.rateControlMode = X265_RC_ABR;
353 } else if (ctx->cqp >= 0) {
354 ret = libx265_param_parse_int(avctx, "qp", ctx->cqp);
359 if (avctx->qmin >= 0) {
360 ret = libx265_param_parse_int(avctx, "qpmin", avctx->qmin);
364 if (avctx->qmax >= 0) {
365 ret = libx265_param_parse_int(avctx, "qpmax", avctx->qmax);
369 if (avctx->max_qdiff >= 0) {
370 ret = libx265_param_parse_int(avctx, "qpstep", avctx->max_qdiff);
374 if (avctx->qblur >= 0) {
375 ret = libx265_param_parse_float(avctx, "qblur", avctx->qblur);
379 if (avctx->qcompress >= 0) {
380 ret = libx265_param_parse_float(avctx, "qcomp", avctx->qcompress);
384 if (avctx->i_quant_factor >= 0) {
385 ret = libx265_param_parse_float(avctx, "ipratio", avctx->i_quant_factor);
389 if (avctx->b_quant_factor >= 0) {
390 ret = libx265_param_parse_float(avctx, "pbratio", avctx->b_quant_factor);
395 ctx->params->rc.vbvBufferSize = avctx->rc_buffer_size / 1000;
396 ctx->params->rc.vbvMaxBitrate = avctx->rc_max_rate / 1000;
398 cpb_props = ff_encode_add_cpb_side_data(avctx);
400 return AVERROR(ENOMEM);
401 cpb_props->buffer_size = ctx->params->rc.vbvBufferSize * 1000;
402 cpb_props->max_bitrate = ctx->params->rc.vbvMaxBitrate * 1000LL;
403 cpb_props->avg_bitrate = ctx->params->rc.bitrate * 1000LL;
405 if (!(avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER))
406 ctx->params->bRepeatHeaders = 1;
408 if (avctx->gop_size >= 0) {
409 ret = libx265_param_parse_int(avctx, "keyint", avctx->gop_size);
413 if (avctx->keyint_min > 0) {
414 ret = libx265_param_parse_int(avctx, "min-keyint", avctx->keyint_min);
418 if (avctx->max_b_frames >= 0) {
419 ret = libx265_param_parse_int(avctx, "bframes", avctx->max_b_frames);
423 if (avctx->refs >= 0) {
424 ret = libx265_param_parse_int(avctx, "ref", avctx->refs);
430 AVDictionaryEntry *en = NULL;
431 while ((en = av_dict_get(ctx->x265_opts, "", en, AV_DICT_IGNORE_SUFFIX))) {
432 int parse_ret = ctx->api->param_parse(ctx->params, en->key, en->value);
435 case X265_PARAM_BAD_NAME:
436 av_log(avctx, AV_LOG_WARNING,
437 "Unknown option: %s.\n", en->key);
439 case X265_PARAM_BAD_VALUE:
440 av_log(avctx, AV_LOG_WARNING,
441 "Invalid value for %s: %s.\n", en->key, en->value);
449 if (ctx->params->rc.vbvBufferSize && avctx->rc_initial_buffer_occupancy > 1000 &&
450 ctx->params->rc.vbvBufferInit == 0.9) {
451 ctx->params->rc.vbvBufferInit = (float)avctx->rc_initial_buffer_occupancy / 1000;
455 if (ctx->api->param_apply_profile(ctx->params, ctx->profile) < 0) {
457 av_log(avctx, AV_LOG_ERROR, "Invalid or incompatible profile set: %s.\n", ctx->profile);
458 av_log(avctx, AV_LOG_INFO, "Possible profiles:");
459 for (i = 0; x265_profile_names[i]; i++)
460 av_log(avctx, AV_LOG_INFO, " %s", x265_profile_names[i]);
461 av_log(avctx, AV_LOG_INFO, "\n");
462 return AVERROR(EINVAL);
466 ctx->encoder = ctx->api->encoder_open(ctx->params);
468 av_log(avctx, AV_LOG_ERROR, "Cannot open libx265 encoder.\n");
469 libx265_encode_close(avctx);
470 return AVERROR_INVALIDDATA;
473 if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
477 avctx->extradata_size = ctx->api->encoder_headers(ctx->encoder, &nal, &nnal);
478 if (avctx->extradata_size <= 0) {
479 av_log(avctx, AV_LOG_ERROR, "Cannot encode headers.\n");
480 libx265_encode_close(avctx);
481 return AVERROR_INVALIDDATA;
484 avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
485 if (!avctx->extradata) {
486 av_log(avctx, AV_LOG_ERROR,
487 "Cannot allocate HEVC header of size %d.\n", avctx->extradata_size);
488 libx265_encode_close(avctx);
489 return AVERROR(ENOMEM);
492 memcpy(avctx->extradata, nal[0].payload, avctx->extradata_size);
493 memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
499 static av_cold int libx265_encode_set_roi(libx265Context *ctx, const AVFrame *frame, x265_picture* pic)
501 AVFrameSideData *sd = av_frame_get_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST);
503 if (ctx->params->rc.aqMode == X265_AQ_NONE) {
504 if (!ctx->roi_warned) {
506 av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
509 /* 8x8 block when qg-size is 8, 16*16 block otherwise. */
510 int mb_size = (ctx->params->rc.qgSize == 8) ? 8 : 16;
511 int mbx = (frame->width + mb_size - 1) / mb_size;
512 int mby = (frame->height + mb_size - 1) / mb_size;
513 int qp_range = 51 + 6 * (pic->bitDepth - 8);
515 const AVRegionOfInterest *roi;
517 float *qoffsets; /* will be freed after encode is called. */
519 roi = (const AVRegionOfInterest*)sd->data;
520 roi_size = roi->self_size;
521 if (!roi_size || sd->size % roi_size != 0) {
522 av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
523 return AVERROR(EINVAL);
525 nb_rois = sd->size / roi_size;
527 qoffsets = av_calloc(mbx * mby, sizeof(*qoffsets));
529 return AVERROR(ENOMEM);
531 // This list must be iterated in reverse because the first
532 // region in the list applies when regions overlap.
533 for (int i = nb_rois - 1; i >= 0; i--) {
534 int startx, endx, starty, endy;
537 roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
539 starty = FFMIN(mby, roi->top / mb_size);
540 endy = FFMIN(mby, (roi->bottom + mb_size - 1)/ mb_size);
541 startx = FFMIN(mbx, roi->left / mb_size);
542 endx = FFMIN(mbx, (roi->right + mb_size - 1)/ mb_size);
544 if (roi->qoffset.den == 0) {
546 av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
547 return AVERROR(EINVAL);
549 qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
550 qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
552 for (int y = starty; y < endy; y++)
553 for (int x = startx; x < endx; x++)
554 qoffsets[x + y*mbx] = qoffset;
557 pic->quantOffsets = qoffsets;
563 static void free_picture(libx265Context *ctx, x265_picture *pic)
565 x265_sei *sei = &pic->userSEI;
566 for (int i = 0; i < sei->numPayloads; i++)
567 av_free(sei->payloads[i].payload);
570 int idx = (int)(intptr_t)pic->userData - 1;
571 rd_release(ctx, idx);
572 pic->userData = NULL;
575 av_freep(&pic->quantOffsets);
576 sei->numPayloads = 0;
579 static int libx265_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
580 const AVFrame *pic, int *got_packet)
582 libx265Context *ctx = avctx->priv_data;
583 x265_picture x265pic;
584 x265_picture x265pic_out = { 0 };
594 ctx->api->picture_init(ctx->params, &x265pic);
596 sei = &x265pic.userSEI;
597 sei->numPayloads = 0;
603 for (i = 0; i < 3; i++) {
604 x265pic.planes[i] = pic->data[i];
605 x265pic.stride[i] = pic->linesize[i];
608 x265pic.pts = pic->pts;
609 x265pic.bitDepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
611 x265pic.sliceType = pic->pict_type == AV_PICTURE_TYPE_I ?
612 (ctx->forced_idr ? X265_TYPE_IDR : X265_TYPE_I) :
613 pic->pict_type == AV_PICTURE_TYPE_P ? X265_TYPE_P :
614 pic->pict_type == AV_PICTURE_TYPE_B ? X265_TYPE_B :
617 ret = libx265_encode_set_roi(ctx, pic, &x265pic);
621 rd_idx = rd_get(ctx);
623 free_picture(ctx, &x265pic);
626 rd = &ctx->rd[rd_idx];
628 rd->duration = pic->duration;
629 #if FF_API_REORDERED_OPAQUE
630 FF_DISABLE_DEPRECATION_WARNINGS
631 rd->reordered_opaque = pic->reordered_opaque;
632 FF_ENABLE_DEPRECATION_WARNINGS
634 if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
635 rd->frame_opaque = pic->opaque;
636 ret = av_buffer_replace(&rd->frame_opaque_ref, pic->opaque_ref);
638 rd_release(ctx, rd_idx);
639 free_picture(ctx, &x265pic);
644 x265pic.userData = (void*)(intptr_t)(rd_idx + 1);
650 ret = ff_alloc_a53_sei(pic, 0, &sei_data, &sei_size);
652 av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
653 } else if (sei_data) {
655 x265_sei_payload *sei_payload;
657 tmp = av_fast_realloc(ctx->sei_data,
659 (sei->numPayloads + 1) * sizeof(*sei_payload));
662 free_picture(ctx, &x265pic);
663 return AVERROR(ENOMEM);
666 sei->payloads = ctx->sei_data;
667 sei_payload = &sei->payloads[sei->numPayloads];
668 sei_payload->payload = sei_data;
669 sei_payload->payloadSize = sei_size;
670 sei_payload->payloadType = SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35;
676 for (i = 0; i < pic->nb_side_data; i++) {
677 AVFrameSideData *side_data = pic->side_data[i];
679 x265_sei_payload *sei_payload;
681 if (side_data->type != AV_FRAME_DATA_SEI_UNREGISTERED)
684 tmp = av_fast_realloc(ctx->sei_data,
686 (sei->numPayloads + 1) * sizeof(*sei_payload));
688 free_picture(ctx, &x265pic);
689 return AVERROR(ENOMEM);
692 sei->payloads = ctx->sei_data;
693 sei_payload = &sei->payloads[sei->numPayloads];
694 sei_payload->payload = av_memdup(side_data->data, side_data->size);
695 if (!sei_payload->payload) {
696 free_picture(ctx, &x265pic);
697 return AVERROR(ENOMEM);
699 sei_payload->payloadSize = side_data->size;
700 /* Equal to libx265 USER_DATA_UNREGISTERED */
701 sei_payload->payloadType = SEI_TYPE_USER_DATA_UNREGISTERED;
707 ret = ctx->api->encoder_encode(ctx->encoder, &nal, &nnal,
708 pic ? &x265pic : NULL, &x265pic_out);
710 for (i = 0; i < sei->numPayloads; i++)
711 av_free(sei->payloads[i].payload);
712 av_freep(&x265pic.quantOffsets);
715 return AVERROR_EXTERNAL;
720 for (i = 0; i < nnal; i++)
721 payload += nal[i].sizeBytes;
723 ret = ff_get_encode_buffer(avctx, pkt, payload, 0);
725 av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
730 for (i = 0; i < nnal; i++) {
731 memcpy(dst, nal[i].payload, nal[i].sizeBytes);
732 dst += nal[i].sizeBytes;
734 if (is_keyframe(nal[i].type))
735 pkt->flags |= AV_PKT_FLAG_KEY;
738 pkt->pts = x265pic_out.pts;
739 pkt->dts = x265pic_out.dts;
741 switch (x265pic_out.sliceType) {
744 pict_type = AV_PICTURE_TYPE_I;
747 pict_type = AV_PICTURE_TYPE_P;
751 pict_type = AV_PICTURE_TYPE_B;
754 av_log(avctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
755 return AVERROR_EXTERNAL;
758 #if X265_BUILD >= 130
759 if (x265pic_out.sliceType == X265_TYPE_B)
761 if (x265pic_out.frameData.sliceType == 'b')
763 pkt->flags |= AV_PKT_FLAG_DISPOSABLE;
765 ff_side_data_set_encoder_stats(pkt, x265pic_out.frameData.qp * FF_QP2LAMBDA, NULL, 0, pict_type);
767 if (x265pic_out.userData) {
768 int idx = (int)(intptr_t)x265pic_out.userData - 1;
769 ReorderedData *rd = &ctx->rd[idx];
771 #if FF_API_REORDERED_OPAQUE
772 FF_DISABLE_DEPRECATION_WARNINGS
773 avctx->reordered_opaque = rd->reordered_opaque;
774 FF_ENABLE_DEPRECATION_WARNINGS
776 pkt->duration = rd->duration;
778 if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
779 pkt->opaque = rd->frame_opaque;
780 pkt->opaque_ref = rd->frame_opaque_ref;
781 rd->frame_opaque_ref = NULL;
784 rd_release(ctx, idx);
786 #if FF_API_REORDERED_OPAQUE
788 FF_DISABLE_DEPRECATION_WARNINGS
789 avctx->reordered_opaque = 0;
790 FF_ENABLE_DEPRECATION_WARNINGS
798 static const enum AVPixelFormat x265_csp_eight[] = {
810 static const enum AVPixelFormat x265_csp_ten[] = {
818 AV_PIX_FMT_YUV420P10,
819 AV_PIX_FMT_YUV422P10,
820 AV_PIX_FMT_YUV444P10,
827 static const enum AVPixelFormat x265_csp_twelve[] = {
835 AV_PIX_FMT_YUV420P10,
836 AV_PIX_FMT_YUV422P10,
837 AV_PIX_FMT_YUV444P10,
839 AV_PIX_FMT_YUV420P12,
840 AV_PIX_FMT_YUV422P12,
841 AV_PIX_FMT_YUV444P12,
849 static av_cold void libx265_encode_init_csp(FFCodec *codec)
851 if (x265_api_get(12))
852 codec->p.pix_fmts = x265_csp_twelve;
853 else if (x265_api_get(10))
854 codec->p.pix_fmts = x265_csp_ten;
855 else if (x265_api_get(8))
856 codec->p.pix_fmts = x265_csp_eight;
859 #define OFFSET(x) offsetof(libx265Context, x)
860 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
861 static const AVOption options[] = {
862 { "crf", "set the x265 crf", OFFSET(crf), AV_OPT_TYPE_FLOAT, { .dbl = -1 }, -1, FLT_MAX, VE },
863 { "qp", "set the x265 qp", OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
864 { "forced-idr", "if forcing keyframes, force them as IDR frames", OFFSET(forced_idr),AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
865 { "preset", "set the x265 preset", OFFSET(preset), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
866 { "tune", "set the x265 tune parameter", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
867 { "profile", "set the x265 profile", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
868 { "udu_sei", "Use user data unregistered SEI if available", OFFSET(udu_sei), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
869 { "a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
870 { "x265-params", "set the x265 configuration using a :-separated list of key=value parameters", OFFSET(x265_opts), AV_OPT_TYPE_DICT, { 0 }, 0, 0, VE },
874 static const AVClass class = {
875 .class_name = "libx265",
876 .item_name = av_default_item_name,
878 .version = LIBAVUTIL_VERSION_INT,
881 static const FFCodecDefault x265_defaults[] = {
885 { "keyint_min", "-1" },
892 { "i_qfactor", "-1" },
893 { "b_qfactor", "-1" },
897 FFCodec ff_libx265_encoder = {
899 CODEC_LONG_NAME("libx265 H.265 / HEVC"),
900 .p.type = AVMEDIA_TYPE_VIDEO,
901 .p.id = AV_CODEC_ID_HEVC,
902 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
903 AV_CODEC_CAP_OTHER_THREADS |
904 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
905 .p.priv_class = &class,
906 .p.wrapper_name = "libx265",
907 .init = libx265_encode_init,
908 .init_static_data = libx265_encode_init_csp,
909 FF_CODEC_ENCODE_CB(libx265_encode_frame),
910 .close = libx265_encode_close,
911 .priv_data_size = sizeof(libx265Context),
912 .defaults = x265_defaults,
913 .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
914 FF_CODEC_CAP_AUTO_THREADS,