FFmpeg
libx265.c
Go to the documentation of this file.
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/avassert.h"
31 #include "libavutil/buffer.h"
32 #include "libavutil/internal.h"
34 #include "libavutil/mem.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/pixdesc.h"
37 #include "avcodec.h"
38 #include "codec_internal.h"
39 #include "dovi_rpu.h"
40 #include "encode.h"
41 #include "packet_internal.h"
42 #include "atsc_a53.h"
43 #include "sei.h"
44 
45 typedef struct ReorderedData {
46  int64_t duration;
47 
48  void *frame_opaque;
50 
51  int in_use;
53 
54 typedef struct libx265Context {
55  const AVClass *class;
56 
57  x265_encoder *encoder;
58  x265_param *params;
59  const x265_api *api;
60 
61  float crf;
62  int cqp;
64  char *preset;
65  char *tune;
66  char *profile;
68 
69  void *sei_data;
71  int udu_sei;
72  int a53_cc;
73 
75  int nb_rd;
76 
77  /**
78  * If the encoder does not support ROI then warn the first time we
79  * encounter a frame with ROI side data.
80  */
82 
85 
86 static int is_keyframe(NalUnitType naltype)
87 {
88  switch (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:
95  return 1;
96  default:
97  return 0;
98  }
99 }
100 
102 {
103  const int add = 16;
104 
106  int idx;
107 
108  for (int i = 0; i < ctx->nb_rd; i++)
109  if (!ctx->rd[i].in_use) {
110  ctx->rd[i].in_use = 1;
111  return i;
112  }
113 
114  tmp = av_realloc_array(ctx->rd, ctx->nb_rd + add, sizeof(*ctx->rd));
115  if (!tmp)
116  return AVERROR(ENOMEM);
117  memset(tmp + ctx->nb_rd, 0, sizeof(*tmp) * add);
118 
119  ctx->rd = tmp;
120  ctx->nb_rd += add;
121 
122  idx = ctx->nb_rd - add;
123  ctx->rd[idx].in_use = 1;
124 
125  return idx;
126 }
127 
128 static void rd_release(libx265Context *ctx, int idx)
129 {
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]));
133 }
134 
136 {
137  libx265Context *ctx = avctx->priv_data;
138 
139  ctx->api->param_free(ctx->params);
140  av_freep(&ctx->sei_data);
141 
142  for (int i = 0; i < ctx->nb_rd; i++)
143  rd_release(ctx, i);
144  av_freep(&ctx->rd);
145 
146  if (ctx->encoder)
147  ctx->api->encoder_close(ctx->encoder);
148 
149  ff_dovi_ctx_unref(&ctx->dovi);
150 
151  return 0;
152 }
153 
155  const char *key, float value)
156 {
157  libx265Context *ctx = avctx->priv_data;
158  char buf[256];
159 
160  snprintf(buf, sizeof(buf), "%2.2f", value);
161  if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
162  av_log(avctx, AV_LOG_ERROR, "Invalid value %2.2f for param \"%s\".\n", value, key);
163  return AVERROR(EINVAL);
164  }
165 
166  return 0;
167 }
168 
170  const char *key, int value)
171 {
172  libx265Context *ctx = avctx->priv_data;
173  char buf[256];
174 
175  snprintf(buf, sizeof(buf), "%d", value);
176  if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
177  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for param \"%s\".\n", value, key);
178  return AVERROR(EINVAL);
179  }
180 
181  return 0;
182 }
183 
184 static int handle_mdcv(void *logctx, const x265_api *api,
185  x265_param *params,
186  const AVMasteringDisplayMetadata *mdcv)
187 {
188  char buf[10 /* # of PRId64s */ * 20 /* max strlen for %PRId64 */ + sizeof("G(,)B(,)R(,)WP(,)L(,)")];
189 
190  // G(%hu,%hu)B(%hu,%hu)R(%hu,%hu)WP(%hu,%hu)L(%u,%u)
191  snprintf(buf, sizeof(buf),
192  "G(%"PRId64",%"PRId64")B(%"PRId64",%"PRId64")R(%"PRId64",%"PRId64")"
193  "WP(%"PRId64",%"PRId64")L(%"PRId64",%"PRId64")",
194  av_rescale_q(1, mdcv->display_primaries[1][0], (AVRational){ 1, 50000 }),
195  av_rescale_q(1, mdcv->display_primaries[1][1], (AVRational){ 1, 50000 }),
196  av_rescale_q(1, mdcv->display_primaries[2][0], (AVRational){ 1, 50000 }),
197  av_rescale_q(1, mdcv->display_primaries[2][1], (AVRational){ 1, 50000 }),
198  av_rescale_q(1, mdcv->display_primaries[0][0], (AVRational){ 1, 50000 }),
199  av_rescale_q(1, mdcv->display_primaries[0][1], (AVRational){ 1, 50000 }),
200  av_rescale_q(1, mdcv->white_point[0], (AVRational){ 1, 50000 }),
201  av_rescale_q(1, mdcv->white_point[1], (AVRational){ 1, 50000 }),
202  av_rescale_q(1, mdcv->max_luminance, (AVRational){ 1, 10000 }),
203  av_rescale_q(1, mdcv->min_luminance, (AVRational){ 1, 10000 }));
204 
205  if (api->param_parse(params, "master-display", buf) ==
206  X265_PARAM_BAD_VALUE) {
207  av_log(logctx, AV_LOG_ERROR,
208  "Invalid value \"%s\" for param \"master-display\".\n",
209  buf);
210  return AVERROR(EINVAL);
211  }
212 
213  return 0;
214 }
215 
216 static int handle_side_data(AVCodecContext *avctx, const x265_api *api,
217  x265_param *params)
218 {
219  const AVFrameSideData *cll_sd =
222  const AVFrameSideData *mdcv_sd =
224  avctx->nb_decoded_side_data,
226 
227  if (cll_sd) {
228  const AVContentLightMetadata *cll =
229  (AVContentLightMetadata *)cll_sd->data;
230 
231  params->maxCLL = cll->MaxCLL;
232  params->maxFALL = cll->MaxFALL;
233  }
234 
235  if (mdcv_sd) {
236  int ret = handle_mdcv(
237  avctx, api, params,
238  (AVMasteringDisplayMetadata *)mdcv_sd->data);
239  if (ret < 0)
240  return ret;
241  }
242 
243  return 0;
244 }
245 
247 {
248  libx265Context *ctx = avctx->priv_data;
249  AVCPBProperties *cpb_props = NULL;
251  int ret;
252 
253  ctx->api = x265_api_get(desc->comp[0].depth);
254  if (!ctx->api)
255  ctx->api = x265_api_get(0);
256 
257  ctx->params = ctx->api->param_alloc();
258  if (!ctx->params) {
259  av_log(avctx, AV_LOG_ERROR, "Could not allocate x265 param structure.\n");
260  return AVERROR(ENOMEM);
261  }
262 
263  if (ctx->api->param_default_preset(ctx->params, ctx->preset, ctx->tune) < 0) {
264  int i;
265 
266  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", ctx->preset, ctx->tune);
267  av_log(avctx, AV_LOG_INFO, "Possible presets:");
268  for (i = 0; x265_preset_names[i]; i++)
269  av_log(avctx, AV_LOG_INFO, " %s", x265_preset_names[i]);
270 
271  av_log(avctx, AV_LOG_INFO, "\n");
272  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
273  for (i = 0; x265_tune_names[i]; i++)
274  av_log(avctx, AV_LOG_INFO, " %s", x265_tune_names[i]);
275 
276  av_log(avctx, AV_LOG_INFO, "\n");
277 
278  return AVERROR(EINVAL);
279  }
280 
281  ctx->params->frameNumThreads = avctx->thread_count;
282  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
283  ctx->params->fpsNum = avctx->framerate.num;
284  ctx->params->fpsDenom = avctx->framerate.den;
285  } else {
286  ctx->params->fpsNum = avctx->time_base.den;
288  ctx->params->fpsDenom = avctx->time_base.num
289 #if FF_API_TICKS_PER_FRAME
290  * avctx->ticks_per_frame
291 #endif
292  ;
294  }
295  ctx->params->sourceWidth = avctx->width;
296  ctx->params->sourceHeight = avctx->height;
297  ctx->params->bEnablePsnr = !!(avctx->flags & AV_CODEC_FLAG_PSNR);
298  ctx->params->bOpenGOP = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
299 
300  /* Tune the CTU size based on input resolution. */
301  if (ctx->params->sourceWidth < 64 || ctx->params->sourceHeight < 64)
302  ctx->params->maxCUSize = 32;
303  if (ctx->params->sourceWidth < 32 || ctx->params->sourceHeight < 32)
304  ctx->params->maxCUSize = 16;
305  if (ctx->params->sourceWidth < 16 || ctx->params->sourceHeight < 16) {
306  av_log(avctx, AV_LOG_ERROR, "Image size is too small (%dx%d).\n",
307  ctx->params->sourceWidth, ctx->params->sourceHeight);
308  return AVERROR(EINVAL);
309  }
310 
311 
312  ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
313 
314  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED)
315  ctx->params->vui.bEnableVideoFullRangeFlag =
316  avctx->color_range == AVCOL_RANGE_JPEG;
317  else
318  ctx->params->vui.bEnableVideoFullRangeFlag =
319  (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
320  avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
321  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
322  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P;
323 
325  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
326  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
327 
328  ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
329 
330  // x265 validates the parameters internally
331  ctx->params->vui.colorPrimaries = avctx->color_primaries;
332  ctx->params->vui.transferCharacteristics = avctx->color_trc;
333 #if X265_BUILD >= 159
334  if (avctx->color_trc == AVCOL_TRC_ARIB_STD_B67)
335  ctx->params->preferredTransferCharacteristics = ctx->params->vui.transferCharacteristics;
336 #endif
337  ctx->params->vui.matrixCoeffs = avctx->colorspace;
338  }
339 
340  // chroma sample location values are to be ignored in case of non-4:2:0
341  // according to the specification, so we only write them out in case of
342  // 4:2:0 (log2_chroma_{w,h} == 1).
343  ctx->params->vui.bEnableChromaLocInfoPresentFlag =
345  desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1;
346 
347  if (ctx->params->vui.bEnableChromaLocInfoPresentFlag) {
348  ctx->params->vui.chromaSampleLocTypeTopField =
349  ctx->params->vui.chromaSampleLocTypeBottomField =
350  avctx->chroma_sample_location - 1;
351  }
352 
353  if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
354  char sar[12];
355  int sar_num, sar_den;
356 
357  av_reduce(&sar_num, &sar_den,
358  avctx->sample_aspect_ratio.num,
359  avctx->sample_aspect_ratio.den, 65535);
360  snprintf(sar, sizeof(sar), "%d:%d", sar_num, sar_den);
361  if (ctx->api->param_parse(ctx->params, "sar", sar) == X265_PARAM_BAD_VALUE) {
362  av_log(avctx, AV_LOG_ERROR, "Invalid SAR: %d:%d.\n", sar_num, sar_den);
363  return AVERROR_INVALIDDATA;
364  }
365  }
366 
367  switch (desc->log2_chroma_w) {
368  // 4:4:4, RGB. gray
369  case 0:
370  // gray
371  if (desc->nb_components == 1) {
372  if (ctx->api->api_build_number < 85) {
373  av_log(avctx, AV_LOG_ERROR,
374  "libx265 version is %d, must be at least 85 for gray encoding.\n",
375  ctx->api->api_build_number);
376  return AVERROR_INVALIDDATA;
377  }
378  ctx->params->internalCsp = X265_CSP_I400;
379  break;
380  }
381 
382  // set identity matrix for RGB
383  if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
384  ctx->params->vui.matrixCoeffs = AVCOL_SPC_RGB;
385  ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
386  ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
387  }
388 
389  ctx->params->internalCsp = X265_CSP_I444;
390  break;
391  // 4:2:0, 4:2:2
392  case 1:
393  ctx->params->internalCsp = desc->log2_chroma_h == 1 ?
394  X265_CSP_I420 : X265_CSP_I422;
395  break;
396  default:
397  av_log(avctx, AV_LOG_ERROR,
398  "Pixel format '%s' cannot be mapped to a libx265 CSP!\n",
399  desc->name);
400  return AVERROR_BUG;
401  }
402 
403  ret = handle_side_data(avctx, ctx->api, ctx->params);
404  if (ret < 0) {
405  av_log(avctx, AV_LOG_ERROR, "Failed handling side data! (%s)\n",
406  av_err2str(ret));
407  return ret;
408  }
409 
410  if (ctx->crf >= 0) {
411  char crf[6];
412 
413  snprintf(crf, sizeof(crf), "%2.2f", ctx->crf);
414  if (ctx->api->param_parse(ctx->params, "crf", crf) == X265_PARAM_BAD_VALUE) {
415  av_log(avctx, AV_LOG_ERROR, "Invalid crf: %2.2f.\n", ctx->crf);
416  return AVERROR(EINVAL);
417  }
418  } else if (avctx->bit_rate > 0) {
419  ctx->params->rc.bitrate = avctx->bit_rate / 1000;
420  ctx->params->rc.rateControlMode = X265_RC_ABR;
421  } else if (ctx->cqp >= 0) {
422  ret = libx265_param_parse_int(avctx, "qp", ctx->cqp);
423  if (ret < 0)
424  return ret;
425  }
426 
427  if (avctx->qmin >= 0) {
428  ret = libx265_param_parse_int(avctx, "qpmin", avctx->qmin);
429  if (ret < 0)
430  return ret;
431  }
432  if (avctx->qmax >= 0) {
433  ret = libx265_param_parse_int(avctx, "qpmax", avctx->qmax);
434  if (ret < 0)
435  return ret;
436  }
437  if (avctx->max_qdiff >= 0) {
438  ret = libx265_param_parse_int(avctx, "qpstep", avctx->max_qdiff);
439  if (ret < 0)
440  return ret;
441  }
442  if (avctx->qblur >= 0) {
443  ret = libx265_param_parse_float(avctx, "qblur", avctx->qblur);
444  if (ret < 0)
445  return ret;
446  }
447  if (avctx->qcompress >= 0) {
448  ret = libx265_param_parse_float(avctx, "qcomp", avctx->qcompress);
449  if (ret < 0)
450  return ret;
451  }
452  if (avctx->i_quant_factor >= 0) {
453  ret = libx265_param_parse_float(avctx, "ipratio", avctx->i_quant_factor);
454  if (ret < 0)
455  return ret;
456  }
457  if (avctx->b_quant_factor >= 0) {
458  ret = libx265_param_parse_float(avctx, "pbratio", avctx->b_quant_factor);
459  if (ret < 0)
460  return ret;
461  }
462 
463  ctx->params->rc.vbvBufferSize = avctx->rc_buffer_size / 1000;
464  ctx->params->rc.vbvMaxBitrate = avctx->rc_max_rate / 1000;
465 
466  cpb_props = ff_encode_add_cpb_side_data(avctx);
467  if (!cpb_props)
468  return AVERROR(ENOMEM);
469  cpb_props->buffer_size = ctx->params->rc.vbvBufferSize * 1000;
470  cpb_props->max_bitrate = ctx->params->rc.vbvMaxBitrate * 1000LL;
471  cpb_props->avg_bitrate = ctx->params->rc.bitrate * 1000LL;
472 
473  if (!(avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER))
474  ctx->params->bRepeatHeaders = 1;
475 
476  if (avctx->gop_size >= 0) {
477  ret = libx265_param_parse_int(avctx, "keyint", avctx->gop_size);
478  if (ret < 0)
479  return ret;
480  }
481  if (avctx->keyint_min > 0) {
482  ret = libx265_param_parse_int(avctx, "min-keyint", avctx->keyint_min);
483  if (ret < 0)
484  return ret;
485  }
486  if (avctx->max_b_frames >= 0) {
487  ret = libx265_param_parse_int(avctx, "bframes", avctx->max_b_frames);
488  if (ret < 0)
489  return ret;
490  }
491  if (avctx->refs >= 0) {
492  ret = libx265_param_parse_int(avctx, "ref", avctx->refs);
493  if (ret < 0)
494  return ret;
495  }
496 
497  {
498  const AVDictionaryEntry *en = NULL;
499  while ((en = av_dict_iterate(ctx->x265_opts, en))) {
500  int parse_ret = ctx->api->param_parse(ctx->params, en->key, en->value);
501 
502  switch (parse_ret) {
503  case X265_PARAM_BAD_NAME:
504  av_log(avctx, AV_LOG_WARNING,
505  "Unknown option: %s.\n", en->key);
506  break;
507  case X265_PARAM_BAD_VALUE:
508  av_log(avctx, AV_LOG_WARNING,
509  "Invalid value for %s: %s.\n", en->key, en->value);
510  break;
511  default:
512  break;
513  }
514  }
515  }
516 
517  if (ctx->params->rc.vbvBufferSize && avctx->rc_initial_buffer_occupancy > 1000 &&
518  ctx->params->rc.vbvBufferInit == 0.9) {
519  ctx->params->rc.vbvBufferInit = (float)avctx->rc_initial_buffer_occupancy / 1000;
520  }
521 
522  if (ctx->profile) {
523  if (ctx->api->param_apply_profile(ctx->params, ctx->profile) < 0) {
524  int i;
525  av_log(avctx, AV_LOG_ERROR, "Invalid or incompatible profile set: %s.\n", ctx->profile);
526  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
527  for (i = 0; x265_profile_names[i]; i++)
528  av_log(avctx, AV_LOG_INFO, " %s", x265_profile_names[i]);
529  av_log(avctx, AV_LOG_INFO, "\n");
530  return AVERROR(EINVAL);
531  }
532  }
533 
534 #if X265_BUILD >= 167
535  ctx->dovi.logctx = avctx;
536  if ((ret = ff_dovi_configure(&ctx->dovi, avctx)) < 0)
537  return ret;
538  ctx->params->dolbyProfile = ctx->dovi.cfg.dv_profile * 10 +
539  ctx->dovi.cfg.dv_bl_signal_compatibility_id;
540 #endif
541 
542  ctx->encoder = ctx->api->encoder_open(ctx->params);
543  if (!ctx->encoder) {
544  av_log(avctx, AV_LOG_ERROR, "Cannot open libx265 encoder.\n");
545  libx265_encode_close(avctx);
546  return AVERROR_INVALIDDATA;
547  }
548 
549  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
550  x265_nal *nal;
551  int nnal;
552 
553  avctx->extradata_size = ctx->api->encoder_headers(ctx->encoder, &nal, &nnal);
554  if (avctx->extradata_size <= 0) {
555  av_log(avctx, AV_LOG_ERROR, "Cannot encode headers.\n");
556  libx265_encode_close(avctx);
557  return AVERROR_INVALIDDATA;
558  }
559 
561  if (!avctx->extradata) {
562  av_log(avctx, AV_LOG_ERROR,
563  "Cannot allocate HEVC header of size %d.\n", avctx->extradata_size);
564  libx265_encode_close(avctx);
565  return AVERROR(ENOMEM);
566  }
567 
568  memcpy(avctx->extradata, nal[0].payload, avctx->extradata_size);
569  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
570  }
571 
572  return 0;
573 }
574 
575 static av_cold int libx265_encode_set_roi(libx265Context *ctx, const AVFrame *frame, x265_picture* pic)
576 {
578  if (sd) {
579  if (ctx->params->rc.aqMode == X265_AQ_NONE) {
580  if (!ctx->roi_warned) {
581  ctx->roi_warned = 1;
582  av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
583  }
584  } else {
585  /* 8x8 block when qg-size is 8, 16*16 block otherwise. */
586  int mb_size = (ctx->params->rc.qgSize == 8) ? 8 : 16;
587  int mbx = (frame->width + mb_size - 1) / mb_size;
588  int mby = (frame->height + mb_size - 1) / mb_size;
589  int qp_range = 51 + 6 * (pic->bitDepth - 8);
590  int nb_rois;
591  const AVRegionOfInterest *roi;
592  uint32_t roi_size;
593  float *qoffsets; /* will be freed after encode is called. */
594 
595  roi = (const AVRegionOfInterest*)sd->data;
596  roi_size = roi->self_size;
597  if (!roi_size || sd->size % roi_size != 0) {
598  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
599  return AVERROR(EINVAL);
600  }
601  nb_rois = sd->size / roi_size;
602 
603  qoffsets = av_calloc(mbx * mby, sizeof(*qoffsets));
604  if (!qoffsets)
605  return AVERROR(ENOMEM);
606 
607  // This list must be iterated in reverse because the first
608  // region in the list applies when regions overlap.
609  for (int i = nb_rois - 1; i >= 0; i--) {
610  int startx, endx, starty, endy;
611  float qoffset;
612 
613  roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
614 
615  starty = FFMIN(mby, roi->top / mb_size);
616  endy = FFMIN(mby, (roi->bottom + mb_size - 1)/ mb_size);
617  startx = FFMIN(mbx, roi->left / mb_size);
618  endx = FFMIN(mbx, (roi->right + mb_size - 1)/ mb_size);
619 
620  if (roi->qoffset.den == 0) {
621  av_free(qoffsets);
622  av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
623  return AVERROR(EINVAL);
624  }
625  qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
626  qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
627 
628  for (int y = starty; y < endy; y++)
629  for (int x = startx; x < endx; x++)
630  qoffsets[x + y*mbx] = qoffset;
631  }
632 
633  pic->quantOffsets = qoffsets;
634  }
635  }
636  return 0;
637 }
638 
639 static void free_picture(libx265Context *ctx, x265_picture *pic)
640 {
641  x265_sei *sei = &pic->userSEI;
642  for (int i = 0; i < sei->numPayloads; i++)
643  av_free(sei->payloads[i].payload);
644 
645 #if X265_BUILD >= 167
646  av_free(pic->rpu.payload);
647 #endif
648 
649  if (pic->userData) {
650  int idx = (int)(intptr_t)pic->userData - 1;
651  rd_release(ctx, idx);
652  pic->userData = NULL;
653  }
654 
655  av_freep(&pic->quantOffsets);
656  sei->numPayloads = 0;
657 }
658 
660  const AVFrame *pic, int *got_packet)
661 {
662  libx265Context *ctx = avctx->priv_data;
663  x265_picture x265pic;
664  x265_picture x265pic_out = { 0 };
665  x265_nal *nal;
666  x265_sei *sei;
667  uint8_t *dst;
668  int pict_type;
669  int payload = 0;
670  int nnal;
671  int ret;
672  int i;
673 
674  ctx->api->picture_init(ctx->params, &x265pic);
675 
676  sei = &x265pic.userSEI;
677  sei->numPayloads = 0;
678 
679  if (pic) {
680  AVFrameSideData *sd;
681  ReorderedData *rd;
682  int rd_idx;
683 
684  for (i = 0; i < 3; i++) {
685  x265pic.planes[i] = pic->data[i];
686  x265pic.stride[i] = pic->linesize[i];
687  }
688 
689  x265pic.pts = pic->pts;
690  x265pic.bitDepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
691 
692  x265pic.sliceType = pic->pict_type == AV_PICTURE_TYPE_I ?
693  (ctx->forced_idr ? X265_TYPE_IDR : X265_TYPE_I) :
694  pic->pict_type == AV_PICTURE_TYPE_P ? X265_TYPE_P :
695  pic->pict_type == AV_PICTURE_TYPE_B ? X265_TYPE_B :
696  X265_TYPE_AUTO;
697 
698  ret = libx265_encode_set_roi(ctx, pic, &x265pic);
699  if (ret < 0)
700  return ret;
701 
702  rd_idx = rd_get(ctx);
703  if (rd_idx < 0) {
704  free_picture(ctx, &x265pic);
705  return rd_idx;
706  }
707  rd = &ctx->rd[rd_idx];
708 
709  rd->duration = pic->duration;
710  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
711  rd->frame_opaque = pic->opaque;
713  if (ret < 0) {
714  rd_release(ctx, rd_idx);
715  free_picture(ctx, &x265pic);
716  return ret;
717  }
718  }
719 
720  x265pic.userData = (void*)(intptr_t)(rd_idx + 1);
721 
722  if (ctx->a53_cc) {
723  void *sei_data;
724  size_t sei_size;
725 
726  ret = ff_alloc_a53_sei(pic, 0, &sei_data, &sei_size);
727  if (ret < 0) {
728  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
729  } else if (sei_data) {
730  void *tmp;
731  x265_sei_payload *sei_payload;
732 
733  tmp = av_fast_realloc(ctx->sei_data,
734  &ctx->sei_data_size,
735  (sei->numPayloads + 1) * sizeof(*sei_payload));
736  if (!tmp) {
737  av_free(sei_data);
738  free_picture(ctx, &x265pic);
739  return AVERROR(ENOMEM);
740  }
741  ctx->sei_data = tmp;
742  sei->payloads = ctx->sei_data;
743  sei_payload = &sei->payloads[sei->numPayloads];
744  sei_payload->payload = sei_data;
745  sei_payload->payloadSize = sei_size;
746  sei_payload->payloadType = SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35;
747  sei->numPayloads++;
748  }
749  }
750 
751  if (ctx->udu_sei) {
752  for (i = 0; i < pic->nb_side_data; i++) {
753  AVFrameSideData *side_data = pic->side_data[i];
754  void *tmp;
755  x265_sei_payload *sei_payload;
756 
757  if (side_data->type != AV_FRAME_DATA_SEI_UNREGISTERED)
758  continue;
759 
760  tmp = av_fast_realloc(ctx->sei_data,
761  &ctx->sei_data_size,
762  (sei->numPayloads + 1) * sizeof(*sei_payload));
763  if (!tmp) {
764  free_picture(ctx, &x265pic);
765  return AVERROR(ENOMEM);
766  }
767  ctx->sei_data = tmp;
768  sei->payloads = ctx->sei_data;
769  sei_payload = &sei->payloads[sei->numPayloads];
770  sei_payload->payload = av_memdup(side_data->data, side_data->size);
771  if (!sei_payload->payload) {
772  free_picture(ctx, &x265pic);
773  return AVERROR(ENOMEM);
774  }
775  sei_payload->payloadSize = side_data->size;
776  /* Equal to libx265 USER_DATA_UNREGISTERED */
777  sei_payload->payloadType = SEI_TYPE_USER_DATA_UNREGISTERED;
778  sei->numPayloads++;
779  }
780  }
781 
782 #if X265_BUILD >= 167
784  if (ctx->dovi.cfg.dv_profile && sd) {
785  const AVDOVIMetadata *metadata = (const AVDOVIMetadata *)sd->data;
786  ret = ff_dovi_rpu_generate(&ctx->dovi, metadata, &x265pic.rpu.payload,
787  &x265pic.rpu.payloadSize);
788  if (ret < 0) {
789  free_picture(ctx, &x265pic);
790  return ret;
791  }
792  } else if (ctx->dovi.cfg.dv_profile) {
793  av_log(avctx, AV_LOG_ERROR, "Dolby Vision enabled, but received frame "
794  "without AV_FRAME_DATA_DOVI_METADATA");
795  free_picture(ctx, &x265pic);
796  return AVERROR_INVALIDDATA;
797  }
798 #endif
799  }
800 
801  ret = ctx->api->encoder_encode(ctx->encoder, &nal, &nnal,
802  pic ? &x265pic : NULL, &x265pic_out);
803 
804  for (i = 0; i < sei->numPayloads; i++)
805  av_free(sei->payloads[i].payload);
806  av_freep(&x265pic.quantOffsets);
807 
808  if (ret < 0)
809  return AVERROR_EXTERNAL;
810 
811  if (!nnal)
812  return 0;
813 
814  for (i = 0; i < nnal; i++)
815  payload += nal[i].sizeBytes;
816 
817  ret = ff_get_encode_buffer(avctx, pkt, payload, 0);
818  if (ret < 0) {
819  av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
820  return ret;
821  }
822  dst = pkt->data;
823 
824  for (i = 0; i < nnal; i++) {
825  memcpy(dst, nal[i].payload, nal[i].sizeBytes);
826  dst += nal[i].sizeBytes;
827 
828  if (is_keyframe(nal[i].type))
830  }
831 
832  pkt->pts = x265pic_out.pts;
833  pkt->dts = x265pic_out.dts;
834 
835  switch (x265pic_out.sliceType) {
836  case X265_TYPE_IDR:
837  case X265_TYPE_I:
838  pict_type = AV_PICTURE_TYPE_I;
839  break;
840  case X265_TYPE_P:
841  pict_type = AV_PICTURE_TYPE_P;
842  break;
843  case X265_TYPE_B:
844  case X265_TYPE_BREF:
845  pict_type = AV_PICTURE_TYPE_B;
846  break;
847  default:
848  av_log(avctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
849  return AVERROR_EXTERNAL;
850  }
851 
852 #if X265_BUILD >= 130
853  if (x265pic_out.sliceType == X265_TYPE_B)
854 #else
855  if (x265pic_out.frameData.sliceType == 'b')
856 #endif
858 
859  ff_side_data_set_encoder_stats(pkt, x265pic_out.frameData.qp * FF_QP2LAMBDA, NULL, 0, pict_type);
860 
861  if (x265pic_out.userData) {
862  int idx = (int)(intptr_t)x265pic_out.userData - 1;
863  ReorderedData *rd = &ctx->rd[idx];
864 
865  pkt->duration = rd->duration;
866 
867  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
868  pkt->opaque = rd->frame_opaque;
870  rd->frame_opaque_ref = NULL;
871  }
872 
873  rd_release(ctx, idx);
874  }
875 
876  *got_packet = 1;
877  return 0;
878 }
879 
880 static const enum AVPixelFormat x265_csp_eight[] = {
890 };
891 
892 static const enum AVPixelFormat x265_csp_ten[] = {
907 };
908 
909 static const enum AVPixelFormat x265_csp_twelve[] = {
929 };
930 
932 {
933  if (x265_api_get(12))
934  codec->p.pix_fmts = x265_csp_twelve;
935  else if (x265_api_get(10))
936  codec->p.pix_fmts = x265_csp_ten;
937  else if (x265_api_get(8))
938  codec->p.pix_fmts = x265_csp_eight;
939 }
940 
941 #define OFFSET(x) offsetof(libx265Context, x)
942 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
943 static const AVOption options[] = {
944  { "crf", "set the x265 crf", OFFSET(crf), AV_OPT_TYPE_FLOAT, { .dbl = -1 }, -1, FLT_MAX, VE },
945  { "qp", "set the x265 qp", OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
946  { "forced-idr", "if forcing keyframes, force them as IDR frames", OFFSET(forced_idr),AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
947  { "preset", "set the x265 preset", OFFSET(preset), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
948  { "tune", "set the x265 tune parameter", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
949  { "profile", "set the x265 profile", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
950  { "udu_sei", "Use user data unregistered SEI if available", OFFSET(udu_sei), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
951  { "a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
952  { "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 },
953 #if X265_BUILD >= 167
954  { "dolbyvision", "Enable Dolby Vision RPU coding", OFFSET(dovi.enable), AV_OPT_TYPE_BOOL, {.i64 = FF_DOVI_AUTOMATIC }, -1, 1, VE, .unit = "dovi" },
955  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DOVI_AUTOMATIC}, .flags = VE, .unit = "dovi" },
956 #endif
957  { NULL }
958 };
959 
960 static const AVClass class = {
961  .class_name = "libx265",
962  .item_name = av_default_item_name,
963  .option = options,
965 };
966 
967 static const FFCodecDefault x265_defaults[] = {
968  { "b", "0" },
969  { "bf", "-1" },
970  { "g", "-1" },
971  { "keyint_min", "-1" },
972  { "refs", "-1" },
973  { "qmin", "-1" },
974  { "qmax", "-1" },
975  { "qdiff", "-1" },
976  { "qblur", "-1" },
977  { "qcomp", "-1" },
978  { "i_qfactor", "-1" },
979  { "b_qfactor", "-1" },
980  { NULL },
981 };
982 
984  .p.name = "libx265",
985  CODEC_LONG_NAME("libx265 H.265 / HEVC"),
986  .p.type = AVMEDIA_TYPE_VIDEO,
987  .p.id = AV_CODEC_ID_HEVC,
988  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
991  .p.priv_class = &class,
992  .p.wrapper_name = "libx265",
993  .init = libx265_encode_init,
994  .init_static_data = libx265_encode_init_csp,
996  .close = libx265_encode_close,
997  .priv_data_size = sizeof(libx265Context),
999  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
1001 };
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
ff_alloc_a53_sei
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.
Definition: atsc_a53.c:26
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AVCodecContext::keyint_min
int keyint_min
minimum GOP size
Definition: avcodec.h:1024
AVERROR
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
opt.h
ff_dovi_ctx_unref
void ff_dovi_ctx_unref(DOVIContext *s)
Completely reset a DOVIContext, preserving only logctx.
Definition: dovi_rpu.c:29
libx265_param_parse_int
static av_cold int libx265_param_parse_int(AVCodecContext *avctx, const char *key, int value)
Definition: libx265.c:169
libx265_param_parse_float
static av_cold int libx265_param_parse_float(AVCodecContext *avctx, const char *key, float value)
Definition: libx265.c:154
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
AVCodecContext::decoded_side_data
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition: avcodec.h:2077
libx265Context::forced_idr
int forced_idr
Definition: libx265.c:63
defaults
static const FFCodecDefault defaults[]
Definition: amfenc_av1.c:456
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:947
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:780
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
libx265Context::params
x265_param * params
Definition: libx265.c:58
AVFrame::nb_side_data
int nb_side_data
Definition: frame.h:608
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
options
static const AVOption options[]
Definition: libx265.c:943
AV_FRAME_DATA_DOVI_METADATA
@ AV_FRAME_DATA_DOVI_METADATA
Parsed Dolby Vision metadata, suitable for passing to a software implementation.
Definition: frame.h:208
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:209
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:522
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:111
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:486
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
VE
#define VE
Definition: libx265.c:942
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:686
AVPacket::data
uint8_t * data
Definition: packet.h:520
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
free_picture
static void free_picture(libx265Context *ctx, x265_picture *pic)
Definition: libx265.c:639
AVOption
AVOption.
Definition: opt.h:357
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:478
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:34
FFCodec
Definition: codec_internal.h:126
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:610
float.h
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:538
ReorderedData::in_use
int in_use
Definition: libx265.c:51
AVDictionary
Definition: dict.c:34
AV_PKT_FLAG_DISPOSABLE
#define AV_PKT_FLAG_DISPOSABLE
Flag is used to indicate packets that contain frames that can be discarded by the decoder.
Definition: packet.h:594
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:326
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1263
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:575
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:338
libx265Context::x265_opts
AVDictionary * x265_opts
Definition: libx265.c:67
libx265Context::roi_warned
int roi_warned
If the encoder does not support ROI then warn the first time we encounter a frame with ROI side data.
Definition: libx265.c:81
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
AVFrame::opaque_ref
AVBufferRef * opaque_ref
Frame owner's private data.
Definition: frame.h:741
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
libx265_encode_frame
static int libx265_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
Definition: libx265.c:659
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:299
AVCodecContext::i_quant_factor
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
Definition: avcodec.h:820
FFCodecDefault
Definition: codec_internal.h:96
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
DOVIContext
Definition: dovi_rpu.h:32
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:556
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1583
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:494
libx265_encode_init_csp
static av_cold void libx265_encode_init_csp(FFCodec *codec)
Definition: libx265.c:931
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:715
libx265Context::a53_cc
int a53_cc
Definition: libx265.c:72
libx265Context::preset
char * preset
Definition: libx265.c:64
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
dovi_rpu.h
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:295
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
AVRational::num
int num
Numerator.
Definition: rational.h:59
ff_dovi_configure
int ff_dovi_configure(DOVIContext *s, AVCodecContext *avctx)
Configure the encoder for Dolby Vision encoding.
Definition: dovi_rpuenc.c:55
FF_DOVI_AUTOMATIC
#define FF_DOVI_AUTOMATIC
Enable tri-state.
Definition: dovi_rpu.h:39
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
preset
preset
Definition: vf_curves.c:47
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVFrameSideData::size
size_t size
Definition: frame.h:253
av_cold
#define av_cold
Definition: attributes.h:90
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:300
AVCodecContext::rc_initial_buffer_occupancy
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1320
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:86
float
float
Definition: af_crystalizer.c:121
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
av_fast_realloc
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.
Definition: mem.c:497
AVDOVIMetadata
Combined struct representing a combination of header, mapping and color metadata, for attaching to fr...
Definition: dovi_meta.h:324
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:316
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
AVCodecContext::nb_decoded_side_data
int nb_decoded_side_data
Definition: avcodec.h:2078
AVDictionaryEntry::key
char * key
Definition: dict.h:90
rd_release
static void rd_release(libx265Context *ctx, int idx)
Definition: libx265.c:128
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:124
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
ctx
AVFormatContext * ctx
Definition: movenc.c:49
SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
@ SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
Definition: sei.h:34
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1292
key
const char * key
Definition: hwcontext_opencl.c:189
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:545
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:270
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:459
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1277
ff_dovi_rpu_generate
int ff_dovi_rpu_generate(DOVIContext *s, const AVDOVIMetadata *metadata, uint8_t **out_rpu, int *out_size)
Synthesize a Dolby Vision RPU reflecting the current state.
Definition: dovi_rpuenc.c:437
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCodecContext::qblur
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:1249
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
libx265_encode_init
static av_cold int libx265_encode_init(AVCodecContext *avctx)
Definition: libx265.c:246
sei.h
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:252
libx265Context::tune
char * tune
Definition: libx265.c:65
AVRegionOfInterest::self_size
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:305
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
libx265Context::encoder
x265_encoder * encoder
Definition: libx265.c:57
libx265Context::dovi
DOVIContext dovi
Definition: libx265.c:83
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:120
ReorderedData::duration
int64_t duration
Definition: libx265.c:46
OFFSET
#define OFFSET(x)
Definition: libx265.c:941
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
av_clipf
av_clipf
Definition: af_crystalizer.c:121
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:824
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:652
AV_FRAME_DATA_SEI_UNREGISTERED
@ AV_FRAME_DATA_SEI_UNREGISTERED
User data unregistered metadata associated with a video frame.
Definition: frame.h:178
AVCodecContext::qcompress
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:1248
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:544
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:476
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1031
codec_internal.h
ReorderedData::frame_opaque_ref
AVBufferRef * frame_opaque_ref
Definition: libx265.c:49
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:122
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:483
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:485
AVFrameSideData::data
uint8_t * data
Definition: frame.h:252
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:706
libx265Context::udu_sei
int udu_sei
Definition: libx265.c:71
buffer.h
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:519
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:526
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:285
AVRegionOfInterest::right
int right
Definition: frame.h:318
libx265Context::cqp
int cqp
Definition: libx265.c:62
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AVCodecContext::b_quant_factor
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...
Definition: avcodec.h:804
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:248
ReorderedData
Definition: libx265.c:45
AVRegionOfInterest::left
int left
Definition: frame.h:317
handle_mdcv
static int handle_mdcv(void *logctx, const x265_api *api, x265_param *params, const AVMasteringDisplayMetadata *mdcv)
Definition: libx265.c:184
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:137
libx265Context::crf
float crf
Definition: libx265.c:61
libx265Context::api
const x265_api * api
Definition: libx265.c:59
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:513
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
AVRegionOfInterest::top
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
Definition: frame.h:315
internal.h
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:495
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:275
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:702
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
AVFrame::side_data
AVFrameSideData ** side_data
Definition: frame.h:607
profile
int profile
Definition: mxfenc.c:2227
libx265_encode_set_roi
static av_cold int libx265_encode_set_roi(libx265Context *ctx, const AVFrame *frame, x265_picture *pic)
Definition: libx265.c:575
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
libx265Context::sei_data
void * sei_data
Definition: libx265.c:69
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
avcodec.h
libx265Context::rd
ReorderedData * rd
Definition: libx265.c:74
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:352
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
frame
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
Definition: filter_design.txt:264
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:291
atsc_a53.h
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:482
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
rd_get
static int rd_get(libx265Context *ctx)
Definition: libx265.c:101
AVCodecContext::max_qdiff
int max_qdiff
maximum quantizer difference between frames
Definition: avcodec.h:1270
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVCOL_TRC_ARIB_STD_B67
@ AVCOL_TRC_ARIB_STD_B67
ARIB STD-B67, known as "Hybrid log-gamma".
Definition: pixfmt.h:601
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:106
SEI_TYPE_USER_DATA_UNREGISTERED
@ SEI_TYPE_USER_DATA_UNREGISTERED
Definition: sei.h:35
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1256
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:251
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
x265_csp_ten
static enum AVPixelFormat x265_csp_ten[]
Definition: libx265.c:892
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:576
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
libx265_encode_close
static av_cold int libx265_encode_close(AVCodecContext *avctx)
Definition: libx265.c:135
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
ff_libx265_encoder
FFCodec ff_libx265_encoder
Definition: libx265.c:983
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
libx265Context::sei_data_size
int sei_data_size
Definition: libx265.c:70
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
desc
const char * desc
Definition: libsvtav1.c:79
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
AVCodecContext::max_b_frames
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...
Definition: avcodec.h:795
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
packet_internal.h
handle_side_data
static int handle_side_data(AVCodecContext *avctx, const x265_api *api, x265_param *params)
Definition: libx265.c:216
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:72
mastering_display_metadata.h
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:250
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
ReorderedData::frame_opaque
void * frame_opaque
Definition: libx265.c:48
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVPacket
This structure stores compressed data.
Definition: packet.h:497
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
libx265Context::nb_rd
int nb_rd
Definition: libx265.c:75
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_frame_side_data_get
static const AVFrameSideData * av_frame_side_data_get(AVFrameSideData *const *sd, const int nb_sd, enum AVFrameSideDataType type)
Wrapper around av_frame_side_data_get_c() to workaround the limitation that for any type T the conver...
Definition: frame.h:1143
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
AV_FRAME_DATA_REGIONS_OF_INTEREST
@ AV_FRAME_DATA_REGIONS_OF_INTEREST
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
Definition: frame.h:165
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:419
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: packet.c:607
x265_defaults
static const FFCodecDefault x265_defaults[]
Definition: libx265.c:967
ff_encode_add_cpb_side_data
AVCPBProperties * ff_encode_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: encode.c:880
libx265Context::profile
char * profile
Definition: libx265.c:66
AVDictionaryEntry::value
char * value
Definition: dict.h:91
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:249
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:460
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
libx265Context
Definition: libx265.c:54
int
int
Definition: ffmpeg_filter.c:424
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:342
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
snprintf
#define snprintf
Definition: snprintf.h:34
x265_csp_eight
static enum AVPixelFormat x265_csp_eight[]
Definition: libx265.c:880
x265_csp_twelve
static enum AVPixelFormat x265_csp_twelve[]
Definition: libx265.c:909
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:642
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
is_keyframe
static int is_keyframe(NalUnitType naltype)
Definition: libx265.c:86