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 {
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 #if (X265_BUILD >= 210) && (X265_BUILD < 213)
665  x265_picture x265pic_layers_out[MAX_SCALABLE_LAYERS];
666  x265_picture* x265pic_lyrptr_out[MAX_SCALABLE_LAYERS];
667 #else
668  x265_picture x265pic_solo_out = { 0 };
669 #endif
670  x265_picture* x265pic_out;
671  x265_nal *nal;
672  x265_sei *sei;
673  uint8_t *dst;
674  int pict_type;
675  int payload = 0;
676  int nnal;
677  int ret;
678  int i;
679 
680  ctx->api->picture_init(ctx->params, &x265pic);
681 
682  sei = &x265pic.userSEI;
683  sei->numPayloads = 0;
684 
685  if (pic) {
686  AVFrameSideData *sd;
687  ReorderedData *rd;
688  int rd_idx;
689 
690  for (i = 0; i < 3; i++) {
691  x265pic.planes[i] = pic->data[i];
692  x265pic.stride[i] = pic->linesize[i];
693  }
694 
695  x265pic.pts = pic->pts;
696  x265pic.bitDepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
697 
698  x265pic.sliceType = pic->pict_type == AV_PICTURE_TYPE_I ?
699  (ctx->forced_idr ? X265_TYPE_IDR : X265_TYPE_I) :
700  pic->pict_type == AV_PICTURE_TYPE_P ? X265_TYPE_P :
701  pic->pict_type == AV_PICTURE_TYPE_B ? X265_TYPE_B :
702  X265_TYPE_AUTO;
703 
704  ret = libx265_encode_set_roi(ctx, pic, &x265pic);
705  if (ret < 0)
706  return ret;
707 
708  rd_idx = rd_get(ctx);
709  if (rd_idx < 0) {
710  free_picture(ctx, &x265pic);
711  return rd_idx;
712  }
713  rd = &ctx->rd[rd_idx];
714 
715  rd->duration = pic->duration;
716  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
717  rd->frame_opaque = pic->opaque;
719  if (ret < 0) {
720  rd_release(ctx, rd_idx);
721  free_picture(ctx, &x265pic);
722  return ret;
723  }
724  }
725 
726  x265pic.userData = (void*)(intptr_t)(rd_idx + 1);
727 
728  if (ctx->a53_cc) {
729  void *sei_data;
730  size_t sei_size;
731 
732  ret = ff_alloc_a53_sei(pic, 0, &sei_data, &sei_size);
733  if (ret < 0) {
734  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
735  } else if (sei_data) {
736  void *tmp;
737  x265_sei_payload *sei_payload;
738 
739  tmp = av_fast_realloc(ctx->sei_data,
740  &ctx->sei_data_size,
741  (sei->numPayloads + 1) * sizeof(*sei_payload));
742  if (!tmp) {
743  av_free(sei_data);
744  free_picture(ctx, &x265pic);
745  return AVERROR(ENOMEM);
746  }
747  ctx->sei_data = tmp;
748  sei->payloads = ctx->sei_data;
749  sei_payload = &sei->payloads[sei->numPayloads];
750  sei_payload->payload = sei_data;
751  sei_payload->payloadSize = sei_size;
752  sei_payload->payloadType = SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35;
753  sei->numPayloads++;
754  }
755  }
756 
757  if (ctx->udu_sei) {
758  for (i = 0; i < pic->nb_side_data; i++) {
759  AVFrameSideData *side_data = pic->side_data[i];
760  void *tmp;
761  x265_sei_payload *sei_payload;
762 
763  if (side_data->type != AV_FRAME_DATA_SEI_UNREGISTERED)
764  continue;
765 
766  tmp = av_fast_realloc(ctx->sei_data,
767  &ctx->sei_data_size,
768  (sei->numPayloads + 1) * sizeof(*sei_payload));
769  if (!tmp) {
770  free_picture(ctx, &x265pic);
771  return AVERROR(ENOMEM);
772  }
773  ctx->sei_data = tmp;
774  sei->payloads = ctx->sei_data;
775  sei_payload = &sei->payloads[sei->numPayloads];
776  sei_payload->payload = av_memdup(side_data->data, side_data->size);
777  if (!sei_payload->payload) {
778  free_picture(ctx, &x265pic);
779  return AVERROR(ENOMEM);
780  }
781  sei_payload->payloadSize = side_data->size;
782  /* Equal to libx265 USER_DATA_UNREGISTERED */
783  sei_payload->payloadType = SEI_TYPE_USER_DATA_UNREGISTERED;
784  sei->numPayloads++;
785  }
786  }
787 
788 #if X265_BUILD >= 167
790  if (ctx->dovi.cfg.dv_profile && sd) {
791  const AVDOVIMetadata *metadata = (const AVDOVIMetadata *)sd->data;
792  ret = ff_dovi_rpu_generate(&ctx->dovi, metadata, FF_DOVI_WRAP_NAL,
793  &x265pic.rpu.payload,
794  &x265pic.rpu.payloadSize);
795  if (ret < 0) {
796  free_picture(ctx, &x265pic);
797  return ret;
798  }
799  } else if (ctx->dovi.cfg.dv_profile) {
800  av_log(avctx, AV_LOG_ERROR, "Dolby Vision enabled, but received frame "
801  "without AV_FRAME_DATA_DOVI_METADATA");
802  free_picture(ctx, &x265pic);
803  return AVERROR_INVALIDDATA;
804  }
805 #endif
806  }
807 
808 #if (X265_BUILD >= 210) && (X265_BUILD < 213)
809  for (i = 0; i < MAX_SCALABLE_LAYERS; i++)
810  x265pic_lyrptr_out[i] = &x265pic_layers_out[i];
811 
812  ret = ctx->api->encoder_encode(ctx->encoder, &nal, &nnal,
813  pic ? &x265pic : NULL, x265pic_lyrptr_out);
814 #else
815  ret = ctx->api->encoder_encode(ctx->encoder, &nal, &nnal,
816  pic ? &x265pic : NULL, &x265pic_solo_out);
817 #endif
818 
819  for (i = 0; i < sei->numPayloads; i++)
820  av_free(sei->payloads[i].payload);
821  av_freep(&x265pic.quantOffsets);
822 
823  if (ret < 0)
824  return AVERROR_EXTERNAL;
825 
826  if (!nnal)
827  return 0;
828 
829  for (i = 0; i < nnal; i++)
830  payload += nal[i].sizeBytes;
831 
832  ret = ff_get_encode_buffer(avctx, pkt, payload, 0);
833  if (ret < 0) {
834  av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
835  return ret;
836  }
837  dst = pkt->data;
838 
839  for (i = 0; i < nnal; i++) {
840  memcpy(dst, nal[i].payload, nal[i].sizeBytes);
841  dst += nal[i].sizeBytes;
842 
843  if (is_keyframe(nal[i].type))
845  }
846 
847 #if (X265_BUILD >= 210) && (X265_BUILD < 213)
848  x265pic_out = x265pic_lyrptr_out[0];
849 #else
850  x265pic_out = &x265pic_solo_out;
851 #endif
852 
853  pkt->pts = x265pic_out->pts;
854  pkt->dts = x265pic_out->dts;
855 
856  switch (x265pic_out->sliceType) {
857  case X265_TYPE_IDR:
858  case X265_TYPE_I:
859  pict_type = AV_PICTURE_TYPE_I;
860  break;
861  case X265_TYPE_P:
862  pict_type = AV_PICTURE_TYPE_P;
863  break;
864  case X265_TYPE_B:
865  case X265_TYPE_BREF:
866  pict_type = AV_PICTURE_TYPE_B;
867  break;
868  default:
869  av_log(avctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
870  return AVERROR_EXTERNAL;
871  }
872 
873 #if X265_BUILD >= 130
874  if (x265pic_out->sliceType == X265_TYPE_B)
875 #else
876  if (x265pic_out->frameData.sliceType == 'b')
877 #endif
879 
880  ff_side_data_set_encoder_stats(pkt, x265pic_out->frameData.qp * FF_QP2LAMBDA, NULL, 0, pict_type);
881 
882  if (x265pic_out->userData) {
883  int idx = (int)(intptr_t)x265pic_out->userData - 1;
884  ReorderedData *rd = &ctx->rd[idx];
885 
886  pkt->duration = rd->duration;
887 
888  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
889  pkt->opaque = rd->frame_opaque;
891  rd->frame_opaque_ref = NULL;
892  }
893 
894  rd_release(ctx, idx);
895  }
896 
897  *got_packet = 1;
898  return 0;
899 }
900 
901 static const enum AVPixelFormat x265_csp_eight[] = {
911 };
912 
913 static const enum AVPixelFormat x265_csp_ten[] = {
928 };
929 
930 static const enum AVPixelFormat x265_csp_twelve[] = {
950 };
951 
953  const AVCodec *codec,
954  enum AVCodecConfig config,
955  unsigned flags, const void **out,
956  int *out_num)
957 {
959  if (x265_api_get(12)) {
960  *out = x265_csp_twelve;
961  *out_num = FF_ARRAY_ELEMS(x265_csp_twelve) - 1;
962  } else if (x265_api_get(10)) {
963  *out = x265_csp_ten;
964  *out_num = FF_ARRAY_ELEMS(x265_csp_ten) - 1;
965  } else if (x265_api_get(8)) {
966  *out = x265_csp_eight;
967  *out_num = FF_ARRAY_ELEMS(x265_csp_eight) - 1;
968  } else
969  return AVERROR_EXTERNAL;
970  return 0;
971  }
972 
973  return ff_default_get_supported_config(avctx, codec, config, flags, out, out_num);
974 }
975 
976 #define OFFSET(x) offsetof(libx265Context, x)
977 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
978 static const AVOption options[] = {
979  { "crf", "set the x265 crf", OFFSET(crf), AV_OPT_TYPE_FLOAT, { .dbl = -1 }, -1, FLT_MAX, VE },
980  { "qp", "set the x265 qp", OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
981  { "forced-idr", "if forcing keyframes, force them as IDR frames", OFFSET(forced_idr),AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
982  { "preset", "set the x265 preset", OFFSET(preset), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
983  { "tune", "set the x265 tune parameter", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
984  { "profile", "set the x265 profile", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
985  { "udu_sei", "Use user data unregistered SEI if available", OFFSET(udu_sei), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
986  { "a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
987  { "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 },
988 #if X265_BUILD >= 167
989  { "dolbyvision", "Enable Dolby Vision RPU coding", OFFSET(dovi.enable), AV_OPT_TYPE_BOOL, {.i64 = FF_DOVI_AUTOMATIC }, -1, 1, VE, .unit = "dovi" },
990  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DOVI_AUTOMATIC}, .flags = VE, .unit = "dovi" },
991 #endif
992  { NULL }
993 };
994 
995 static const AVClass class = {
996  .class_name = "libx265",
997  .item_name = av_default_item_name,
998  .option = options,
1000 };
1001 
1002 static const FFCodecDefault x265_defaults[] = {
1003  { "b", "0" },
1004  { "bf", "-1" },
1005  { "g", "-1" },
1006  { "keyint_min", "-1" },
1007  { "refs", "-1" },
1008  { "qmin", "-1" },
1009  { "qmax", "-1" },
1010  { "qdiff", "-1" },
1011  { "qblur", "-1" },
1012  { "qcomp", "-1" },
1013  { "i_qfactor", "-1" },
1014  { "b_qfactor", "-1" },
1015  { NULL },
1016 };
1017 
1019  .p.name = "libx265",
1020  CODEC_LONG_NAME("libx265 H.265 / HEVC"),
1021  .p.type = AVMEDIA_TYPE_VIDEO,
1022  .p.id = AV_CODEC_ID_HEVC,
1023  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1026  .color_ranges = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
1027  .p.priv_class = &class,
1028  .p.wrapper_name = "libx265",
1029  .init = libx265_encode_init,
1030  .get_supported_config = libx265_get_supported_config,
1032  .close = libx265_encode_close,
1033  .priv_data_size = sizeof(libx265Context),
1035  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
1037 };
AVCodec
AVCodec.
Definition: codec.h:187
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:215
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:1030
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:691
AVCodecContext::decoded_side_data
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition: avcodec.h:2087
out
FILE * out
Definition: movenc.c:55
libx265Context::forced_idr
int forced_idr
Definition: libx265.c:63
defaults
static const FFCodecDefault defaults[]
Definition: amfenc_av1.c:603
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:963
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:795
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
libx265Context::params
x265_param * params
Definition: libx265.c:58
AVFrame::nb_side_data
int nb_side_data
Definition: frame.h:623
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:978
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
int64_t
long long int64_t
Definition: coverity.c:34
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:537
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:389
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:501
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:684
VE
#define VE
Definition: libx265.c:977
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:717
AVPacket::data
uint8_t * data
Definition: packet.h:539
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:429
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:614
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:502
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:35
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:641
float.h
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:557
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:613
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:326
AV_CODEC_CONFIG_PIX_FORMAT
@ AV_CODEC_CONFIG_PIX_FORMAT
AVPixelFormat, terminated by AV_PIX_FMT_NONE.
Definition: avcodec.h:2705
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1273
tf_sess_config.config
config
Definition: tf_sess_config.py:33
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:410
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:756
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:566
libx265_get_supported_config
static int libx265_get_supported_config(const AVCodecContext *avctx, const AVCodec *codec, enum AVCodecConfig config, unsigned flags, const void **out, int *out_num)
Definition: libx265.c:952
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:826
FFCodecDefault
Definition: codec_internal.h:97
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
DOVIContext
Definition: dovi_rpu.h:42
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:575
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1593
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:518
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:721
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:508
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:320
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)
Helper wrapper around ff_dovi_configure_ext which infers the codec parameters from an AVCodecContext.
Definition: dovi_rpuenc.c:241
FF_DOVI_AUTOMATIC
#define FF_DOVI_AUTOMATIC
Enable tri-state.
Definition: dovi_rpu.h:49
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:505
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:677
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:209
AVFrameSideData::size
size_t size
Definition: frame.h:268
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:315
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:1330
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:122
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:530
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:337
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:331
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:2088
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:1302
key
const char * key
Definition: hwcontext_opencl.c:189
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:564
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:589
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:271
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
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:483
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1287
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:701
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
ff_dovi_rpu_generate
int ff_dovi_rpu_generate(DOVIContext *s, const AVDOVIMetadata *metadata, int flags, uint8_t **out_rpu, int *out_size)
Synthesize a Dolby Vision RPU reflecting the current state.
Definition: dovi_rpuenc.c:562
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:1259
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:501
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
Underlying C type is AVDictionary*.
Definition: opt.h:290
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:320
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
options
Definition: swscale.c:42
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:976
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:503
av_clipf
av_clipf
Definition: af_crystalizer.c:122
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:858
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:683
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:1258
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:550
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:491
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:1037
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
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
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:507
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:509
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:737
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:538
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:545
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:286
AVRegionOfInterest::right
int right
Definition: frame.h:333
libx265Context::cqp
int cqp
Definition: libx265.c:62
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
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:810
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
Definition: opt.h:271
ReorderedData
Definition: libx265.c:45
AVRegionOfInterest::left
int left
Definition: frame.h:332
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
ff_default_get_supported_config
int ff_default_get_supported_config(const AVCodecContext *avctx, const AVCodec *codec, enum AVCodecConfig config, unsigned flags, const void **out_configs, int *out_num_configs)
Default implementation for avcodec_get_supported_config().
Definition: avcodec.c:757
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:532
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:529
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:330
internal.h
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:519
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:276
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:228
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:708
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:622
profile
int profile
Definition: mxfenc.c:2233
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:643
AVCodecContext::height
int height
Definition: avcodec.h:624
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:663
libx265Context::sei_data
void * sei_data
Definition: libx265.c:69
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:700
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:80
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:292
atsc_a53.h
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:506
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:1280
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVCOL_TRC_ARIB_STD_B67
@ AVCOL_TRC_ARIB_STD_B67
ARIB STD-B67, known as "Hybrid log-gamma".
Definition: pixfmt.h:632
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
FF_DOVI_WRAP_NAL
@ FF_DOVI_WRAP_NAL
wrap inside NAL RBSP
Definition: dovi_rpu.h:158
SEI_TYPE_USER_DATA_UNREGISTERED
@ SEI_TYPE_USER_DATA_UNREGISTERED
Definition: sei.h:35
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1266
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
Underlying C type is int.
Definition: opt.h:259
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:266
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:913
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:582
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:1018
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:801
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:73
mastering_display_metadata.h
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
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:516
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:478
libx265Context::nb_rd
int nb_rd
Definition: libx265.c:75
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
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:1159
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
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
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
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:434
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:609
x265_defaults
static const FFCodecDefault x265_defaults[]
Definition: libx265.c:1002
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:909
libx265Context::profile
char * profile
Definition: libx265.c:66
AVDictionaryEntry::value
char * value
Definition: dict.h:91
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:484
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
libx265Context
Definition: libx265.c:54
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:357
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
snprintf
#define snprintf
Definition: snprintf.h:34
x265_csp_eight
static enum AVPixelFormat x265_csp_eight[]
Definition: libx265.c:901
x265_csp_twelve
static enum AVPixelFormat x265_csp_twelve[]
Definition: libx265.c:930
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:648
AVCodecConfig
AVCodecConfig
Definition: avcodec.h:2704
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