FFmpeg: libavcodec/libx265.c Source File

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"
33 #include "libavutil/common.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 "internal.h"
40 #include "packet_internal.h"
41 #include "atsc_a53.h"
42 #include "sei.h"
43 
44  typedef struct ReorderedData {
45 #if FF_API_REORDERED_OPAQUE
46  int64_t reordered_opaque;
47 #endif
48   int64_t duration;
49 
50   void *frame_opaque;
51   AVBufferRef *frame_opaque_ref;
52 
53   int in_use;
54 } ReorderedData;
55 
56  typedef struct libx265Context {
57   const AVClass *class;
58 
59   x265_encoder *encoder;
60   x265_param *params;
61   const x265_api *api;
62 
63   float crf;
64   int cqp;
65   int forced_idr;
66   char *preset;
67   char *tune;
68   char *profile;
69   AVDictionary *x265_opts;
70 
71   void *sei_data;
72   int sei_data_size;
73   int udu_sei;
74   int a53_cc;
75 
76   ReorderedData *rd;
77   int nb_rd;
78 
79  /**
80  * If the encoder does not support ROI then warn the first time we
81  * encounter a frame with ROI side data.
82  */
83   int roi_warned;
84 } libx265Context;
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 
101  static int rd_get(libx265Context *ctx)
102 {
103  const int add = 16;
104 
105  ReorderedData *tmp;
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 
135  static av_cold int libx265_encode_close(AVCodecContext *avctx)
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  return 0;
150 }
151 
152  static av_cold int libx265_param_parse_float(AVCodecContext *avctx,
153  const char *key, float value)
154 {
155  libx265Context *ctx = avctx->priv_data;
156  char buf[256];
157 
158  snprintf(buf, sizeof(buf), "%2.2f", value);
159  if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
160  av_log(avctx, AV_LOG_ERROR, "Invalid value %2.2f for param \"%s\".\n", value, key);
161  return AVERROR(EINVAL);
162  }
163 
164  return 0;
165 }
166 
167  static av_cold int libx265_param_parse_int(AVCodecContext *avctx,
168  const char *key, int value)
169 {
170  libx265Context *ctx = avctx->priv_data;
171  char buf[256];
172 
173  snprintf(buf, sizeof(buf), "%d", value);
174  if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
175  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for param \"%s\".\n", value, key);
176  return AVERROR(EINVAL);
177  }
178 
179  return 0;
180 }
181 
182  static av_cold int libx265_encode_init(AVCodecContext *avctx)
183 {
184  libx265Context *ctx = avctx->priv_data;
185  AVCPBProperties *cpb_props = NULL;
186  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
187  int ret;
188 
189  ctx->api = x265_api_get(desc->comp[0].depth);
190  if (!ctx->api)
191  ctx->api = x265_api_get(0);
192 
193  ctx->params = ctx->api->param_alloc();
194  if (!ctx->params) {
195  av_log(avctx, AV_LOG_ERROR, "Could not allocate x265 param structure.\n");
196  return AVERROR(ENOMEM);
197  }
198 
199  if (ctx->api->param_default_preset(ctx->params, ctx->preset, ctx->tune) < 0) {
200  int i;
201 
202  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", ctx->preset, ctx->tune);
203  av_log(avctx, AV_LOG_INFO, "Possible presets:");
204  for (i = 0; x265_preset_names[i]; i++)
205  av_log(avctx, AV_LOG_INFO, " %s", x265_preset_names[i]);
206 
207  av_log(avctx, AV_LOG_INFO, "\n");
208  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
209  for (i = 0; x265_tune_names[i]; i++)
210  av_log(avctx, AV_LOG_INFO, " %s", x265_tune_names[i]);
211 
212  av_log(avctx, AV_LOG_INFO, "\n");
213 
214  return AVERROR(EINVAL);
215  }
216 
217  ctx->params->frameNumThreads = avctx->thread_count;
218  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
219  ctx->params->fpsNum = avctx->framerate.num;
220  ctx->params->fpsDenom = avctx->framerate.den;
221  } else {
222  ctx->params->fpsNum = avctx->time_base.den;
223  ctx->params->fpsDenom = avctx->time_base.num * avctx->ticks_per_frame;
224  }
225  ctx->params->sourceWidth = avctx->width;
226  ctx->params->sourceHeight = avctx->height;
227  ctx->params->bEnablePsnr = !!(avctx->flags & AV_CODEC_FLAG_PSNR);
228  ctx->params->bOpenGOP = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
229 
230  /* Tune the CTU size based on input resolution. */
231  if (ctx->params->sourceWidth < 64 || ctx->params->sourceHeight < 64)
232  ctx->params->maxCUSize = 32;
233  if (ctx->params->sourceWidth < 32 || ctx->params->sourceHeight < 32)
234  ctx->params->maxCUSize = 16;
235  if (ctx->params->sourceWidth < 16 || ctx->params->sourceHeight < 16) {
236  av_log(avctx, AV_LOG_ERROR, "Image size is too small (%dx%d).\n",
237  ctx->params->sourceWidth, ctx->params->sourceHeight);
238  return AVERROR(EINVAL);
239  }
240 
241 
242  ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
243 
244  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED)
245  ctx->params->vui.bEnableVideoFullRangeFlag =
246  avctx->color_range == AVCOL_RANGE_JPEG;
247  else
248  ctx->params->vui.bEnableVideoFullRangeFlag =
249  (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
250  avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
251  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
252  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P;
253 
254  if ((avctx->color_primaries <= AVCOL_PRI_SMPTE432 &&
255  avctx->color_primaries != AVCOL_PRI_UNSPECIFIED) ||
256  (avctx->color_trc <= AVCOL_TRC_ARIB_STD_B67 &&
257  avctx->color_trc != AVCOL_TRC_UNSPECIFIED) ||
258  (avctx->colorspace <= AVCOL_SPC_ICTCP &&
259  avctx->colorspace != AVCOL_SPC_UNSPECIFIED)) {
260 
261  ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
262 
263  // x265 validates the parameters internally
264  ctx->params->vui.colorPrimaries = avctx->color_primaries;
265  ctx->params->vui.transferCharacteristics = avctx->color_trc;
266 #if X265_BUILD >= 159
267  if (avctx->color_trc == AVCOL_TRC_ARIB_STD_B67)
268  ctx->params->preferredTransferCharacteristics = ctx->params->vui.transferCharacteristics;
269 #endif
270  ctx->params->vui.matrixCoeffs = avctx->colorspace;
271  }
272 
273  // chroma sample location values are to be ignored in case of non-4:2:0
274  // according to the specification, so we only write them out in case of
275  // 4:2:0 (log2_chroma_{w,h} == 1).
276  ctx->params->vui.bEnableChromaLocInfoPresentFlag =
277  avctx->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED &&
278  desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1;
279 
280  if (ctx->params->vui.bEnableChromaLocInfoPresentFlag) {
281  ctx->params->vui.chromaSampleLocTypeTopField =
282  ctx->params->vui.chromaSampleLocTypeBottomField =
283  avctx->chroma_sample_location - 1;
284  }
285 
286  if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
287  char sar[12];
288  int sar_num, sar_den;
289 
290  av_reduce(&sar_num, &sar_den,
291  avctx->sample_aspect_ratio.num,
292  avctx->sample_aspect_ratio.den, 65535);
293  snprintf(sar, sizeof(sar), "%d:%d", sar_num, sar_den);
294  if (ctx->api->param_parse(ctx->params, "sar", sar) == X265_PARAM_BAD_VALUE) {
295  av_log(avctx, AV_LOG_ERROR, "Invalid SAR: %d:%d.\n", sar_num, sar_den);
296  return AVERROR_INVALIDDATA;
297  }
298  }
299 
300  switch (desc->log2_chroma_w) {
301  // 4:4:4, RGB. gray
302  case 0:
303  // gray
304  if (desc->nb_components == 1) {
305  if (ctx->api->api_build_number < 85) {
306  av_log(avctx, AV_LOG_ERROR,
307  "libx265 version is %d, must be at least 85 for gray encoding.\n",
308  ctx->api->api_build_number);
309  return AVERROR_INVALIDDATA;
310  }
311  ctx->params->internalCsp = X265_CSP_I400;
312  break;
313  }
314 
315  // set identity matrix for RGB
316  if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
317  ctx->params->vui.matrixCoeffs = AVCOL_SPC_RGB;
318  ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
319  ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
320  }
321 
322  ctx->params->internalCsp = X265_CSP_I444;
323  break;
324  // 4:2:0, 4:2:2
325  case 1:
326  ctx->params->internalCsp = desc->log2_chroma_h == 1 ?
327  X265_CSP_I420 : X265_CSP_I422;
328  break;
329  default:
330  av_log(avctx, AV_LOG_ERROR,
331  "Pixel format '%s' cannot be mapped to a libx265 CSP!\n",
332  desc->name);
333  return AVERROR_BUG;
334  }
335 
336  if (ctx->crf >= 0) {
337  char crf[6];
338 
339  snprintf(crf, sizeof(crf), "%2.2f", ctx->crf);
340  if (ctx->api->param_parse(ctx->params, "crf", crf) == X265_PARAM_BAD_VALUE) {
341  av_log(avctx, AV_LOG_ERROR, "Invalid crf: %2.2f.\n", ctx->crf);
342  return AVERROR(EINVAL);
343  }
344  } else if (avctx->bit_rate > 0) {
345  ctx->params->rc.bitrate = avctx->bit_rate / 1000;
346  ctx->params->rc.rateControlMode = X265_RC_ABR;
347  } else if (ctx->cqp >= 0) {
348  ret = libx265_param_parse_int(avctx, "qp", ctx->cqp);
349  if (ret < 0)
350  return ret;
351  }
352 
353  if (avctx->qmin >= 0) {
354  ret = libx265_param_parse_int(avctx, "qpmin", avctx->qmin);
355  if (ret < 0)
356  return ret;
357  }
358  if (avctx->qmax >= 0) {
359  ret = libx265_param_parse_int(avctx, "qpmax", avctx->qmax);
360  if (ret < 0)
361  return ret;
362  }
363  if (avctx->max_qdiff >= 0) {
364  ret = libx265_param_parse_int(avctx, "qpstep", avctx->max_qdiff);
365  if (ret < 0)
366  return ret;
367  }
368  if (avctx->qblur >= 0) {
369  ret = libx265_param_parse_float(avctx, "qblur", avctx->qblur);
370  if (ret < 0)
371  return ret;
372  }
373  if (avctx->qcompress >= 0) {
374  ret = libx265_param_parse_float(avctx, "qcomp", avctx->qcompress);
375  if (ret < 0)
376  return ret;
377  }
378  if (avctx->i_quant_factor >= 0) {
379  ret = libx265_param_parse_float(avctx, "ipratio", avctx->i_quant_factor);
380  if (ret < 0)
381  return ret;
382  }
383  if (avctx->b_quant_factor >= 0) {
384  ret = libx265_param_parse_float(avctx, "pbratio", avctx->b_quant_factor);
385  if (ret < 0)
386  return ret;
387  }
388 
389  ctx->params->rc.vbvBufferSize = avctx->rc_buffer_size / 1000;
390  ctx->params->rc.vbvMaxBitrate = avctx->rc_max_rate / 1000;
391 
392  cpb_props = ff_add_cpb_side_data(avctx);
393  if (!cpb_props)
394  return AVERROR(ENOMEM);
395  cpb_props->buffer_size = ctx->params->rc.vbvBufferSize * 1000;
396  cpb_props->max_bitrate = ctx->params->rc.vbvMaxBitrate * 1000LL;
397  cpb_props->avg_bitrate = ctx->params->rc.bitrate * 1000LL;
398 
399  if (!(avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER))
400  ctx->params->bRepeatHeaders = 1;
401 
402  if (avctx->gop_size >= 0) {
403  ret = libx265_param_parse_int(avctx, "keyint", avctx->gop_size);
404  if (ret < 0)
405  return ret;
406  }
407  if (avctx->keyint_min > 0) {
408  ret = libx265_param_parse_int(avctx, "min-keyint", avctx->keyint_min);
409  if (ret < 0)
410  return ret;
411  }
412  if (avctx->max_b_frames >= 0) {
413  ret = libx265_param_parse_int(avctx, "bframes", avctx->max_b_frames);
414  if (ret < 0)
415  return ret;
416  }
417  if (avctx->refs >= 0) {
418  ret = libx265_param_parse_int(avctx, "ref", avctx->refs);
419  if (ret < 0)
420  return ret;
421  }
422 
423  {
424  AVDictionaryEntry *en = NULL;
425  while ((en = av_dict_get(ctx->x265_opts, "", en, AV_DICT_IGNORE_SUFFIX))) {
426  int parse_ret = ctx->api->param_parse(ctx->params, en->key, en->value);
427 
428  switch (parse_ret) {
429  case X265_PARAM_BAD_NAME:
430  av_log(avctx, AV_LOG_WARNING,
431  "Unknown option: %s.\n", en->key);
432  break;
433  case X265_PARAM_BAD_VALUE:
434  av_log(avctx, AV_LOG_WARNING,
435  "Invalid value for %s: %s.\n", en->key, en->value);
436  break;
437  default:
438  break;
439  }
440  }
441  }
442 
443  if (ctx->params->rc.vbvBufferSize && avctx->rc_initial_buffer_occupancy > 1000 &&
444  ctx->params->rc.vbvBufferInit == 0.9) {
445  ctx->params->rc.vbvBufferInit = (float)avctx->rc_initial_buffer_occupancy / 1000;
446  }
447 
448  if (ctx->profile) {
449  if (ctx->api->param_apply_profile(ctx->params, ctx->profile) < 0) {
450  int i;
451  av_log(avctx, AV_LOG_ERROR, "Invalid or incompatible profile set: %s.\n", ctx->profile);
452  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
453  for (i = 0; x265_profile_names[i]; i++)
454  av_log(avctx, AV_LOG_INFO, " %s", x265_profile_names[i]);
455  av_log(avctx, AV_LOG_INFO, "\n");
456  return AVERROR(EINVAL);
457  }
458  }
459 
460  ctx->encoder = ctx->api->encoder_open(ctx->params);
461  if (!ctx->encoder) {
462  av_log(avctx, AV_LOG_ERROR, "Cannot open libx265 encoder.\n");
463  libx265_encode_close(avctx);
464  return AVERROR_INVALIDDATA;
465  }
466 
467  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
468  x265_nal *nal;
469  int nnal;
470 
471  avctx->extradata_size = ctx->api->encoder_headers(ctx->encoder, &nal, &nnal);
472  if (avctx->extradata_size <= 0) {
473  av_log(avctx, AV_LOG_ERROR, "Cannot encode headers.\n");
474  libx265_encode_close(avctx);
475  return AVERROR_INVALIDDATA;
476  }
477 
478  avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
479  if (!avctx->extradata) {
480  av_log(avctx, AV_LOG_ERROR,
481  "Cannot allocate HEVC header of size %d.\n", avctx->extradata_size);
482  libx265_encode_close(avctx);
483  return AVERROR(ENOMEM);
484  }
485 
486  memcpy(avctx->extradata, nal[0].payload, avctx->extradata_size);
487  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
488  }
489 
490  return 0;
491 }
492 
493  static av_cold int libx265_encode_set_roi(libx265Context *ctx, const AVFrame *frame, x265_picture* pic)
494 {
495  AVFrameSideData *sd = av_frame_get_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST);
496  if (sd) {
497  if (ctx->params->rc.aqMode == X265_AQ_NONE) {
498  if (!ctx->roi_warned) {
499  ctx->roi_warned = 1;
500  av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
501  }
502  } else {
503  /* 8x8 block when qg-size is 8, 16*16 block otherwise. */
504  int mb_size = (ctx->params->rc.qgSize == 8) ? 8 : 16;
505  int mbx = (frame->width + mb_size - 1) / mb_size;
506  int mby = (frame->height + mb_size - 1) / mb_size;
507  int qp_range = 51 + 6 * (pic->bitDepth - 8);
508  int nb_rois;
509  const AVRegionOfInterest *roi;
510  uint32_t roi_size;
511  float *qoffsets; /* will be freed after encode is called. */
512 
513  roi = (const AVRegionOfInterest*)sd->data;
514  roi_size = roi->self_size;
515  if (!roi_size || sd->size % roi_size != 0) {
516  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
517  return AVERROR(EINVAL);
518  }
519  nb_rois = sd->size / roi_size;
520 
521  qoffsets = av_calloc(mbx * mby, sizeof(*qoffsets));
522  if (!qoffsets)
523  return AVERROR(ENOMEM);
524 
525  // This list must be iterated in reverse because the first
526  // region in the list applies when regions overlap.
527  for (int i = nb_rois - 1; i >= 0; i--) {
528  int startx, endx, starty, endy;
529  float qoffset;
530 
531  roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
532 
533  starty = FFMIN(mby, roi->top / mb_size);
534  endy = FFMIN(mby, (roi->bottom + mb_size - 1)/ mb_size);
535  startx = FFMIN(mbx, roi->left / mb_size);
536  endx = FFMIN(mbx, (roi->right + mb_size - 1)/ mb_size);
537 
538  if (roi->qoffset.den == 0) {
539  av_free(qoffsets);
540  av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
541  return AVERROR(EINVAL);
542  }
543  qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
544  qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
545 
546  for (int y = starty; y < endy; y++)
547  for (int x = startx; x < endx; x++)
548  qoffsets[x + y*mbx] = qoffset;
549  }
550 
551  pic->quantOffsets = qoffsets;
552  }
553  }
554  return 0;
555 }
556 
557  static void free_picture(libx265Context *ctx, x265_picture *pic)
558 {
559  x265_sei *sei = &pic->userSEI;
560  for (int i = 0; i < sei->numPayloads; i++)
561  av_free(sei->payloads[i].payload);
562 
563  if (pic->userData) {
564  int idx = (int)(intptr_t)pic->userData - 1;
565  rd_release(ctx, idx);
566  pic->userData = NULL;
567  }
568 
569  av_freep(&pic->quantOffsets);
570  sei->numPayloads = 0;
571 }
572 
573  static int libx265_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
574  const AVFrame *pic, int *got_packet)
575 {
576  libx265Context *ctx = avctx->priv_data;
577  x265_picture x265pic;
578  x265_picture x265pic_out = { 0 };
579  x265_nal *nal;
580  x265_sei *sei;
581  uint8_t *dst;
582  int pict_type;
583  int payload = 0;
584  int nnal;
585  int ret;
586  int i;
587 
588  ctx->api->picture_init(ctx->params, &x265pic);
589 
590  sei = &x265pic.userSEI;
591  sei->numPayloads = 0;
592 
593  if (pic) {
594  ReorderedData *rd;
595  int rd_idx;
596 
597  for (i = 0; i < 3; i++) {
598  x265pic.planes[i] = pic->data[i];
599  x265pic.stride[i] = pic->linesize[i];
600  }
601 
602  x265pic.pts = pic->pts;
603  x265pic.bitDepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
604 
605  x265pic.sliceType = pic->pict_type == AV_PICTURE_TYPE_I ?
606  (ctx->forced_idr ? X265_TYPE_IDR : X265_TYPE_I) :
607  pic->pict_type == AV_PICTURE_TYPE_P ? X265_TYPE_P :
608  pic->pict_type == AV_PICTURE_TYPE_B ? X265_TYPE_B :
609  X265_TYPE_AUTO;
610 
611  ret = libx265_encode_set_roi(ctx, pic, &x265pic);
612  if (ret < 0)
613  return ret;
614 
615  rd_idx = rd_get(ctx);
616  if (rd_idx < 0) {
617  free_picture(ctx, &x265pic);
618  return rd_idx;
619  }
620  rd = &ctx->rd[rd_idx];
621 
622  rd->duration = pic->duration;
623 #if FF_API_REORDERED_OPAQUE
624 FF_DISABLE_DEPRECATION_WARNINGS
625  rd->reordered_opaque = pic->reordered_opaque;
626 FF_ENABLE_DEPRECATION_WARNINGS
627 #endif
628  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
629  rd->frame_opaque = pic->opaque;
630  ret = av_buffer_replace(&rd->frame_opaque_ref, pic->opaque_ref);
631  if (ret < 0) {
632  rd_release(ctx, rd_idx);
633  free_picture(ctx, &x265pic);
634  return ret;
635  }
636  }
637 
638  x265pic.userData = (void*)(intptr_t)(rd_idx + 1);
639 
640  if (ctx->a53_cc) {
641  void *sei_data;
642  size_t sei_size;
643 
644  ret = ff_alloc_a53_sei(pic, 0, &sei_data, &sei_size);
645  if (ret < 0) {
646  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
647  } else if (sei_data) {
648  void *tmp;
649  x265_sei_payload *sei_payload;
650 
651  tmp = av_fast_realloc(ctx->sei_data,
652  &ctx->sei_data_size,
653  (sei->numPayloads + 1) * sizeof(*sei_payload));
654  if (!tmp) {
655  av_free(sei_data);
656  free_picture(ctx, &x265pic);
657  return AVERROR(ENOMEM);
658  }
659  ctx->sei_data = tmp;
660  sei->payloads = ctx->sei_data;
661  sei_payload = &sei->payloads[sei->numPayloads];
662  sei_payload->payload = sei_data;
663  sei_payload->payloadSize = sei_size;
664  sei_payload->payloadType = SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35;
665  sei->numPayloads++;
666  }
667  }
668 
669  if (ctx->udu_sei) {
670  for (i = 0; i < pic->nb_side_data; i++) {
671  AVFrameSideData *side_data = pic->side_data[i];
672  void *tmp;
673  x265_sei_payload *sei_payload;
674 
675  if (side_data->type != AV_FRAME_DATA_SEI_UNREGISTERED)
676  continue;
677 
678  tmp = av_fast_realloc(ctx->sei_data,
679  &ctx->sei_data_size,
680  (sei->numPayloads + 1) * sizeof(*sei_payload));
681  if (!tmp) {
682  free_picture(ctx, &x265pic);
683  return AVERROR(ENOMEM);
684  }
685  ctx->sei_data = tmp;
686  sei->payloads = ctx->sei_data;
687  sei_payload = &sei->payloads[sei->numPayloads];
688  sei_payload->payload = av_memdup(side_data->data, side_data->size);
689  if (!sei_payload->payload) {
690  free_picture(ctx, &x265pic);
691  return AVERROR(ENOMEM);
692  }
693  sei_payload->payloadSize = side_data->size;
694  /* Equal to libx265 USER_DATA_UNREGISTERED */
695  sei_payload->payloadType = SEI_TYPE_USER_DATA_UNREGISTERED;
696  sei->numPayloads++;
697  }
698  }
699  }
700 
701  ret = ctx->api->encoder_encode(ctx->encoder, &nal, &nnal,
702  pic ? &x265pic : NULL, &x265pic_out);
703 
704  for (i = 0; i < sei->numPayloads; i++)
705  av_free(sei->payloads[i].payload);
706  av_freep(&x265pic.quantOffsets);
707 
708  if (ret < 0)
709  return AVERROR_EXTERNAL;
710 
711  if (!nnal)
712  return 0;
713 
714  for (i = 0; i < nnal; i++)
715  payload += nal[i].sizeBytes;
716 
717  ret = ff_get_encode_buffer(avctx, pkt, payload, 0);
718  if (ret < 0) {
719  av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
720  return ret;
721  }
722  dst = pkt->data;
723 
724  for (i = 0; i < nnal; i++) {
725  memcpy(dst, nal[i].payload, nal[i].sizeBytes);
726  dst += nal[i].sizeBytes;
727 
728  if (is_keyframe(nal[i].type))
729  pkt->flags |= AV_PKT_FLAG_KEY;
730  }
731 
732  pkt->pts = x265pic_out.pts;
733  pkt->dts = x265pic_out.dts;
734 
735  switch (x265pic_out.sliceType) {
736  case X265_TYPE_IDR:
737  case X265_TYPE_I:
738  pict_type = AV_PICTURE_TYPE_I;
739  break;
740  case X265_TYPE_P:
741  pict_type = AV_PICTURE_TYPE_P;
742  break;
743  case X265_TYPE_B:
744  case X265_TYPE_BREF:
745  pict_type = AV_PICTURE_TYPE_B;
746  break;
747  default:
748  av_log(avctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
749  return AVERROR_EXTERNAL;
750  }
751 
752 #if X265_BUILD >= 130
753  if (x265pic_out.sliceType == X265_TYPE_B)
754 #else
755  if (x265pic_out.frameData.sliceType == 'b')
756 #endif
757  pkt->flags |= AV_PKT_FLAG_DISPOSABLE;
758 
759  ff_side_data_set_encoder_stats(pkt, x265pic_out.frameData.qp * FF_QP2LAMBDA, NULL, 0, pict_type);
760 
761  if (x265pic_out.userData) {
762  int idx = (int)(intptr_t)x265pic_out.userData - 1;
763  ReorderedData *rd = &ctx->rd[idx];
764 
765 #if FF_API_REORDERED_OPAQUE
766 FF_DISABLE_DEPRECATION_WARNINGS
767  avctx->reordered_opaque = rd->reordered_opaque;
768 FF_ENABLE_DEPRECATION_WARNINGS
769 #endif
770  pkt->duration = rd->duration;
771 
772  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
773  pkt->opaque = rd->frame_opaque;
774  pkt->opaque_ref = rd->frame_opaque_ref;
775  rd->frame_opaque_ref = NULL;
776  }
777 
778  rd_release(ctx, idx);
779  }
780 #if FF_API_REORDERED_OPAQUE
781  else {
782 FF_DISABLE_DEPRECATION_WARNINGS
783  avctx->reordered_opaque = 0;
784 FF_ENABLE_DEPRECATION_WARNINGS
785  }
786 #endif
787 
788  *got_packet = 1;
789  return 0;
790 }
791 
792  static const enum AVPixelFormat x265_csp_eight[] = {
793  AV_PIX_FMT_YUV420P,
794  AV_PIX_FMT_YUVJ420P,
795  AV_PIX_FMT_YUV422P,
796  AV_PIX_FMT_YUVJ422P,
797  AV_PIX_FMT_YUV444P,
798  AV_PIX_FMT_YUVJ444P,
799  AV_PIX_FMT_GBRP,
800  AV_PIX_FMT_GRAY8,
801  AV_PIX_FMT_NONE
802 };
803 
804  static const enum AVPixelFormat x265_csp_ten[] = {
805  AV_PIX_FMT_YUV420P,
806  AV_PIX_FMT_YUVJ420P,
807  AV_PIX_FMT_YUV422P,
808  AV_PIX_FMT_YUVJ422P,
809  AV_PIX_FMT_YUV444P,
810  AV_PIX_FMT_YUVJ444P,
811  AV_PIX_FMT_GBRP,
812  AV_PIX_FMT_YUV420P10,
813  AV_PIX_FMT_YUV422P10,
814  AV_PIX_FMT_YUV444P10,
815  AV_PIX_FMT_GBRP10,
816  AV_PIX_FMT_GRAY8,
817  AV_PIX_FMT_GRAY10,
818  AV_PIX_FMT_NONE
819 };
820 
821  static const enum AVPixelFormat x265_csp_twelve[] = {
822  AV_PIX_FMT_YUV420P,
823  AV_PIX_FMT_YUVJ420P,
824  AV_PIX_FMT_YUV422P,
825  AV_PIX_FMT_YUVJ422P,
826  AV_PIX_FMT_YUV444P,
827  AV_PIX_FMT_YUVJ444P,
828  AV_PIX_FMT_GBRP,
829  AV_PIX_FMT_YUV420P10,
830  AV_PIX_FMT_YUV422P10,
831  AV_PIX_FMT_YUV444P10,
832  AV_PIX_FMT_GBRP10,
833  AV_PIX_FMT_YUV420P12,
834  AV_PIX_FMT_YUV422P12,
835  AV_PIX_FMT_YUV444P12,
836  AV_PIX_FMT_GBRP12,
837  AV_PIX_FMT_GRAY8,
838  AV_PIX_FMT_GRAY10,
839  AV_PIX_FMT_GRAY12,
840  AV_PIX_FMT_NONE
841 };
842 
843  static av_cold void libx265_encode_init_csp(FFCodec *codec)
844 {
845  if (x265_api_get(12))
846  codec->p.pix_fmts = x265_csp_twelve;
847  else if (x265_api_get(10))
848  codec->p.pix_fmts = x265_csp_ten;
849  else if (x265_api_get(8))
850  codec->p.pix_fmts = x265_csp_eight;
851 }
852 
853  #define OFFSET(x) offsetof(libx265Context, x)
854  #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
855  static const AVOption options[] = {
856  { "crf", "set the x265 crf", OFFSET(crf), AV_OPT_TYPE_FLOAT, { .dbl = -1 }, -1, FLT_MAX, VE },
857  { "qp", "set the x265 qp", OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
858  { "forced-idr", "if forcing keyframes, force them as IDR frames", OFFSET(forced_idr),AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
859  { "preset", "set the x265 preset", OFFSET(preset), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
860  { "tune", "set the x265 tune parameter", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
861  { "profile", "set the x265 profile", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
862  { "udu_sei", "Use user data unregistered SEI if available", OFFSET(udu_sei), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
863  { "a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
864  { "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 },
865  { NULL }
866 };
867 
868 static const AVClass class = {
869   .class_name = "libx265",
870   .item_name = av_default_item_name,
871   .option = options,
872   .version = LIBAVUTIL_VERSION_INT,
873 };
874 
875  static const FFCodecDefault x265_defaults[] = {
876  { "b", "0" },
877  { "bf", "-1" },
878  { "g", "-1" },
879  { "keyint_min", "-1" },
880  { "refs", "-1" },
881  { "qmin", "-1" },
882  { "qmax", "-1" },
883  { "qdiff", "-1" },
884  { "qblur", "-1" },
885  { "qcomp", "-1" },
886  { "i_qfactor", "-1" },
887  { "b_qfactor", "-1" },
888  { NULL },
889 };
890 
891  FFCodec ff_libx265_encoder = {
892  .p.name = "libx265",
893  CODEC_LONG_NAME("libx265 H.265 / HEVC"),
894  .p.type = AVMEDIA_TYPE_VIDEO,
895  .p.id = AV_CODEC_ID_HEVC,
896  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
897  AV_CODEC_CAP_OTHER_THREADS |
898  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
899  .p.priv_class = &class,
900  .p.wrapper_name = "libx265",
901  .init = libx265_encode_init,
902  .init_static_data = libx265_encode_init_csp,
903  FF_CODEC_ENCODE_CB(libx265_encode_frame),
904  .close = libx265_encode_close,
905  .priv_data_size = sizeof(libx265Context),
906  .defaults = x265_defaults,
907  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
908  FF_CODEC_CAP_AUTO_THREADS,
909 };
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
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
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AVCodecContext::keyint_min
int keyint_min
minimum GOP size
Definition: avcodec.h:967
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:167
libx265_param_parse_float
static av_cold int libx265_param_parse_float(AVCodecContext *avctx, const char *key, float value)
Definition: libx265.c:152
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1002
libx265Context::forced_idr
int forced_idr
Definition: libx265.c:65
defaults
static const FFCodecDefault defaults[]
Definition: amfenc_av1.c:327
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:682
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:728
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2888
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:602
libx265Context::params
x265_param * params
Definition: libx265.c:60
AVFrame::nb_side_data
int nb_side_data
Definition: frame.h:560
options
static const AVOption options[]
Definition: libx265.c:855
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:206
AVFrame::opaque
void * opaque
for some private data of the user
Definition: frame.h:475
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
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:437
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:995
VE
#define VE
Definition: libx265.c:854
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:661
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
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:557
AVOption
AVOption.
Definition: opt.h:251
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:561
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:459
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:588
float.h
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
ReorderedData::in_use
int in_use
Definition: libx265.c:53
AVDictionary
Definition: dict.c:32
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:448
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:305
ff_add_cpb_side_data
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1028
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1225
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:351
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:317
libx265Context::x265_opts
AVDictionary * x265_opts
Definition: libx265.c:69
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:83
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
AVBufferRef for free use by the API user.
Definition: frame.h:689
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1750
libx265_encode_frame
static int libx265_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
Definition: libx265.c:573
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:278
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:730
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:410
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1502
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:475
libx265_encode_init_csp
static av_cold void libx265_encode_init_csp(FFCodec *codec)
Definition: libx265.c:843
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:974
libx265Context::a53_cc
int a53_cc
Definition: libx265.c:74
libx265Context::preset
char * preset
Definition: libx265.c:66
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:506
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:315
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:462
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:988
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:239
av_cold
#define av_cold
Definition: attributes.h:90
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:255
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:1282
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:60
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:79
float
float
Definition: af_crystalizer.c:122
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:528
AVFrame::reordered_opaque
attribute_deprecated int64_t reordered_opaque
reordered opaque 64 bits (generally an integer or a double precision float PTS but can be anything).
Definition: frame.h:510
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
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:271
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:215
AVDictionaryEntry::key
char * key
Definition: dict.h:90
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:557
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:121
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:156
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1254
key
const char * key
Definition: hwcontext_opencl.c:174
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:399
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:536
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:126
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:80
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:440
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1239
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:1009
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
AVCodecContext::qblur
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:1211
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:78
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:476
libx265_encode_init
static av_cold int libx265_encode_init(AVCodecContext *avctx)
Definition: libx265.c:182
sei.h
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:232
libx265Context::tune
char * tune
Definition: libx265.c:67
AVRegionOfInterest::self_size
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:260
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:274
libx265Context::encoder
x265_encoder * encoder
Definition: libx265.c:59
ReorderedData::duration
int64_t duration
Definition: libx265.c:48
OFFSET
#define OFFSET(x)
Definition: libx265.c:853
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:460
av_clipf
av_clipf
Definition: af_crystalizer.c:122
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:825
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:627
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:1210
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:548
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:427
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:620
codec_internal.h
ReorderedData::frame_opaque_ref
AVBufferRef * frame_opaque_ref
Definition: libx265.c:51
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_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:464
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:466
AVFrameSideData::data
uint8_t * data
Definition: frame.h:238
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:681
libx265Context::udu_sei
int udu_sei
Definition: libx265.c:73
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:373
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:380
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:141
AVRegionOfInterest::right
int right
Definition: frame.h:273
libx265Context::cqp
int cqp
Definition: libx265.c:64
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:706
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
ReorderedData
Definition: libx265.c:44
AVRegionOfInterest::left
int left
Definition: frame.h:272
libx265Context::crf
float crf
Definition: libx265.c:63
libx265Context::api
const x265_api * api
Definition: libx265.c:61
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:527
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:270
internal.h
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:476
common.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:131
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:191
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:1016
AVFrame::side_data
AVFrameSideData ** side_data
Definition: frame.h:559
profile
int profile
Definition: mxfenc.c:2009
libx265_encode_set_roi
static av_cold int libx265_encode_set_roi(libx265Context *ctx, const AVFrame *frame, x265_picture *pic)
Definition: libx265.c:493
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:590
AVCodecContext::height
int height
Definition: avcodec.h:598
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:635
libx265Context::sei_data
void * sei_data
Definition: libx265.c:71
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
avcodec.h
libx265Context::rd
ReorderedData * rd
Definition: libx265.c:76
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:331
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:147
atsc_a53.h
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:463
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:1232
AVCodecContext
main external API structure.
Definition: avcodec.h:426
AVCOL_TRC_ARIB_STD_B67
@ AVCOL_TRC_ARIB_STD_B67
ARIB STD-B67, known as "Hybrid log-gamma".
Definition: pixfmt.h:579
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
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:79
SEI_TYPE_USER_DATA_UNREGISTERED
@ SEI_TYPE_USER_DATA_UNREGISTERED
Definition: sei.h:35
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1218
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:237
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:804
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
ff_libx265_encoder
FFCodec ff_libx265_encoder
Definition: libx265.c:891
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:71
libx265Context::sei_data_size
int sei_data_size
Definition: libx265.c:72
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
desc
const char * desc
Definition: libsvtav1.c:83
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
add
static float add(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:35
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:70
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:697
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
packet_internal.h
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:73
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:236
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:548
ReorderedData::frame_opaque
void * frame_opaque
Definition: libx265.c:50
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:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:453
libx265Context::nb_rd
int nb_rd
Definition: libx265.c:77
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:598
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:375
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:875
libx265Context::profile
char * profile
Definition: libx265.c:68
AVDictionaryEntry::value
char * value
Definition: dict.h:91
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:441
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
libx265Context
Definition: libx265.c:56
int
int
Definition: ffmpeg_filter.c:156
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:297
AVCOL_SPC_ICTCP
@ AVCOL_SPC_ICTCP
ITU-R BT.2100-0, ICtCp.
Definition: pixfmt.h:603
snprintf
#define snprintf
Definition: snprintf.h:34
x265_csp_eight
static enum AVPixelFormat x265_csp_eight[]
Definition: libx265.c:792
x265_csp_twelve
static enum AVPixelFormat x265_csp_twelve[]
Definition: libx265.c:821
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:795
is_keyframe
static int is_keyframe(NalUnitType naltype)
Definition: libx265.c:86
Generated on Tue Feb 28 2023 21:33:22 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /