1 /*
2 * libx265 encoder
3 *
4 * Copyright (c) 2013-2014 Derek Buitenhuis
5 *
6 * This file is part of FFmpeg.
7 *
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.
12 *
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.
17 *
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
21 */
22
23 #if defined(_MSC_VER)
24 #define X265_API_IMPORTS 1
25 #endif
26
27 #include <x265.h>
28 #include <float.h>
29
30 #include "libavutil/internal.h"
31 #include "libavutil/common.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "avcodec.h"
35 #include "internal.h"
36 #include "packet_internal.h"
37
38 typedef struct libx265Context {
39 const AVClass *class;
40
41 x265_encoder *encoder;
42 x265_param *params;
43 const x265_api *api;
44
45 float crf;
46 int cqp;
47 int forced_idr;
48 char *preset;
49 char *tune;
50 char *profile;
51 AVDictionary *x265_opts;
52
53 /**
54 * If the encoder does not support ROI then warn the first time we
55 * encounter a frame with ROI side data.
56 */
57 int roi_warned;
58 } libx265Context;
59
is_keyframe(NalUnitType naltype)60 static int is_keyframe(NalUnitType naltype)
61 {
62 switch (naltype) {
63 case NAL_UNIT_CODED_SLICE_BLA_W_LP:
64 case NAL_UNIT_CODED_SLICE_BLA_W_RADL:
65 case NAL_UNIT_CODED_SLICE_BLA_N_LP:
66 case NAL_UNIT_CODED_SLICE_IDR_W_RADL:
67 case NAL_UNIT_CODED_SLICE_IDR_N_LP:
68 case NAL_UNIT_CODED_SLICE_CRA:
69 return 1;
70 default:
71 return 0;
72 }
73 }
74
libx265_encode_close(AVCodecContext * avctx)75 static av_cold int libx265_encode_close(AVCodecContext *avctx)
76 {
77 libx265Context *ctx = avctx->priv_data;
78
79 ctx->api->param_free(ctx->params);
80
81 if (ctx->encoder)
82 ctx->api->encoder_close(ctx->encoder);
83
84 return 0;
85 }
86
libx265_param_parse_float(AVCodecContext * avctx,const char * key,float value)87 static av_cold int libx265_param_parse_float(AVCodecContext *avctx,
88 const char *key, float value)
89 {
90 libx265Context *ctx = avctx->priv_data;
91 char buf[256];
92
93 snprintf(buf, sizeof(buf), "%2.2f", value);
94 if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
95 av_log(avctx, AV_LOG_ERROR, "Invalid value %2.2f for param \"%s\".\n", value, key);
96 return AVERROR(EINVAL);
97 }
98
99 return 0;
100 }
101
libx265_param_parse_int(AVCodecContext * avctx,const char * key,int value)102 static av_cold int libx265_param_parse_int(AVCodecContext *avctx,
103 const char *key, int value)
104 {
105 libx265Context *ctx = avctx->priv_data;
106 char buf[256];
107
108 snprintf(buf, sizeof(buf), "%d", value);
109 if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
110 av_log(avctx, AV_LOG_ERROR, "Invalid value %d for param \"%s\".\n", value, key);
111 return AVERROR(EINVAL);
112 }
113
114 return 0;
115 }
116
libx265_encode_init(AVCodecContext * avctx)117 static av_cold int libx265_encode_init(AVCodecContext *avctx)
118 {
119 libx265Context *ctx = avctx->priv_data;
120 AVCPBProperties *cpb_props = NULL;
121 int ret;
122
123 ctx->api = x265_api_get(av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth);
124 if (!ctx->api)
125 ctx->api = x265_api_get(0);
126
127 ctx->params = ctx->api->param_alloc();
128 if (!ctx->params) {
129 av_log(avctx, AV_LOG_ERROR, "Could not allocate x265 param structure.\n");
130 return AVERROR(ENOMEM);
131 }
132
133 if (ctx->api->param_default_preset(ctx->params, ctx->preset, ctx->tune) < 0) {
134 int i;
135
136 av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", ctx->preset, ctx->tune);
137 av_log(avctx, AV_LOG_INFO, "Possible presets:");
138 for (i = 0; x265_preset_names[i]; i++)
139 av_log(avctx, AV_LOG_INFO, " %s", x265_preset_names[i]);
140
141 av_log(avctx, AV_LOG_INFO, "\n");
142 av_log(avctx, AV_LOG_INFO, "Possible tunes:");
143 for (i = 0; x265_tune_names[i]; i++)
144 av_log(avctx, AV_LOG_INFO, " %s", x265_tune_names[i]);
145
146 av_log(avctx, AV_LOG_INFO, "\n");
147
148 return AVERROR(EINVAL);
149 }
150
151 ctx->params->frameNumThreads = avctx->thread_count;
152 if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
153 ctx->params->fpsNum = avctx->framerate.num;
154 ctx->params->fpsDenom = avctx->framerate.den;
155 } else {
156 ctx->params->fpsNum = avctx->time_base.den;
157 ctx->params->fpsDenom = avctx->time_base.num * avctx->ticks_per_frame;
158 }
159 ctx->params->sourceWidth = avctx->width;
160 ctx->params->sourceHeight = avctx->height;
161 ctx->params->bEnablePsnr = !!(avctx->flags & AV_CODEC_FLAG_PSNR);
162 ctx->params->bOpenGOP = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
163
164 /* Tune the CTU size based on input resolution. */
165 if (ctx->params->sourceWidth < 64 || ctx->params->sourceHeight < 64)
166 ctx->params->maxCUSize = 32;
167 if (ctx->params->sourceWidth < 32 || ctx->params->sourceHeight < 32)
168 ctx->params->maxCUSize = 16;
169 if (ctx->params->sourceWidth < 16 || ctx->params->sourceHeight < 16) {
170 av_log(avctx, AV_LOG_ERROR, "Image size is too small (%dx%d).\n",
171 ctx->params->sourceWidth, ctx->params->sourceHeight);
172 return AVERROR(EINVAL);
173 }
174
175
176 ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
177
178 ctx->params->vui.bEnableVideoFullRangeFlag = avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
179 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
180 avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
181 avctx->color_range == AVCOL_RANGE_JPEG;
182
183 if ((avctx->color_primaries <= AVCOL_PRI_SMPTE432 &&
184 avctx->color_primaries != AVCOL_PRI_UNSPECIFIED) ||
185 (avctx->color_trc <= AVCOL_TRC_ARIB_STD_B67 &&
186 avctx->color_trc != AVCOL_TRC_UNSPECIFIED) ||
187 (avctx->colorspace <= AVCOL_SPC_ICTCP &&
188 avctx->colorspace != AVCOL_SPC_UNSPECIFIED)) {
189
190 ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
191
192 // x265 validates the parameters internally
193 ctx->params->vui.colorPrimaries = avctx->color_primaries;
194 ctx->params->vui.transferCharacteristics = avctx->color_trc;
195 #if X265_BUILD >= 159
196 if (avctx->color_trc == AVCOL_TRC_ARIB_STD_B67)
197 ctx->params->preferredTransferCharacteristics = ctx->params->vui.transferCharacteristics;
198 #endif
199 ctx->params->vui.matrixCoeffs = avctx->colorspace;
200 }
201
202 if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
203 char sar[12];
204 int sar_num, sar_den;
205
206 av_reduce(&sar_num, &sar_den,
207 avctx->sample_aspect_ratio.num,
208 avctx->sample_aspect_ratio.den, 65535);
209 snprintf(sar, sizeof(sar), "%d:%d", sar_num, sar_den);
210 if (ctx->api->param_parse(ctx->params, "sar", sar) == X265_PARAM_BAD_VALUE) {
211 av_log(avctx, AV_LOG_ERROR, "Invalid SAR: %d:%d.\n", sar_num, sar_den);
212 return AVERROR_INVALIDDATA;
213 }
214 }
215
216 switch (avctx->pix_fmt) {
217 case AV_PIX_FMT_YUV420P:
218 case AV_PIX_FMT_YUV420P10:
219 case AV_PIX_FMT_YUV420P12:
220 ctx->params->internalCsp = X265_CSP_I420;
221 break;
222 case AV_PIX_FMT_YUV422P:
223 case AV_PIX_FMT_YUV422P10:
224 case AV_PIX_FMT_YUV422P12:
225 ctx->params->internalCsp = X265_CSP_I422;
226 break;
227 case AV_PIX_FMT_GBRP:
228 case AV_PIX_FMT_GBRP10:
229 case AV_PIX_FMT_GBRP12:
230 ctx->params->vui.matrixCoeffs = AVCOL_SPC_RGB;
231 ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
232 ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
233 case AV_PIX_FMT_YUV444P:
234 case AV_PIX_FMT_YUV444P10:
235 case AV_PIX_FMT_YUV444P12:
236 ctx->params->internalCsp = X265_CSP_I444;
237 break;
238 case AV_PIX_FMT_GRAY8:
239 case AV_PIX_FMT_GRAY10:
240 case AV_PIX_FMT_GRAY12:
241 if (ctx->api->api_build_number < 85) {
242 av_log(avctx, AV_LOG_ERROR,
243 "libx265 version is %d, must be at least 85 for gray encoding.\n",
244 ctx->api->api_build_number);
245 return AVERROR_INVALIDDATA;
246 }
247 ctx->params->internalCsp = X265_CSP_I400;
248 break;
249 }
250
251 if (ctx->crf >= 0) {
252 char crf[6];
253
254 snprintf(crf, sizeof(crf), "%2.2f", ctx->crf);
255 if (ctx->api->param_parse(ctx->params, "crf", crf) == X265_PARAM_BAD_VALUE) {
256 av_log(avctx, AV_LOG_ERROR, "Invalid crf: %2.2f.\n", ctx->crf);
257 return AVERROR(EINVAL);
258 }
259 } else if (avctx->bit_rate > 0) {
260 ctx->params->rc.bitrate = avctx->bit_rate / 1000;
261 ctx->params->rc.rateControlMode = X265_RC_ABR;
262 } else if (ctx->cqp >= 0) {
263 ret = libx265_param_parse_int(avctx, "qp", ctx->cqp);
264 if (ret < 0)
265 return ret;
266 }
267
268 #if X265_BUILD >= 89
269 if (avctx->qmin >= 0) {
270 ret = libx265_param_parse_int(avctx, "qpmin", avctx->qmin);
271 if (ret < 0)
272 return ret;
273 }
274 if (avctx->qmax >= 0) {
275 ret = libx265_param_parse_int(avctx, "qpmax", avctx->qmax);
276 if (ret < 0)
277 return ret;
278 }
279 #endif
280 if (avctx->max_qdiff >= 0) {
281 ret = libx265_param_parse_int(avctx, "qpstep", avctx->max_qdiff);
282 if (ret < 0)
283 return ret;
284 }
285 if (avctx->qblur >= 0) {
286 ret = libx265_param_parse_float(avctx, "qblur", avctx->qblur);
287 if (ret < 0)
288 return ret;
289 }
290 if (avctx->qcompress >= 0) {
291 ret = libx265_param_parse_float(avctx, "qcomp", avctx->qcompress);
292 if (ret < 0)
293 return ret;
294 }
295 if (avctx->i_quant_factor >= 0) {
296 ret = libx265_param_parse_float(avctx, "ipratio", avctx->i_quant_factor);
297 if (ret < 0)
298 return ret;
299 }
300 if (avctx->b_quant_factor >= 0) {
301 ret = libx265_param_parse_float(avctx, "pbratio", avctx->b_quant_factor);
302 if (ret < 0)
303 return ret;
304 }
305
306 ctx->params->rc.vbvBufferSize = avctx->rc_buffer_size / 1000;
307 ctx->params->rc.vbvMaxBitrate = avctx->rc_max_rate / 1000;
308
309 cpb_props = ff_add_cpb_side_data(avctx);
310 if (!cpb_props)
311 return AVERROR(ENOMEM);
312 cpb_props->buffer_size = ctx->params->rc.vbvBufferSize * 1000;
313 cpb_props->max_bitrate = ctx->params->rc.vbvMaxBitrate * 1000LL;
314 cpb_props->avg_bitrate = ctx->params->rc.bitrate * 1000LL;
315
316 if (!(avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER))
317 ctx->params->bRepeatHeaders = 1;
318
319 if (avctx->gop_size >= 0) {
320 ret = libx265_param_parse_int(avctx, "keyint", avctx->gop_size);
321 if (ret < 0)
322 return ret;
323 }
324 if (avctx->keyint_min > 0) {
325 ret = libx265_param_parse_int(avctx, "min-keyint", avctx->keyint_min);
326 if (ret < 0)
327 return ret;
328 }
329 if (avctx->max_b_frames >= 0) {
330 ret = libx265_param_parse_int(avctx, "bframes", avctx->max_b_frames);
331 if (ret < 0)
332 return ret;
333 }
334 if (avctx->refs >= 0) {
335 ret = libx265_param_parse_int(avctx, "ref", avctx->refs);
336 if (ret < 0)
337 return ret;
338 }
339
340 {
341 AVDictionaryEntry *en = NULL;
342 while ((en = av_dict_get(ctx->x265_opts, "", en, AV_DICT_IGNORE_SUFFIX))) {
343 int parse_ret = ctx->api->param_parse(ctx->params, en->key, en->value);
344
345 switch (parse_ret) {
346 case X265_PARAM_BAD_NAME:
347 av_log(avctx, AV_LOG_WARNING,
348 "Unknown option: %s.\n", en->key);
349 break;
350 case X265_PARAM_BAD_VALUE:
351 av_log(avctx, AV_LOG_WARNING,
352 "Invalid value for %s: %s.\n", en->key, en->value);
353 break;
354 default:
355 break;
356 }
357 }
358 }
359
360 if (ctx->params->rc.vbvBufferSize && avctx->rc_initial_buffer_occupancy > 1000 &&
361 ctx->params->rc.vbvBufferInit == 0.9) {
362 ctx->params->rc.vbvBufferInit = (float)avctx->rc_initial_buffer_occupancy / 1000;
363 }
364
365 if (ctx->profile) {
366 if (ctx->api->param_apply_profile(ctx->params, ctx->profile) < 0) {
367 int i;
368 av_log(avctx, AV_LOG_ERROR, "Invalid or incompatible profile set: %s.\n", ctx->profile);
369 av_log(avctx, AV_LOG_INFO, "Possible profiles:");
370 for (i = 0; x265_profile_names[i]; i++)
371 av_log(avctx, AV_LOG_INFO, " %s", x265_profile_names[i]);
372 av_log(avctx, AV_LOG_INFO, "\n");
373 return AVERROR(EINVAL);
374 }
375 }
376
377 ctx->encoder = ctx->api->encoder_open(ctx->params);
378 if (!ctx->encoder) {
379 av_log(avctx, AV_LOG_ERROR, "Cannot open libx265 encoder.\n");
380 libx265_encode_close(avctx);
381 return AVERROR_INVALIDDATA;
382 }
383
384 if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
385 x265_nal *nal;
386 int nnal;
387
388 avctx->extradata_size = ctx->api->encoder_headers(ctx->encoder, &nal, &nnal);
389 if (avctx->extradata_size <= 0) {
390 av_log(avctx, AV_LOG_ERROR, "Cannot encode headers.\n");
391 libx265_encode_close(avctx);
392 return AVERROR_INVALIDDATA;
393 }
394
395 avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
396 if (!avctx->extradata) {
397 av_log(avctx, AV_LOG_ERROR,
398 "Cannot allocate HEVC header of size %d.\n", avctx->extradata_size);
399 libx265_encode_close(avctx);
400 return AVERROR(ENOMEM);
401 }
402
403 memcpy(avctx->extradata, nal[0].payload, avctx->extradata_size);
404 memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
405 }
406
407 return 0;
408 }
409
libx265_encode_set_roi(libx265Context * ctx,const AVFrame * frame,x265_picture * pic)410 static av_cold int libx265_encode_set_roi(libx265Context *ctx, const AVFrame *frame, x265_picture* pic)
411 {
412 AVFrameSideData *sd = av_frame_get_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST);
413 if (sd) {
414 if (ctx->params->rc.aqMode == X265_AQ_NONE) {
415 if (!ctx->roi_warned) {
416 ctx->roi_warned = 1;
417 av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
418 }
419 } else {
420 /* 8x8 block when qg-size is 8, 16*16 block otherwise. */
421 int mb_size = (ctx->params->rc.qgSize == 8) ? 8 : 16;
422 int mbx = (frame->width + mb_size - 1) / mb_size;
423 int mby = (frame->height + mb_size - 1) / mb_size;
424 int qp_range = 51 + 6 * (pic->bitDepth - 8);
425 int nb_rois;
426 const AVRegionOfInterest *roi;
427 uint32_t roi_size;
428 float *qoffsets; /* will be freed after encode is called. */
429
430 roi = (const AVRegionOfInterest*)sd->data;
431 roi_size = roi->self_size;
432 if (!roi_size || sd->size % roi_size != 0) {
433 av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
434 return AVERROR(EINVAL);
435 }
436 nb_rois = sd->size / roi_size;
437
438 qoffsets = av_mallocz_array(mbx * mby, sizeof(*qoffsets));
439 if (!qoffsets)
440 return AVERROR(ENOMEM);
441
442 // This list must be iterated in reverse because the first
443 // region in the list applies when regions overlap.
444 for (int i = nb_rois - 1; i >= 0; i--) {
445 int startx, endx, starty, endy;
446 float qoffset;
447
448 roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
449
450 starty = FFMIN(mby, roi->top / mb_size);
451 endy = FFMIN(mby, (roi->bottom + mb_size - 1)/ mb_size);
452 startx = FFMIN(mbx, roi->left / mb_size);
453 endx = FFMIN(mbx, (roi->right + mb_size - 1)/ mb_size);
454
455 if (roi->qoffset.den == 0) {
456 av_free(qoffsets);
457 av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
458 return AVERROR(EINVAL);
459 }
460 qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
461 qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
462
463 for (int y = starty; y < endy; y++)
464 for (int x = startx; x < endx; x++)
465 qoffsets[x + y*mbx] = qoffset;
466 }
467
468 pic->quantOffsets = qoffsets;
469 }
470 }
471 return 0;
472 }
473
libx265_encode_frame(AVCodecContext * avctx,AVPacket * pkt,const AVFrame * pic,int * got_packet)474 static int libx265_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
475 const AVFrame *pic, int *got_packet)
476 {
477 libx265Context *ctx = avctx->priv_data;
478 x265_picture x265pic;
479 x265_picture x265pic_out = { 0 };
480 x265_nal *nal;
481 uint8_t *dst;
482 int pict_type;
483 int payload = 0;
484 int nnal;
485 int ret;
486 int i;
487
488 ctx->api->picture_init(ctx->params, &x265pic);
489
490 if (pic) {
491 for (i = 0; i < 3; i++) {
492 x265pic.planes[i] = pic->data[i];
493 x265pic.stride[i] = pic->linesize[i];
494 }
495
496 x265pic.pts = pic->pts;
497 x265pic.bitDepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
498
499 x265pic.sliceType = pic->pict_type == AV_PICTURE_TYPE_I ?
500 (ctx->forced_idr ? X265_TYPE_IDR : X265_TYPE_I) :
501 pic->pict_type == AV_PICTURE_TYPE_P ? X265_TYPE_P :
502 pic->pict_type == AV_PICTURE_TYPE_B ? X265_TYPE_B :
503 X265_TYPE_AUTO;
504
505 ret = libx265_encode_set_roi(ctx, pic, &x265pic);
506 if (ret < 0)
507 return ret;
508
509 if (pic->reordered_opaque) {
510 x265pic.userData = av_malloc(sizeof(pic->reordered_opaque));
511 if (!x265pic.userData) {
512 av_freep(&x265pic.quantOffsets);
513 return AVERROR(ENOMEM);
514 }
515
516 memcpy(x265pic.userData, &pic->reordered_opaque, sizeof(pic->reordered_opaque));
517 }
518 }
519
520 ret = ctx->api->encoder_encode(ctx->encoder, &nal, &nnal,
521 pic ? &x265pic : NULL, &x265pic_out);
522
523 av_freep(&x265pic.quantOffsets);
524
525 if (ret < 0)
526 return AVERROR_EXTERNAL;
527
528 if (!nnal)
529 return 0;
530
531 for (i = 0; i < nnal; i++)
532 payload += nal[i].sizeBytes;
533
534 ret = ff_alloc_packet2(avctx, pkt, payload, payload);
535 if (ret < 0) {
536 av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
537 return ret;
538 }
539 dst = pkt->data;
540
541 for (i = 0; i < nnal; i++) {
542 memcpy(dst, nal[i].payload, nal[i].sizeBytes);
543 dst += nal[i].sizeBytes;
544
545 if (is_keyframe(nal[i].type))
546 pkt->flags |= AV_PKT_FLAG_KEY;
547 }
548
549 pkt->pts = x265pic_out.pts;
550 pkt->dts = x265pic_out.dts;
551
552 switch (x265pic_out.sliceType) {
553 case X265_TYPE_IDR:
554 case X265_TYPE_I:
555 pict_type = AV_PICTURE_TYPE_I;
556 break;
557 case X265_TYPE_P:
558 pict_type = AV_PICTURE_TYPE_P;
559 break;
560 case X265_TYPE_B:
561 case X265_TYPE_BREF:
562 pict_type = AV_PICTURE_TYPE_B;
563 break;
564 default:
565 av_log(avctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
566 return AVERROR_EXTERNAL;
567 }
568
569 #if FF_API_CODED_FRAME
570 FF_DISABLE_DEPRECATION_WARNINGS
571 avctx->coded_frame->pict_type = pict_type;
572 FF_ENABLE_DEPRECATION_WARNINGS
573 #endif
574
575 #if X265_BUILD >= 130
576 if (x265pic_out.sliceType == X265_TYPE_B)
577 #else
578 if (x265pic_out.frameData.sliceType == 'b')
579 #endif
580 pkt->flags |= AV_PKT_FLAG_DISPOSABLE;
581
582 ff_side_data_set_encoder_stats(pkt, x265pic_out.frameData.qp * FF_QP2LAMBDA, NULL, 0, pict_type);
583
584 if (x265pic_out.userData) {
585 memcpy(&avctx->reordered_opaque, x265pic_out.userData, sizeof(avctx->reordered_opaque));
586 av_freep(&x265pic_out.userData);
587 } else
588 avctx->reordered_opaque = 0;
589
590 *got_packet = 1;
591 return 0;
592 }
593
594 static const enum AVPixelFormat x265_csp_eight[] = {
595 AV_PIX_FMT_YUV420P,
596 AV_PIX_FMT_YUVJ420P,
597 AV_PIX_FMT_YUV422P,
598 AV_PIX_FMT_YUVJ422P,
599 AV_PIX_FMT_YUV444P,
600 AV_PIX_FMT_YUVJ444P,
601 AV_PIX_FMT_GBRP,
602 AV_PIX_FMT_GRAY8,
603 AV_PIX_FMT_NONE
604 };
605
606 static const enum AVPixelFormat x265_csp_ten[] = {
607 AV_PIX_FMT_YUV420P,
608 AV_PIX_FMT_YUVJ420P,
609 AV_PIX_FMT_YUV422P,
610 AV_PIX_FMT_YUVJ422P,
611 AV_PIX_FMT_YUV444P,
612 AV_PIX_FMT_YUVJ444P,
613 AV_PIX_FMT_GBRP,
614 AV_PIX_FMT_YUV420P10,
615 AV_PIX_FMT_YUV422P10,
616 AV_PIX_FMT_YUV444P10,
617 AV_PIX_FMT_GBRP10,
618 AV_PIX_FMT_GRAY8,
619 AV_PIX_FMT_GRAY10,
620 AV_PIX_FMT_NONE
621 };
622
623 static const enum AVPixelFormat x265_csp_twelve[] = {
624 AV_PIX_FMT_YUV420P,
625 AV_PIX_FMT_YUVJ420P,
626 AV_PIX_FMT_YUV422P,
627 AV_PIX_FMT_YUVJ422P,
628 AV_PIX_FMT_YUV444P,
629 AV_PIX_FMT_YUVJ444P,
630 AV_PIX_FMT_GBRP,
631 AV_PIX_FMT_YUV420P10,
632 AV_PIX_FMT_YUV422P10,
633 AV_PIX_FMT_YUV444P10,
634 AV_PIX_FMT_GBRP10,
635 AV_PIX_FMT_YUV420P12,
636 AV_PIX_FMT_YUV422P12,
637 AV_PIX_FMT_YUV444P12,
638 AV_PIX_FMT_GBRP12,
639 AV_PIX_FMT_GRAY8,
640 AV_PIX_FMT_GRAY10,
641 AV_PIX_FMT_GRAY12,
642 AV_PIX_FMT_NONE
643 };
644
libx265_encode_init_csp(AVCodec * codec)645 static av_cold void libx265_encode_init_csp(AVCodec *codec)
646 {
647 if (x265_api_get(12))
648 codec->pix_fmts = x265_csp_twelve;
649 else if (x265_api_get(10))
650 codec->pix_fmts = x265_csp_ten;
651 else if (x265_api_get(8))
652 codec->pix_fmts = x265_csp_eight;
653 }
654
655 #define OFFSET(x) offsetof(libx265Context, x)
656 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
657 static const AVOption options[] = {
658 { "crf", "set the x265 crf", OFFSET(crf), AV_OPT_TYPE_FLOAT, { .dbl = -1 }, -1, FLT_MAX, VE },
659 { "qp", "set the x265 qp", OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
660 { "forced-idr", "if forcing keyframes, force them as IDR frames", OFFSET(forced_idr),AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
661 { "preset", "set the x265 preset", OFFSET(preset), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
662 { "tune", "set the x265 tune parameter", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
663 { "profile", "set the x265 profile", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
664 { "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 },
665 { NULL }
666 };
667
668 static const AVClass class = {
669 .class_name = "libx265",
670 .item_name = av_default_item_name,
671 .option = options,
672 .version = LIBAVUTIL_VERSION_INT,
673 };
674
675 static const AVCodecDefault x265_defaults[] = {
676 { "b", "0" },
677 { "bf", "-1" },
678 { "g", "-1" },
679 { "keyint_min", "-1" },
680 { "refs", "-1" },
681 { "qmin", "-1" },
682 { "qmax", "-1" },
683 { "qdiff", "-1" },
684 { "qblur", "-1" },
685 { "qcomp", "-1" },
686 { "i_qfactor", "-1" },
687 { "b_qfactor", "-1" },
688 { NULL },
689 };
690
691 AVCodec ff_libx265_encoder = {
692 .name = "libx265",
693 .long_name = NULL_IF_CONFIG_SMALL("libx265 H.265 / HEVC"),
694 .type = AVMEDIA_TYPE_VIDEO,
695 .id = AV_CODEC_ID_HEVC,
696 .init = libx265_encode_init,
697 .init_static_data = libx265_encode_init_csp,
698 .encode2 = libx265_encode_frame,
699 .close = libx265_encode_close,
700 .priv_data_size = sizeof(libx265Context),
701 .priv_class = &class,
702 .defaults = x265_defaults,
703 .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS |
704 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
705 .caps_internal = FF_CODEC_CAP_AUTO_THREADS,
706 .wrapper_name = "libx265",
707 };
708