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/opt.h"
35 #include "libavutil/pixdesc.h"
36 #include "avcodec.h"
37 #include "codec_internal.h"
38 #include "encode.h"
39 #include "packet_internal.h"
40 #include "atsc_a53.h"
41 #include "sei.h"
42 
43 typedef struct ReorderedData {
44  int64_t duration;
45 
46  void *frame_opaque;
48 
49  int in_use;
51 
52 typedef struct libx265Context {
53  const AVClass *class;
54 
55  x265_encoder *encoder;
56  x265_param *params;
57  const x265_api *api;
58 
59  float crf;
60  int cqp;
62  char *preset;
63  char *tune;
64  char *profile;
66 
67  void *sei_data;
69  int udu_sei;
70  int a53_cc;
71 
73  int nb_rd;
74 
75  /**
76  * If the encoder does not support ROI then warn the first time we
77  * encounter a frame with ROI side data.
78  */
81 
82 static int is_keyframe(NalUnitType naltype)
83 {
84  switch (naltype) {
85  case NAL_UNIT_CODED_SLICE_BLA_W_LP:
86  case NAL_UNIT_CODED_SLICE_BLA_W_RADL:
87  case NAL_UNIT_CODED_SLICE_BLA_N_LP:
88  case NAL_UNIT_CODED_SLICE_IDR_W_RADL:
89  case NAL_UNIT_CODED_SLICE_IDR_N_LP:
90  case NAL_UNIT_CODED_SLICE_CRA:
91  return 1;
92  default:
93  return 0;
94  }
95 }
96 
98 {
99  const int add = 16;
100 
102  int idx;
103 
104  for (int i = 0; i < ctx->nb_rd; i++)
105  if (!ctx->rd[i].in_use) {
106  ctx->rd[i].in_use = 1;
107  return i;
108  }
109 
110  tmp = av_realloc_array(ctx->rd, ctx->nb_rd + add, sizeof(*ctx->rd));
111  if (!tmp)
112  return AVERROR(ENOMEM);
113  memset(tmp + ctx->nb_rd, 0, sizeof(*tmp) * add);
114 
115  ctx->rd = tmp;
116  ctx->nb_rd += add;
117 
118  idx = ctx->nb_rd - add;
119  ctx->rd[idx].in_use = 1;
120 
121  return idx;
122 }
123 
124 static void rd_release(libx265Context *ctx, int idx)
125 {
126  av_assert0(idx >= 0 && idx < ctx->nb_rd);
127  av_buffer_unref(&ctx->rd[idx].frame_opaque_ref);
128  memset(&ctx->rd[idx], 0, sizeof(ctx->rd[idx]));
129 }
130 
132 {
133  libx265Context *ctx = avctx->priv_data;
134 
135  ctx->api->param_free(ctx->params);
136  av_freep(&ctx->sei_data);
137 
138  for (int i = 0; i < ctx->nb_rd; i++)
139  rd_release(ctx, i);
140  av_freep(&ctx->rd);
141 
142  if (ctx->encoder)
143  ctx->api->encoder_close(ctx->encoder);
144 
145  return 0;
146 }
147 
149  const char *key, float value)
150 {
151  libx265Context *ctx = avctx->priv_data;
152  char buf[256];
153 
154  snprintf(buf, sizeof(buf), "%2.2f", value);
155  if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
156  av_log(avctx, AV_LOG_ERROR, "Invalid value %2.2f for param \"%s\".\n", value, key);
157  return AVERROR(EINVAL);
158  }
159 
160  return 0;
161 }
162 
164  const char *key, int value)
165 {
166  libx265Context *ctx = avctx->priv_data;
167  char buf[256];
168 
169  snprintf(buf, sizeof(buf), "%d", value);
170  if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
171  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for param \"%s\".\n", value, key);
172  return AVERROR(EINVAL);
173  }
174 
175  return 0;
176 }
177 
178 static int handle_mdcv(void *logctx, const x265_api *api,
179  x265_param *params,
180  const AVMasteringDisplayMetadata *mdcv)
181 {
182  char buf[10 /* # of PRId64s */ * 20 /* max strlen for %PRId64 */ + sizeof("G(,)B(,)R(,)WP(,)L(,)")];
183 
184  // G(%hu,%hu)B(%hu,%hu)R(%hu,%hu)WP(%hu,%hu)L(%u,%u)
185  snprintf(buf, sizeof(buf),
186  "G(%"PRId64",%"PRId64")B(%"PRId64",%"PRId64")R(%"PRId64",%"PRId64")"
187  "WP(%"PRId64",%"PRId64")L(%"PRId64",%"PRId64")",
188  av_rescale_q(1, mdcv->display_primaries[1][0], (AVRational){ 1, 50000 }),
189  av_rescale_q(1, mdcv->display_primaries[1][1], (AVRational){ 1, 50000 }),
190  av_rescale_q(1, mdcv->display_primaries[2][0], (AVRational){ 1, 50000 }),
191  av_rescale_q(1, mdcv->display_primaries[2][1], (AVRational){ 1, 50000 }),
192  av_rescale_q(1, mdcv->display_primaries[0][0], (AVRational){ 1, 50000 }),
193  av_rescale_q(1, mdcv->display_primaries[0][1], (AVRational){ 1, 50000 }),
194  av_rescale_q(1, mdcv->white_point[0], (AVRational){ 1, 50000 }),
195  av_rescale_q(1, mdcv->white_point[1], (AVRational){ 1, 50000 }),
196  av_rescale_q(1, mdcv->max_luminance, (AVRational){ 1, 10000 }),
197  av_rescale_q(1, mdcv->min_luminance, (AVRational){ 1, 10000 }));
198 
199  if (api->param_parse(params, "master-display", buf) ==
200  X265_PARAM_BAD_VALUE) {
201  av_log(logctx, AV_LOG_ERROR,
202  "Invalid value \"%s\" for param \"master-display\".\n",
203  buf);
204  return AVERROR(EINVAL);
205  }
206 
207  return 0;
208 }
209 
210 static int handle_side_data(AVCodecContext *avctx, const x265_api *api,
211  x265_param *params)
212 {
213  const AVFrameSideData *cll_sd =
216  const AVFrameSideData *mdcv_sd =
218  avctx->nb_decoded_side_data,
220 
221  if (cll_sd) {
222  const AVContentLightMetadata *cll =
223  (AVContentLightMetadata *)cll_sd->data;
224 
225  params->maxCLL = cll->MaxCLL;
226  params->maxFALL = cll->MaxFALL;
227  }
228 
229  if (mdcv_sd) {
230  int ret = handle_mdcv(
231  avctx, api, params,
232  (AVMasteringDisplayMetadata *)mdcv_sd->data);
233  if (ret < 0)
234  return ret;
235  }
236 
237  return 0;
238 }
239 
241 {
242  libx265Context *ctx = avctx->priv_data;
243  AVCPBProperties *cpb_props = NULL;
245  int ret;
246 
247  ctx->api = x265_api_get(desc->comp[0].depth);
248  if (!ctx->api)
249  ctx->api = x265_api_get(0);
250 
251  ctx->params = ctx->api->param_alloc();
252  if (!ctx->params) {
253  av_log(avctx, AV_LOG_ERROR, "Could not allocate x265 param structure.\n");
254  return AVERROR(ENOMEM);
255  }
256 
257  if (ctx->api->param_default_preset(ctx->params, ctx->preset, ctx->tune) < 0) {
258  int i;
259 
260  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", ctx->preset, ctx->tune);
261  av_log(avctx, AV_LOG_INFO, "Possible presets:");
262  for (i = 0; x265_preset_names[i]; i++)
263  av_log(avctx, AV_LOG_INFO, " %s", x265_preset_names[i]);
264 
265  av_log(avctx, AV_LOG_INFO, "\n");
266  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
267  for (i = 0; x265_tune_names[i]; i++)
268  av_log(avctx, AV_LOG_INFO, " %s", x265_tune_names[i]);
269 
270  av_log(avctx, AV_LOG_INFO, "\n");
271 
272  return AVERROR(EINVAL);
273  }
274 
275  ctx->params->frameNumThreads = avctx->thread_count;
276  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
277  ctx->params->fpsNum = avctx->framerate.num;
278  ctx->params->fpsDenom = avctx->framerate.den;
279  } else {
280  ctx->params->fpsNum = avctx->time_base.den;
282  ctx->params->fpsDenom = avctx->time_base.num
283 #if FF_API_TICKS_PER_FRAME
284  * avctx->ticks_per_frame
285 #endif
286  ;
288  }
289  ctx->params->sourceWidth = avctx->width;
290  ctx->params->sourceHeight = avctx->height;
291  ctx->params->bEnablePsnr = !!(avctx->flags & AV_CODEC_FLAG_PSNR);
292  ctx->params->bOpenGOP = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
293 
294  /* Tune the CTU size based on input resolution. */
295  if (ctx->params->sourceWidth < 64 || ctx->params->sourceHeight < 64)
296  ctx->params->maxCUSize = 32;
297  if (ctx->params->sourceWidth < 32 || ctx->params->sourceHeight < 32)
298  ctx->params->maxCUSize = 16;
299  if (ctx->params->sourceWidth < 16 || ctx->params->sourceHeight < 16) {
300  av_log(avctx, AV_LOG_ERROR, "Image size is too small (%dx%d).\n",
301  ctx->params->sourceWidth, ctx->params->sourceHeight);
302  return AVERROR(EINVAL);
303  }
304 
305 
306  ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
307 
308  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED)
309  ctx->params->vui.bEnableVideoFullRangeFlag =
310  avctx->color_range == AVCOL_RANGE_JPEG;
311  else
312  ctx->params->vui.bEnableVideoFullRangeFlag =
313  (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
314  avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
315  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
316  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P;
317 
318  if ((avctx->color_primaries <= AVCOL_PRI_SMPTE432 &&
320  (avctx->color_trc <= AVCOL_TRC_ARIB_STD_B67 &&
321  avctx->color_trc != AVCOL_TRC_UNSPECIFIED) ||
322  (avctx->colorspace <= AVCOL_SPC_ICTCP &&
323  avctx->colorspace != AVCOL_SPC_UNSPECIFIED)) {
324 
325  ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
326 
327  // x265 validates the parameters internally
328  ctx->params->vui.colorPrimaries = avctx->color_primaries;
329  ctx->params->vui.transferCharacteristics = avctx->color_trc;
330 #if X265_BUILD >= 159
331  if (avctx->color_trc == AVCOL_TRC_ARIB_STD_B67)
332  ctx->params->preferredTransferCharacteristics = ctx->params->vui.transferCharacteristics;
333 #endif
334  ctx->params->vui.matrixCoeffs = avctx->colorspace;
335  }
336 
337  // chroma sample location values are to be ignored in case of non-4:2:0
338  // according to the specification, so we only write them out in case of
339  // 4:2:0 (log2_chroma_{w,h} == 1).
340  ctx->params->vui.bEnableChromaLocInfoPresentFlag =
342  desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1;
343 
344  if (ctx->params->vui.bEnableChromaLocInfoPresentFlag) {
345  ctx->params->vui.chromaSampleLocTypeTopField =
346  ctx->params->vui.chromaSampleLocTypeBottomField =
347  avctx->chroma_sample_location - 1;
348  }
349 
350  if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
351  char sar[12];
352  int sar_num, sar_den;
353 
354  av_reduce(&sar_num, &sar_den,
355  avctx->sample_aspect_ratio.num,
356  avctx->sample_aspect_ratio.den, 65535);
357  snprintf(sar, sizeof(sar), "%d:%d", sar_num, sar_den);
358  if (ctx->api->param_parse(ctx->params, "sar", sar) == X265_PARAM_BAD_VALUE) {
359  av_log(avctx, AV_LOG_ERROR, "Invalid SAR: %d:%d.\n", sar_num, sar_den);
360  return AVERROR_INVALIDDATA;
361  }
362  }
363 
364  switch (desc->log2_chroma_w) {
365  // 4:4:4, RGB. gray
366  case 0:
367  // gray
368  if (desc->nb_components == 1) {
369  if (ctx->api->api_build_number < 85) {
370  av_log(avctx, AV_LOG_ERROR,
371  "libx265 version is %d, must be at least 85 for gray encoding.\n",
372  ctx->api->api_build_number);
373  return AVERROR_INVALIDDATA;
374  }
375  ctx->params->internalCsp = X265_CSP_I400;
376  break;
377  }
378 
379  // set identity matrix for RGB
380  if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
381  ctx->params->vui.matrixCoeffs = AVCOL_SPC_RGB;
382  ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
383  ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
384  }
385 
386  ctx->params->internalCsp = X265_CSP_I444;
387  break;
388  // 4:2:0, 4:2:2
389  case 1:
390  ctx->params->internalCsp = desc->log2_chroma_h == 1 ?
391  X265_CSP_I420 : X265_CSP_I422;
392  break;
393  default:
394  av_log(avctx, AV_LOG_ERROR,
395  "Pixel format '%s' cannot be mapped to a libx265 CSP!\n",
396  desc->name);
397  return AVERROR_BUG;
398  }
399 
400  ret = handle_side_data(avctx, ctx->api, ctx->params);
401  if (ret < 0) {
402  av_log(avctx, AV_LOG_ERROR, "Failed handling side data! (%s)\n",
403  av_err2str(ret));
404  return ret;
405  }
406 
407  if (ctx->crf >= 0) {
408  char crf[6];
409 
410  snprintf(crf, sizeof(crf), "%2.2f", ctx->crf);
411  if (ctx->api->param_parse(ctx->params, "crf", crf) == X265_PARAM_BAD_VALUE) {
412  av_log(avctx, AV_LOG_ERROR, "Invalid crf: %2.2f.\n", ctx->crf);
413  return AVERROR(EINVAL);
414  }
415  } else if (avctx->bit_rate > 0) {
416  ctx->params->rc.bitrate = avctx->bit_rate / 1000;
417  ctx->params->rc.rateControlMode = X265_RC_ABR;
418  } else if (ctx->cqp >= 0) {
419  ret = libx265_param_parse_int(avctx, "qp", ctx->cqp);
420  if (ret < 0)
421  return ret;
422  }
423 
424  if (avctx->qmin >= 0) {
425  ret = libx265_param_parse_int(avctx, "qpmin", avctx->qmin);
426  if (ret < 0)
427  return ret;
428  }
429  if (avctx->qmax >= 0) {
430  ret = libx265_param_parse_int(avctx, "qpmax", avctx->qmax);
431  if (ret < 0)
432  return ret;
433  }
434  if (avctx->max_qdiff >= 0) {
435  ret = libx265_param_parse_int(avctx, "qpstep", avctx->max_qdiff);
436  if (ret < 0)
437  return ret;
438  }
439  if (avctx->qblur >= 0) {
440  ret = libx265_param_parse_float(avctx, "qblur", avctx->qblur);
441  if (ret < 0)
442  return ret;
443  }
444  if (avctx->qcompress >= 0) {
445  ret = libx265_param_parse_float(avctx, "qcomp", avctx->qcompress);
446  if (ret < 0)
447  return ret;
448  }
449  if (avctx->i_quant_factor >= 0) {
450  ret = libx265_param_parse_float(avctx, "ipratio", avctx->i_quant_factor);
451  if (ret < 0)
452  return ret;
453  }
454  if (avctx->b_quant_factor >= 0) {
455  ret = libx265_param_parse_float(avctx, "pbratio", avctx->b_quant_factor);
456  if (ret < 0)
457  return ret;
458  }
459 
460  ctx->params->rc.vbvBufferSize = avctx->rc_buffer_size / 1000;
461  ctx->params->rc.vbvMaxBitrate = avctx->rc_max_rate / 1000;
462 
463  cpb_props = ff_encode_add_cpb_side_data(avctx);
464  if (!cpb_props)
465  return AVERROR(ENOMEM);
466  cpb_props->buffer_size = ctx->params->rc.vbvBufferSize * 1000;
467  cpb_props->max_bitrate = ctx->params->rc.vbvMaxBitrate * 1000LL;
468  cpb_props->avg_bitrate = ctx->params->rc.bitrate * 1000LL;
469 
470  if (!(avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER))
471  ctx->params->bRepeatHeaders = 1;
472 
473  if (avctx->gop_size >= 0) {
474  ret = libx265_param_parse_int(avctx, "keyint", avctx->gop_size);
475  if (ret < 0)
476  return ret;
477  }
478  if (avctx->keyint_min > 0) {
479  ret = libx265_param_parse_int(avctx, "min-keyint", avctx->keyint_min);
480  if (ret < 0)
481  return ret;
482  }
483  if (avctx->max_b_frames >= 0) {
484  ret = libx265_param_parse_int(avctx, "bframes", avctx->max_b_frames);
485  if (ret < 0)
486  return ret;
487  }
488  if (avctx->refs >= 0) {
489  ret = libx265_param_parse_int(avctx, "ref", avctx->refs);
490  if (ret < 0)
491  return ret;
492  }
493 
494  {
495  AVDictionaryEntry *en = NULL;
496  while ((en = av_dict_get(ctx->x265_opts, "", en, AV_DICT_IGNORE_SUFFIX))) {
497  int parse_ret = ctx->api->param_parse(ctx->params, en->key, en->value);
498 
499  switch (parse_ret) {
500  case X265_PARAM_BAD_NAME:
501  av_log(avctx, AV_LOG_WARNING,
502  "Unknown option: %s.\n", en->key);
503  break;
504  case X265_PARAM_BAD_VALUE:
505  av_log(avctx, AV_LOG_WARNING,
506  "Invalid value for %s: %s.\n", en->key, en->value);
507  break;
508  default:
509  break;
510  }
511  }
512  }
513 
514  if (ctx->params->rc.vbvBufferSize && avctx->rc_initial_buffer_occupancy > 1000 &&
515  ctx->params->rc.vbvBufferInit == 0.9) {
516  ctx->params->rc.vbvBufferInit = (float)avctx->rc_initial_buffer_occupancy / 1000;
517  }
518 
519  if (ctx->profile) {
520  if (ctx->api->param_apply_profile(ctx->params, ctx->profile) < 0) {
521  int i;
522  av_log(avctx, AV_LOG_ERROR, "Invalid or incompatible profile set: %s.\n", ctx->profile);
523  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
524  for (i = 0; x265_profile_names[i]; i++)
525  av_log(avctx, AV_LOG_INFO, " %s", x265_profile_names[i]);
526  av_log(avctx, AV_LOG_INFO, "\n");
527  return AVERROR(EINVAL);
528  }
529  }
530 
531  ctx->encoder = ctx->api->encoder_open(ctx->params);
532  if (!ctx->encoder) {
533  av_log(avctx, AV_LOG_ERROR, "Cannot open libx265 encoder.\n");
534  libx265_encode_close(avctx);
535  return AVERROR_INVALIDDATA;
536  }
537 
538  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
539  x265_nal *nal;
540  int nnal;
541 
542  avctx->extradata_size = ctx->api->encoder_headers(ctx->encoder, &nal, &nnal);
543  if (avctx->extradata_size <= 0) {
544  av_log(avctx, AV_LOG_ERROR, "Cannot encode headers.\n");
545  libx265_encode_close(avctx);
546  return AVERROR_INVALIDDATA;
547  }
548 
550  if (!avctx->extradata) {
551  av_log(avctx, AV_LOG_ERROR,
552  "Cannot allocate HEVC header of size %d.\n", avctx->extradata_size);
553  libx265_encode_close(avctx);
554  return AVERROR(ENOMEM);
555  }
556 
557  memcpy(avctx->extradata, nal[0].payload, avctx->extradata_size);
558  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
559  }
560 
561  return 0;
562 }
563 
564 static av_cold int libx265_encode_set_roi(libx265Context *ctx, const AVFrame *frame, x265_picture* pic)
565 {
567  if (sd) {
568  if (ctx->params->rc.aqMode == X265_AQ_NONE) {
569  if (!ctx->roi_warned) {
570  ctx->roi_warned = 1;
571  av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
572  }
573  } else {
574  /* 8x8 block when qg-size is 8, 16*16 block otherwise. */
575  int mb_size = (ctx->params->rc.qgSize == 8) ? 8 : 16;
576  int mbx = (frame->width + mb_size - 1) / mb_size;
577  int mby = (frame->height + mb_size - 1) / mb_size;
578  int qp_range = 51 + 6 * (pic->bitDepth - 8);
579  int nb_rois;
580  const AVRegionOfInterest *roi;
581  uint32_t roi_size;
582  float *qoffsets; /* will be freed after encode is called. */
583 
584  roi = (const AVRegionOfInterest*)sd->data;
585  roi_size = roi->self_size;
586  if (!roi_size || sd->size % roi_size != 0) {
587  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
588  return AVERROR(EINVAL);
589  }
590  nb_rois = sd->size / roi_size;
591 
592  qoffsets = av_calloc(mbx * mby, sizeof(*qoffsets));
593  if (!qoffsets)
594  return AVERROR(ENOMEM);
595 
596  // This list must be iterated in reverse because the first
597  // region in the list applies when regions overlap.
598  for (int i = nb_rois - 1; i >= 0; i--) {
599  int startx, endx, starty, endy;
600  float qoffset;
601 
602  roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
603 
604  starty = FFMIN(mby, roi->top / mb_size);
605  endy = FFMIN(mby, (roi->bottom + mb_size - 1)/ mb_size);
606  startx = FFMIN(mbx, roi->left / mb_size);
607  endx = FFMIN(mbx, (roi->right + mb_size - 1)/ mb_size);
608 
609  if (roi->qoffset.den == 0) {
610  av_free(qoffsets);
611  av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
612  return AVERROR(EINVAL);
613  }
614  qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
615  qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
616 
617  for (int y = starty; y < endy; y++)
618  for (int x = startx; x < endx; x++)
619  qoffsets[x + y*mbx] = qoffset;
620  }
621 
622  pic->quantOffsets = qoffsets;
623  }
624  }
625  return 0;
626 }
627 
628 static void free_picture(libx265Context *ctx, x265_picture *pic)
629 {
630  x265_sei *sei = &pic->userSEI;
631  for (int i = 0; i < sei->numPayloads; i++)
632  av_free(sei->payloads[i].payload);
633 
634  if (pic->userData) {
635  int idx = (int)(intptr_t)pic->userData - 1;
636  rd_release(ctx, idx);
637  pic->userData = NULL;
638  }
639 
640  av_freep(&pic->quantOffsets);
641  sei->numPayloads = 0;
642 }
643 
645  const AVFrame *pic, int *got_packet)
646 {
647  libx265Context *ctx = avctx->priv_data;
648  x265_picture x265pic;
649  x265_picture x265pic_out = { 0 };
650  x265_nal *nal;
651  x265_sei *sei;
652  uint8_t *dst;
653  int pict_type;
654  int payload = 0;
655  int nnal;
656  int ret;
657  int i;
658 
659  ctx->api->picture_init(ctx->params, &x265pic);
660 
661  sei = &x265pic.userSEI;
662  sei->numPayloads = 0;
663 
664  if (pic) {
665  ReorderedData *rd;
666  int rd_idx;
667 
668  for (i = 0; i < 3; i++) {
669  x265pic.planes[i] = pic->data[i];
670  x265pic.stride[i] = pic->linesize[i];
671  }
672 
673  x265pic.pts = pic->pts;
674  x265pic.bitDepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
675 
676  x265pic.sliceType = pic->pict_type == AV_PICTURE_TYPE_I ?
677  (ctx->forced_idr ? X265_TYPE_IDR : X265_TYPE_I) :
678  pic->pict_type == AV_PICTURE_TYPE_P ? X265_TYPE_P :
679  pic->pict_type == AV_PICTURE_TYPE_B ? X265_TYPE_B :
680  X265_TYPE_AUTO;
681 
682  ret = libx265_encode_set_roi(ctx, pic, &x265pic);
683  if (ret < 0)
684  return ret;
685 
686  rd_idx = rd_get(ctx);
687  if (rd_idx < 0) {
688  free_picture(ctx, &x265pic);
689  return rd_idx;
690  }
691  rd = &ctx->rd[rd_idx];
692 
693  rd->duration = pic->duration;
694  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
695  rd->frame_opaque = pic->opaque;
697  if (ret < 0) {
698  rd_release(ctx, rd_idx);
699  free_picture(ctx, &x265pic);
700  return ret;
701  }
702  }
703 
704  x265pic.userData = (void*)(intptr_t)(rd_idx + 1);
705 
706  if (ctx->a53_cc) {
707  void *sei_data;
708  size_t sei_size;
709 
710  ret = ff_alloc_a53_sei(pic, 0, &sei_data, &sei_size);
711  if (ret < 0) {
712  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
713  } else if (sei_data) {
714  void *tmp;
715  x265_sei_payload *sei_payload;
716 
717  tmp = av_fast_realloc(ctx->sei_data,
718  &ctx->sei_data_size,
719  (sei->numPayloads + 1) * sizeof(*sei_payload));
720  if (!tmp) {
721  av_free(sei_data);
722  free_picture(ctx, &x265pic);
723  return AVERROR(ENOMEM);
724  }
725  ctx->sei_data = tmp;
726  sei->payloads = ctx->sei_data;
727  sei_payload = &sei->payloads[sei->numPayloads];
728  sei_payload->payload = sei_data;
729  sei_payload->payloadSize = sei_size;
730  sei_payload->payloadType = SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35;
731  sei->numPayloads++;
732  }
733  }
734 
735  if (ctx->udu_sei) {
736  for (i = 0; i < pic->nb_side_data; i++) {
737  AVFrameSideData *side_data = pic->side_data[i];
738  void *tmp;
739  x265_sei_payload *sei_payload;
740 
741  if (side_data->type != AV_FRAME_DATA_SEI_UNREGISTERED)
742  continue;
743 
744  tmp = av_fast_realloc(ctx->sei_data,
745  &ctx->sei_data_size,
746  (sei->numPayloads + 1) * sizeof(*sei_payload));
747  if (!tmp) {
748  free_picture(ctx, &x265pic);
749  return AVERROR(ENOMEM);
750  }
751  ctx->sei_data = tmp;
752  sei->payloads = ctx->sei_data;
753  sei_payload = &sei->payloads[sei->numPayloads];
754  sei_payload->payload = av_memdup(side_data->data, side_data->size);
755  if (!sei_payload->payload) {
756  free_picture(ctx, &x265pic);
757  return AVERROR(ENOMEM);
758  }
759  sei_payload->payloadSize = side_data->size;
760  /* Equal to libx265 USER_DATA_UNREGISTERED */
761  sei_payload->payloadType = SEI_TYPE_USER_DATA_UNREGISTERED;
762  sei->numPayloads++;
763  }
764  }
765  }
766 
767  ret = ctx->api->encoder_encode(ctx->encoder, &nal, &nnal,
768  pic ? &x265pic : NULL, &x265pic_out);
769 
770  for (i = 0; i < sei->numPayloads; i++)
771  av_free(sei->payloads[i].payload);
772  av_freep(&x265pic.quantOffsets);
773 
774  if (ret < 0)
775  return AVERROR_EXTERNAL;
776 
777  if (!nnal)
778  return 0;
779 
780  for (i = 0; i < nnal; i++)
781  payload += nal[i].sizeBytes;
782 
783  ret = ff_get_encode_buffer(avctx, pkt, payload, 0);
784  if (ret < 0) {
785  av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
786  return ret;
787  }
788  dst = pkt->data;
789 
790  for (i = 0; i < nnal; i++) {
791  memcpy(dst, nal[i].payload, nal[i].sizeBytes);
792  dst += nal[i].sizeBytes;
793 
794  if (is_keyframe(nal[i].type))
796  }
797 
798  pkt->pts = x265pic_out.pts;
799  pkt->dts = x265pic_out.dts;
800 
801  switch (x265pic_out.sliceType) {
802  case X265_TYPE_IDR:
803  case X265_TYPE_I:
804  pict_type = AV_PICTURE_TYPE_I;
805  break;
806  case X265_TYPE_P:
807  pict_type = AV_PICTURE_TYPE_P;
808  break;
809  case X265_TYPE_B:
810  case X265_TYPE_BREF:
811  pict_type = AV_PICTURE_TYPE_B;
812  break;
813  default:
814  av_log(avctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
815  return AVERROR_EXTERNAL;
816  }
817 
818 #if X265_BUILD >= 130
819  if (x265pic_out.sliceType == X265_TYPE_B)
820 #else
821  if (x265pic_out.frameData.sliceType == 'b')
822 #endif
824 
825  ff_side_data_set_encoder_stats(pkt, x265pic_out.frameData.qp * FF_QP2LAMBDA, NULL, 0, pict_type);
826 
827  if (x265pic_out.userData) {
828  int idx = (int)(intptr_t)x265pic_out.userData - 1;
829  ReorderedData *rd = &ctx->rd[idx];
830 
831  pkt->duration = rd->duration;
832 
833  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
834  pkt->opaque = rd->frame_opaque;
836  rd->frame_opaque_ref = NULL;
837  }
838 
839  rd_release(ctx, idx);
840  }
841 
842  *got_packet = 1;
843  return 0;
844 }
845 
846 static const enum AVPixelFormat x265_csp_eight[] = {
856 };
857 
858 static const enum AVPixelFormat x265_csp_ten[] = {
873 };
874 
875 static const enum AVPixelFormat x265_csp_twelve[] = {
895 };
896 
898 {
899  if (x265_api_get(12))
900  codec->p.pix_fmts = x265_csp_twelve;
901  else if (x265_api_get(10))
902  codec->p.pix_fmts = x265_csp_ten;
903  else if (x265_api_get(8))
904  codec->p.pix_fmts = x265_csp_eight;
905 }
906 
907 #define OFFSET(x) offsetof(libx265Context, x)
908 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
909 static const AVOption options[] = {
910  { "crf", "set the x265 crf", OFFSET(crf), AV_OPT_TYPE_FLOAT, { .dbl = -1 }, -1, FLT_MAX, VE },
911  { "qp", "set the x265 qp", OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
912  { "forced-idr", "if forcing keyframes, force them as IDR frames", OFFSET(forced_idr),AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
913  { "preset", "set the x265 preset", OFFSET(preset), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
914  { "tune", "set the x265 tune parameter", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
915  { "profile", "set the x265 profile", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
916  { "udu_sei", "Use user data unregistered SEI if available", OFFSET(udu_sei), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
917  { "a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
918  { "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 },
919  { NULL }
920 };
921 
922 static const AVClass class = {
923  .class_name = "libx265",
924  .item_name = av_default_item_name,
925  .option = options,
927 };
928 
929 static const FFCodecDefault x265_defaults[] = {
930  { "b", "0" },
931  { "bf", "-1" },
932  { "g", "-1" },
933  { "keyint_min", "-1" },
934  { "refs", "-1" },
935  { "qmin", "-1" },
936  { "qmax", "-1" },
937  { "qdiff", "-1" },
938  { "qblur", "-1" },
939  { "qcomp", "-1" },
940  { "i_qfactor", "-1" },
941  { "b_qfactor", "-1" },
942  { NULL },
943 };
944 
946  .p.name = "libx265",
947  CODEC_LONG_NAME("libx265 H.265 / HEVC"),
948  .p.type = AVMEDIA_TYPE_VIDEO,
949  .p.id = AV_CODEC_ID_HEVC,
950  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
953  .p.priv_class = &class,
954  .p.wrapper_name = "libx265",
955  .init = libx265_encode_init,
956  .init_static_data = libx265_encode_init_csp,
958  .close = libx265_encode_close,
959  .priv_data_size = sizeof(libx265Context),
961  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
963 };
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:25
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
libx265_param_parse_int
static av_cold int libx265_param_parse_int(AVCodecContext *avctx, const char *key, int value)
Definition: libx265.c:163
libx265_param_parse_float
static av_cold int libx265_param_parse_float(AVCodecContext *avctx, const char *key, float value)
Definition: libx265.c:148
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:2076
libx265Context::forced_idr
int forced_idr
Definition: libx265.c:61
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:858
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:781
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2962
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: avpacket.c:607
libx265Context::params
x265_param * params
Definition: libx265.c:56
AVFrame::nb_side_data
int nb_side_data
Definition: frame.h:609
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:909
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:523
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:102
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
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:487
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
VE
#define VE
Definition: libx265.c:908
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:683
AVPacket::data
uint8_t * data
Definition: packet.h:522
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:628
AVOption
AVOption.
Definition: opt.h:346
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
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
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:127
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:540
ReorderedData::in_use
int in_use
Definition: libx265.c:49
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:596
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:577
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:396
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:65
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:79
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:302
AVFrame::opaque_ref
AVBufferRef * opaque_ref
Frame owner's private data.
Definition: frame.h:742
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:98
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:644
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:97
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:558
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1582
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:897
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:715
libx265Context::a53_cc
int a53_cc
Definition: libx265.c:70
libx265Context::preset
char * preset
Definition: libx265.c:62
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
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:296
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
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
preset
preset
Definition: vf_curves.c:46
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:59
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_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
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:495
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:215
AVCodecContext::nb_decoded_side_data
int nb_decoded_side_data
Definition: avcodec.h:2077
AVDictionaryEntry::key
char * key
Definition: dict.h:90
rd_release
static void rd_release(libx265Context *ctx, int idx)
Definition: libx265.c:124
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:48
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:547
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:269
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
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
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:240
sei.h
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:242
libx265Context::tune
char * tune
Definition: libx265.c:63
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:55
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:44
OFFSET
#define OFFSET(x)
Definition: libx265.c:907
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:649
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:477
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:47
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:121
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:703
libx265Context::udu_sei
int udu_sei
Definition: libx265.c:69
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:521
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:528
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:284
AVRegionOfInterest::right
int right
Definition: frame.h:318
libx265Context::cqp
int cqp
Definition: libx265.c:60
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:238
ReorderedData
Definition: libx265.c:43
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:178
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:59
libx265Context::api
const x265_api * api
Definition: libx265.c:57
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
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:274
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:608
profile
int profile
Definition: mxfenc.c:2226
libx265_encode_set_roi
static av_cold int libx265_encode_set_roi(libx265Context *ctx, const AVFrame *frame, x265_picture *pic)
Definition: libx265.c:564
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:67
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
avcodec.h
libx265Context::rd
ReorderedData * rd
Definition: libx265.c:72
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:290
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:97
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:105
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:235
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:858
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:131
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:945
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:68
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:75
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
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:210
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:73
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
AVCOL_PRI_SMPTE432
@ AVCOL_PRI_SMPTE432
SMPTE ST 432-1 (2010) / P3 D65 / Display P3.
Definition: pixfmt.h:570
ReorderedData::frame_opaque
void * frame_opaque
Definition: libx265.c:46
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:499
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:107
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
libx265Context::nb_rd
int nb_rd
Definition: libx265.c:73
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
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:1106
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:420
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
x265_defaults
static const FFCodecDefault x265_defaults[]
Definition: libx265.c:929
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:879
libx265Context::profile
char * profile
Definition: libx265.c:64
AVDictionaryEntry::value
char * value
Definition: dict.h:91
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:239
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:52
int
int
Definition: ffmpeg_filter.c:410
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:342
AVCOL_SPC_ICTCP
@ AVCOL_SPC_ICTCP
ITU-R BT.2100-0, ICtCp.
Definition: pixfmt.h:625
snprintf
#define snprintf
Definition: snprintf.h:34
x265_csp_eight
static enum AVPixelFormat x265_csp_eight[]
Definition: libx265.c:846
x265_csp_twelve
static enum AVPixelFormat x265_csp_twelve[]
Definition: libx265.c:875
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
is_keyframe
static int is_keyframe(NalUnitType naltype)
Definition: libx265.c:82