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/internal.h"
31 #include "libavutil/common.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "avcodec.h"
35 #include "codec_internal.h"
36 #include "encode.h"
37 #include "internal.h"
38 #include "packet_internal.h"
39 #include "sei.h"
40 
41 typedef struct libx265Context {
42  const AVClass *class;
43 
44  x265_encoder *encoder;
45  x265_param *params;
46  const x265_api *api;
47 
48  float crf;
49  int cqp;
51  char *preset;
52  char *tune;
53  char *profile;
55 
56  void *sei_data;
58  int udu_sei;
59 
60  /**
61  * If the encoder does not support ROI then warn the first time we
62  * encounter a frame with ROI side data.
63  */
66 
67 static int is_keyframe(NalUnitType naltype)
68 {
69  switch (naltype) {
70  case NAL_UNIT_CODED_SLICE_BLA_W_LP:
71  case NAL_UNIT_CODED_SLICE_BLA_W_RADL:
72  case NAL_UNIT_CODED_SLICE_BLA_N_LP:
73  case NAL_UNIT_CODED_SLICE_IDR_W_RADL:
74  case NAL_UNIT_CODED_SLICE_IDR_N_LP:
75  case NAL_UNIT_CODED_SLICE_CRA:
76  return 1;
77  default:
78  return 0;
79  }
80 }
81 
83 {
84  libx265Context *ctx = avctx->priv_data;
85 
86  ctx->api->param_free(ctx->params);
87  av_freep(&ctx->sei_data);
88 
89  if (ctx->encoder)
90  ctx->api->encoder_close(ctx->encoder);
91 
92  return 0;
93 }
94 
96  const char *key, float value)
97 {
98  libx265Context *ctx = avctx->priv_data;
99  char buf[256];
100 
101  snprintf(buf, sizeof(buf), "%2.2f", value);
102  if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
103  av_log(avctx, AV_LOG_ERROR, "Invalid value %2.2f for param \"%s\".\n", value, key);
104  return AVERROR(EINVAL);
105  }
106 
107  return 0;
108 }
109 
111  const char *key, int value)
112 {
113  libx265Context *ctx = avctx->priv_data;
114  char buf[256];
115 
116  snprintf(buf, sizeof(buf), "%d", value);
117  if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
118  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for param \"%s\".\n", value, key);
119  return AVERROR(EINVAL);
120  }
121 
122  return 0;
123 }
124 
126 {
127  libx265Context *ctx = avctx->priv_data;
128  AVCPBProperties *cpb_props = NULL;
130  int ret;
131 
132  ctx->api = x265_api_get(desc->comp[0].depth);
133  if (!ctx->api)
134  ctx->api = x265_api_get(0);
135 
136  ctx->params = ctx->api->param_alloc();
137  if (!ctx->params) {
138  av_log(avctx, AV_LOG_ERROR, "Could not allocate x265 param structure.\n");
139  return AVERROR(ENOMEM);
140  }
141 
142  if (ctx->api->param_default_preset(ctx->params, ctx->preset, ctx->tune) < 0) {
143  int i;
144 
145  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", ctx->preset, ctx->tune);
146  av_log(avctx, AV_LOG_INFO, "Possible presets:");
147  for (i = 0; x265_preset_names[i]; i++)
148  av_log(avctx, AV_LOG_INFO, " %s", x265_preset_names[i]);
149 
150  av_log(avctx, AV_LOG_INFO, "\n");
151  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
152  for (i = 0; x265_tune_names[i]; i++)
153  av_log(avctx, AV_LOG_INFO, " %s", x265_tune_names[i]);
154 
155  av_log(avctx, AV_LOG_INFO, "\n");
156 
157  return AVERROR(EINVAL);
158  }
159 
160  ctx->params->frameNumThreads = avctx->thread_count;
161  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
162  ctx->params->fpsNum = avctx->framerate.num;
163  ctx->params->fpsDenom = avctx->framerate.den;
164  } else {
165  ctx->params->fpsNum = avctx->time_base.den;
166  ctx->params->fpsDenom = avctx->time_base.num * avctx->ticks_per_frame;
167  }
168  ctx->params->sourceWidth = avctx->width;
169  ctx->params->sourceHeight = avctx->height;
170  ctx->params->bEnablePsnr = !!(avctx->flags & AV_CODEC_FLAG_PSNR);
171  ctx->params->bOpenGOP = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
172 
173  /* Tune the CTU size based on input resolution. */
174  if (ctx->params->sourceWidth < 64 || ctx->params->sourceHeight < 64)
175  ctx->params->maxCUSize = 32;
176  if (ctx->params->sourceWidth < 32 || ctx->params->sourceHeight < 32)
177  ctx->params->maxCUSize = 16;
178  if (ctx->params->sourceWidth < 16 || ctx->params->sourceHeight < 16) {
179  av_log(avctx, AV_LOG_ERROR, "Image size is too small (%dx%d).\n",
180  ctx->params->sourceWidth, ctx->params->sourceHeight);
181  return AVERROR(EINVAL);
182  }
183 
184 
185  ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
186 
187  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED)
188  ctx->params->vui.bEnableVideoFullRangeFlag =
189  avctx->color_range == AVCOL_RANGE_JPEG;
190  else
191  ctx->params->vui.bEnableVideoFullRangeFlag =
192  (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
193  avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
194  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
195  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P;
196 
197  if ((avctx->color_primaries <= AVCOL_PRI_SMPTE432 &&
199  (avctx->color_trc <= AVCOL_TRC_ARIB_STD_B67 &&
200  avctx->color_trc != AVCOL_TRC_UNSPECIFIED) ||
201  (avctx->colorspace <= AVCOL_SPC_ICTCP &&
202  avctx->colorspace != AVCOL_SPC_UNSPECIFIED)) {
203 
204  ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
205 
206  // x265 validates the parameters internally
207  ctx->params->vui.colorPrimaries = avctx->color_primaries;
208  ctx->params->vui.transferCharacteristics = avctx->color_trc;
209 #if X265_BUILD >= 159
210  if (avctx->color_trc == AVCOL_TRC_ARIB_STD_B67)
211  ctx->params->preferredTransferCharacteristics = ctx->params->vui.transferCharacteristics;
212 #endif
213  ctx->params->vui.matrixCoeffs = avctx->colorspace;
214  }
215 
216  // chroma sample location values are to be ignored in case of non-4:2:0
217  // according to the specification, so we only write them out in case of
218  // 4:2:0 (log2_chroma_{w,h} == 1).
219  ctx->params->vui.bEnableChromaLocInfoPresentFlag =
221  desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1;
222 
223  if (ctx->params->vui.bEnableChromaLocInfoPresentFlag) {
224  ctx->params->vui.chromaSampleLocTypeTopField =
225  ctx->params->vui.chromaSampleLocTypeBottomField =
226  avctx->chroma_sample_location - 1;
227  }
228 
229  if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
230  char sar[12];
231  int sar_num, sar_den;
232 
233  av_reduce(&sar_num, &sar_den,
234  avctx->sample_aspect_ratio.num,
235  avctx->sample_aspect_ratio.den, 65535);
236  snprintf(sar, sizeof(sar), "%d:%d", sar_num, sar_den);
237  if (ctx->api->param_parse(ctx->params, "sar", sar) == X265_PARAM_BAD_VALUE) {
238  av_log(avctx, AV_LOG_ERROR, "Invalid SAR: %d:%d.\n", sar_num, sar_den);
239  return AVERROR_INVALIDDATA;
240  }
241  }
242 
243  switch (desc->log2_chroma_w) {
244  // 4:4:4, RGB. gray
245  case 0:
246  // gray
247  if (desc->nb_components == 1) {
248  if (ctx->api->api_build_number < 85) {
249  av_log(avctx, AV_LOG_ERROR,
250  "libx265 version is %d, must be at least 85 for gray encoding.\n",
251  ctx->api->api_build_number);
252  return AVERROR_INVALIDDATA;
253  }
254  ctx->params->internalCsp = X265_CSP_I400;
255  break;
256  }
257 
258  // set identity matrix for RGB
259  if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
260  ctx->params->vui.matrixCoeffs = AVCOL_SPC_RGB;
261  ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
262  ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
263  }
264 
265  ctx->params->internalCsp = X265_CSP_I444;
266  break;
267  // 4:2:0, 4:2:2
268  case 1:
269  ctx->params->internalCsp = desc->log2_chroma_h == 1 ?
270  X265_CSP_I420 : X265_CSP_I422;
271  break;
272  default:
273  av_log(avctx, AV_LOG_ERROR,
274  "Pixel format '%s' cannot be mapped to a libx265 CSP!\n",
275  desc->name);
276  return AVERROR_BUG;
277  }
278 
279  if (ctx->crf >= 0) {
280  char crf[6];
281 
282  snprintf(crf, sizeof(crf), "%2.2f", ctx->crf);
283  if (ctx->api->param_parse(ctx->params, "crf", crf) == X265_PARAM_BAD_VALUE) {
284  av_log(avctx, AV_LOG_ERROR, "Invalid crf: %2.2f.\n", ctx->crf);
285  return AVERROR(EINVAL);
286  }
287  } else if (avctx->bit_rate > 0) {
288  ctx->params->rc.bitrate = avctx->bit_rate / 1000;
289  ctx->params->rc.rateControlMode = X265_RC_ABR;
290  } else if (ctx->cqp >= 0) {
291  ret = libx265_param_parse_int(avctx, "qp", ctx->cqp);
292  if (ret < 0)
293  return ret;
294  }
295 
296 #if X265_BUILD >= 89
297  if (avctx->qmin >= 0) {
298  ret = libx265_param_parse_int(avctx, "qpmin", avctx->qmin);
299  if (ret < 0)
300  return ret;
301  }
302  if (avctx->qmax >= 0) {
303  ret = libx265_param_parse_int(avctx, "qpmax", avctx->qmax);
304  if (ret < 0)
305  return ret;
306  }
307 #endif
308  if (avctx->max_qdiff >= 0) {
309  ret = libx265_param_parse_int(avctx, "qpstep", avctx->max_qdiff);
310  if (ret < 0)
311  return ret;
312  }
313  if (avctx->qblur >= 0) {
314  ret = libx265_param_parse_float(avctx, "qblur", avctx->qblur);
315  if (ret < 0)
316  return ret;
317  }
318  if (avctx->qcompress >= 0) {
319  ret = libx265_param_parse_float(avctx, "qcomp", avctx->qcompress);
320  if (ret < 0)
321  return ret;
322  }
323  if (avctx->i_quant_factor >= 0) {
324  ret = libx265_param_parse_float(avctx, "ipratio", avctx->i_quant_factor);
325  if (ret < 0)
326  return ret;
327  }
328  if (avctx->b_quant_factor >= 0) {
329  ret = libx265_param_parse_float(avctx, "pbratio", avctx->b_quant_factor);
330  if (ret < 0)
331  return ret;
332  }
333 
334  ctx->params->rc.vbvBufferSize = avctx->rc_buffer_size / 1000;
335  ctx->params->rc.vbvMaxBitrate = avctx->rc_max_rate / 1000;
336 
337  cpb_props = ff_add_cpb_side_data(avctx);
338  if (!cpb_props)
339  return AVERROR(ENOMEM);
340  cpb_props->buffer_size = ctx->params->rc.vbvBufferSize * 1000;
341  cpb_props->max_bitrate = ctx->params->rc.vbvMaxBitrate * 1000LL;
342  cpb_props->avg_bitrate = ctx->params->rc.bitrate * 1000LL;
343 
344  if (!(avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER))
345  ctx->params->bRepeatHeaders = 1;
346 
347  if (avctx->gop_size >= 0) {
348  ret = libx265_param_parse_int(avctx, "keyint", avctx->gop_size);
349  if (ret < 0)
350  return ret;
351  }
352  if (avctx->keyint_min > 0) {
353  ret = libx265_param_parse_int(avctx, "min-keyint", avctx->keyint_min);
354  if (ret < 0)
355  return ret;
356  }
357  if (avctx->max_b_frames >= 0) {
358  ret = libx265_param_parse_int(avctx, "bframes", avctx->max_b_frames);
359  if (ret < 0)
360  return ret;
361  }
362  if (avctx->refs >= 0) {
363  ret = libx265_param_parse_int(avctx, "ref", avctx->refs);
364  if (ret < 0)
365  return ret;
366  }
367 
368  {
369  AVDictionaryEntry *en = NULL;
370  while ((en = av_dict_get(ctx->x265_opts, "", en, AV_DICT_IGNORE_SUFFIX))) {
371  int parse_ret = ctx->api->param_parse(ctx->params, en->key, en->value);
372 
373  switch (parse_ret) {
374  case X265_PARAM_BAD_NAME:
375  av_log(avctx, AV_LOG_WARNING,
376  "Unknown option: %s.\n", en->key);
377  break;
378  case X265_PARAM_BAD_VALUE:
379  av_log(avctx, AV_LOG_WARNING,
380  "Invalid value for %s: %s.\n", en->key, en->value);
381  break;
382  default:
383  break;
384  }
385  }
386  }
387 
388  if (ctx->params->rc.vbvBufferSize && avctx->rc_initial_buffer_occupancy > 1000 &&
389  ctx->params->rc.vbvBufferInit == 0.9) {
390  ctx->params->rc.vbvBufferInit = (float)avctx->rc_initial_buffer_occupancy / 1000;
391  }
392 
393  if (ctx->profile) {
394  if (ctx->api->param_apply_profile(ctx->params, ctx->profile) < 0) {
395  int i;
396  av_log(avctx, AV_LOG_ERROR, "Invalid or incompatible profile set: %s.\n", ctx->profile);
397  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
398  for (i = 0; x265_profile_names[i]; i++)
399  av_log(avctx, AV_LOG_INFO, " %s", x265_profile_names[i]);
400  av_log(avctx, AV_LOG_INFO, "\n");
401  return AVERROR(EINVAL);
402  }
403  }
404 
405  ctx->encoder = ctx->api->encoder_open(ctx->params);
406  if (!ctx->encoder) {
407  av_log(avctx, AV_LOG_ERROR, "Cannot open libx265 encoder.\n");
408  libx265_encode_close(avctx);
409  return AVERROR_INVALIDDATA;
410  }
411 
412  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
413  x265_nal *nal;
414  int nnal;
415 
416  avctx->extradata_size = ctx->api->encoder_headers(ctx->encoder, &nal, &nnal);
417  if (avctx->extradata_size <= 0) {
418  av_log(avctx, AV_LOG_ERROR, "Cannot encode headers.\n");
419  libx265_encode_close(avctx);
420  return AVERROR_INVALIDDATA;
421  }
422 
424  if (!avctx->extradata) {
425  av_log(avctx, AV_LOG_ERROR,
426  "Cannot allocate HEVC header of size %d.\n", avctx->extradata_size);
427  libx265_encode_close(avctx);
428  return AVERROR(ENOMEM);
429  }
430 
431  memcpy(avctx->extradata, nal[0].payload, avctx->extradata_size);
432  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
433  }
434 
435  return 0;
436 }
437 
438 static av_cold int libx265_encode_set_roi(libx265Context *ctx, const AVFrame *frame, x265_picture* pic)
439 {
441  if (sd) {
442  if (ctx->params->rc.aqMode == X265_AQ_NONE) {
443  if (!ctx->roi_warned) {
444  ctx->roi_warned = 1;
445  av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
446  }
447  } else {
448  /* 8x8 block when qg-size is 8, 16*16 block otherwise. */
449  int mb_size = (ctx->params->rc.qgSize == 8) ? 8 : 16;
450  int mbx = (frame->width + mb_size - 1) / mb_size;
451  int mby = (frame->height + mb_size - 1) / mb_size;
452  int qp_range = 51 + 6 * (pic->bitDepth - 8);
453  int nb_rois;
454  const AVRegionOfInterest *roi;
455  uint32_t roi_size;
456  float *qoffsets; /* will be freed after encode is called. */
457 
458  roi = (const AVRegionOfInterest*)sd->data;
459  roi_size = roi->self_size;
460  if (!roi_size || sd->size % roi_size != 0) {
461  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
462  return AVERROR(EINVAL);
463  }
464  nb_rois = sd->size / roi_size;
465 
466  qoffsets = av_calloc(mbx * mby, sizeof(*qoffsets));
467  if (!qoffsets)
468  return AVERROR(ENOMEM);
469 
470  // This list must be iterated in reverse because the first
471  // region in the list applies when regions overlap.
472  for (int i = nb_rois - 1; i >= 0; i--) {
473  int startx, endx, starty, endy;
474  float qoffset;
475 
476  roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
477 
478  starty = FFMIN(mby, roi->top / mb_size);
479  endy = FFMIN(mby, (roi->bottom + mb_size - 1)/ mb_size);
480  startx = FFMIN(mbx, roi->left / mb_size);
481  endx = FFMIN(mbx, (roi->right + mb_size - 1)/ mb_size);
482 
483  if (roi->qoffset.den == 0) {
484  av_free(qoffsets);
485  av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
486  return AVERROR(EINVAL);
487  }
488  qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
489  qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
490 
491  for (int y = starty; y < endy; y++)
492  for (int x = startx; x < endx; x++)
493  qoffsets[x + y*mbx] = qoffset;
494  }
495 
496  pic->quantOffsets = qoffsets;
497  }
498  }
499  return 0;
500 }
501 
503  const AVFrame *pic, int *got_packet)
504 {
505  libx265Context *ctx = avctx->priv_data;
506  x265_picture x265pic;
507  x265_picture x265pic_out = { 0 };
508  x265_nal *nal;
509  uint8_t *dst;
510  int pict_type;
511  int payload = 0;
512  int nnal;
513  int ret;
514  int i;
515 
516  ctx->api->picture_init(ctx->params, &x265pic);
517 
518  if (pic) {
519  x265_sei *sei = &x265pic.userSEI;
520  sei->numPayloads = 0;
521  for (i = 0; i < 3; i++) {
522  x265pic.planes[i] = pic->data[i];
523  x265pic.stride[i] = pic->linesize[i];
524  }
525 
526  x265pic.pts = pic->pts;
527  x265pic.bitDepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
528 
529  x265pic.sliceType = pic->pict_type == AV_PICTURE_TYPE_I ?
530  (ctx->forced_idr ? X265_TYPE_IDR : X265_TYPE_I) :
531  pic->pict_type == AV_PICTURE_TYPE_P ? X265_TYPE_P :
532  pic->pict_type == AV_PICTURE_TYPE_B ? X265_TYPE_B :
533  X265_TYPE_AUTO;
534 
535  ret = libx265_encode_set_roi(ctx, pic, &x265pic);
536  if (ret < 0)
537  return ret;
538 
539  if (pic->reordered_opaque) {
540  x265pic.userData = av_malloc(sizeof(pic->reordered_opaque));
541  if (!x265pic.userData) {
542  av_freep(&x265pic.quantOffsets);
543  return AVERROR(ENOMEM);
544  }
545 
546  memcpy(x265pic.userData, &pic->reordered_opaque, sizeof(pic->reordered_opaque));
547  }
548 
549  if (ctx->udu_sei) {
550  for (i = 0; i < pic->nb_side_data; i++) {
551  AVFrameSideData *side_data = pic->side_data[i];
552  void *tmp;
553  x265_sei_payload *sei_payload;
554 
555  if (side_data->type != AV_FRAME_DATA_SEI_UNREGISTERED)
556  continue;
557 
558  tmp = av_fast_realloc(ctx->sei_data,
559  &ctx->sei_data_size,
560  (sei->numPayloads + 1) * sizeof(*sei_payload));
561  if (!tmp) {
562  av_freep(&x265pic.userData);
563  av_freep(&x265pic.quantOffsets);
564  return AVERROR(ENOMEM);
565  }
566  ctx->sei_data = tmp;
567  sei->payloads = ctx->sei_data;
568  sei_payload = &sei->payloads[sei->numPayloads];
569  sei_payload->payload = side_data->data;
570  sei_payload->payloadSize = side_data->size;
571  /* Equal to libx265 USER_DATA_UNREGISTERED */
572  sei_payload->payloadType = SEI_TYPE_USER_DATA_UNREGISTERED;
573  sei->numPayloads++;
574  }
575  }
576  }
577 
578  ret = ctx->api->encoder_encode(ctx->encoder, &nal, &nnal,
579  pic ? &x265pic : NULL, &x265pic_out);
580 
581  av_freep(&x265pic.quantOffsets);
582 
583  if (ret < 0)
584  return AVERROR_EXTERNAL;
585 
586  if (!nnal)
587  return 0;
588 
589  for (i = 0; i < nnal; i++)
590  payload += nal[i].sizeBytes;
591 
592  ret = ff_get_encode_buffer(avctx, pkt, payload, 0);
593  if (ret < 0) {
594  av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
595  return ret;
596  }
597  dst = pkt->data;
598 
599  for (i = 0; i < nnal; i++) {
600  memcpy(dst, nal[i].payload, nal[i].sizeBytes);
601  dst += nal[i].sizeBytes;
602 
603  if (is_keyframe(nal[i].type))
605  }
606 
607  pkt->pts = x265pic_out.pts;
608  pkt->dts = x265pic_out.dts;
609 
610  switch (x265pic_out.sliceType) {
611  case X265_TYPE_IDR:
612  case X265_TYPE_I:
613  pict_type = AV_PICTURE_TYPE_I;
614  break;
615  case X265_TYPE_P:
616  pict_type = AV_PICTURE_TYPE_P;
617  break;
618  case X265_TYPE_B:
619  case X265_TYPE_BREF:
620  pict_type = AV_PICTURE_TYPE_B;
621  break;
622  default:
623  av_log(avctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
624  return AVERROR_EXTERNAL;
625  }
626 
627 #if X265_BUILD >= 130
628  if (x265pic_out.sliceType == X265_TYPE_B)
629 #else
630  if (x265pic_out.frameData.sliceType == 'b')
631 #endif
633 
634  ff_side_data_set_encoder_stats(pkt, x265pic_out.frameData.qp * FF_QP2LAMBDA, NULL, 0, pict_type);
635 
636  if (x265pic_out.userData) {
637  memcpy(&avctx->reordered_opaque, x265pic_out.userData, sizeof(avctx->reordered_opaque));
638  av_freep(&x265pic_out.userData);
639  } else
640  avctx->reordered_opaque = 0;
641 
642  *got_packet = 1;
643  return 0;
644 }
645 
646 static const enum AVPixelFormat x265_csp_eight[] = {
656 };
657 
658 static const enum AVPixelFormat x265_csp_ten[] = {
673 };
674 
675 static const enum AVPixelFormat x265_csp_twelve[] = {
695 };
696 
698 {
699  if (x265_api_get(12))
700  codec->p.pix_fmts = x265_csp_twelve;
701  else if (x265_api_get(10))
702  codec->p.pix_fmts = x265_csp_ten;
703  else if (x265_api_get(8))
704  codec->p.pix_fmts = x265_csp_eight;
705 }
706 
707 #define OFFSET(x) offsetof(libx265Context, x)
708 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
709 static const AVOption options[] = {
710  { "crf", "set the x265 crf", OFFSET(crf), AV_OPT_TYPE_FLOAT, { .dbl = -1 }, -1, FLT_MAX, VE },
711  { "qp", "set the x265 qp", OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
712  { "forced-idr", "if forcing keyframes, force them as IDR frames", OFFSET(forced_idr),AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
713  { "preset", "set the x265 preset", OFFSET(preset), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
714  { "tune", "set the x265 tune parameter", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
715  { "profile", "set the x265 profile", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
716  { "udu_sei", "Use user data unregistered SEI if available", OFFSET(udu_sei), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
717  { "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 },
718  { NULL }
719 };
720 
721 static const AVClass class = {
722  .class_name = "libx265",
723  .item_name = av_default_item_name,
724  .option = options,
726 };
727 
728 static const FFCodecDefault x265_defaults[] = {
729  { "b", "0" },
730  { "bf", "-1" },
731  { "g", "-1" },
732  { "keyint_min", "-1" },
733  { "refs", "-1" },
734  { "qmin", "-1" },
735  { "qmax", "-1" },
736  { "qdiff", "-1" },
737  { "qblur", "-1" },
738  { "qcomp", "-1" },
739  { "i_qfactor", "-1" },
740  { "b_qfactor", "-1" },
741  { NULL },
742 };
743 
745  .p.name = "libx265",
746  .p.long_name = NULL_IF_CONFIG_SMALL("libx265 H.265 / HEVC"),
747  .p.type = AVMEDIA_TYPE_VIDEO,
748  .p.id = AV_CODEC_ID_HEVC,
749  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
752  .p.priv_class = &class,
753  .p.wrapper_name = "libx265",
754  .init = libx265_encode_init,
755  .init_static_data = libx265_encode_init_csp,
757  .close = libx265_encode_close,
758  .priv_data_size = sizeof(libx265Context),
760  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
762 };
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:940
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:110
libx265_param_parse_float
static av_cold int libx265_param_parse_float(AVCodecContext *avctx, const char *key, float value)
Definition: libx265.c:95
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:975
libx265Context::forced_idr
int forced_idr
Definition: libx265.c:50
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:691
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2703
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:45
AVFrame::nb_side_data
int nb_side_data
Definition: frame.h:546
options
static const AVOption options[]
Definition: libx265.c:709
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:226
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
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:432
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:968
VE
#define VE
Definition: libx265.c:708
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:606
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
AVOption
AVOption.
Definition: opt.h:251
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:506
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:411
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:68
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:33
FFCodec
Definition: codec_internal.h:118
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:533
float.h
AVDictionary
Definition: dict.c:30
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:263
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:1194
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:346
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:284
libx265Context::x265_opts
AVDictionary * x265_opts
Definition: libx265.c:54
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:64
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1741
libx265_encode_frame
static int libx265_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
Definition: libx265.c:502
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:703
FFCodecDefault
Definition: codec_internal.h:88
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1472
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:427
libx265_encode_init_csp
static av_cold void libx265_encode_init_csp(FFCodec *codec)
Definition: libx265.c:697
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:947
libx265Context::preset
char * preset
Definition: libx265.c:51
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:478
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:269
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:414
preset
preset
Definition: vf_curves.c:46
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:961
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:234
av_cold
#define av_cold
Definition: attributes.h:90
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:250
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:1251
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:40
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:500
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:505
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:266
AVDictionaryEntry::key
char * key
Definition: dict.h:80
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:530
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:127
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This codec takes the reordered_opaque field from input AVFrames and returns it in the corresponding f...
Definition: codec.h:176
ctx
AVFormatContext * ctx
Definition: movenc.c:48
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:1223
key
const char * key
Definition: hwcontext_opencl.c:174
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:481
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:104
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:392
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1208
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:982
AVCodecContext::qblur
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:1180
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:448
libx265_encode_init
static av_cold int libx265_encode_init(AVCodecContext *avctx)
Definition: libx265.c:125
sei.h
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:232
libx265Context::tune
char * tune
Definition: libx265.c:52
AVRegionOfInterest::self_size
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:255
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:44
OFFSET
#define OFFSET(x)
Definition: libx265.c:707
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:412
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:572
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:1179
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:521
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:422
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
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
defaults
static const FFCodecDefault defaults[]
Definition: amfenc_h264.c:362
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:593
codec_internal.h
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:416
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:418
AVFrameSideData::data
uint8_t * data
Definition: frame.h:233
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:626
libx265Context::udu_sei
int udu_sei
Definition: libx265.c:58
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:119
AVRegionOfInterest::right
int right
Definition: frame.h:268
libx265Context::cqp
int cqp
Definition: libx265.c:49
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:679
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
AVRegionOfInterest::left
int left
Definition: frame.h:267
libx265Context::crf
float crf
Definition: libx265.c:48
libx265Context::api
const x265_api * api
Definition: libx265.c:46
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:499
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:265
internal.h
SEI_TYPE_USER_DATA_UNREGISTERED
@ SEI_TYPE_USER_DATA_UNREGISTERED
Definition: sei.h:35
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:428
common.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:109
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:224
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:211
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:989
AVFrame::side_data
AVFrameSideData ** side_data
Definition: frame.h:545
profile
int profile
Definition: mxfenc.c:2005
libx265_encode_set_roi
static av_cold int libx265_encode_set_roi(libx265Context *ctx, const AVFrame *frame, x265_picture *pic)
Definition: libx265.c:438
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:535
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
libx265Context::sei_data
void * sei_data
Definition: libx265.c:56
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
avcodec.h
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:298
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:125
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:415
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AVCodecContext::max_qdiff
int max_qdiff
maximum quantizer difference between frames
Definition: avcodec.h:1201
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AVCOL_TRC_ARIB_STD_B67
@ AVCOL_TRC_ARIB_STD_B67
ARIB STD-B67, known as "Hybrid log-gamma".
Definition: pixfmt.h:524
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
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1187
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:232
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:658
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:82
libx265_encode_close
static av_cold int libx265_encode_close(AVCodecContext *avctx)
Definition: libx265.c:82
ff_libx265_encoder
FFCodec ff_libx265_encoder
Definition: libx265.c:744
AVFrame::reordered_opaque
int64_t reordered_opaque
reordered opaque 64 bits (generally an integer or a double precision float PTS but can be anything).
Definition: frame.h:497
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:57
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
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:670
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:72
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:231
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:493
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:79
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecContext::reordered_opaque
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame....
Definition: avcodec.h:1381
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
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:370
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:728
libx265Context::profile
char * profile
Definition: libx265.c:53
AVDictionaryEntry::value
char * value
Definition: dict.h:81
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:393
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
libx265Context
Definition: libx265.c:41
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:292
AVCOL_SPC_ICTCP
@ AVCOL_SPC_ICTCP
ITU-R BT.2100-0, ICtCp.
Definition: pixfmt.h:548
snprintf
#define snprintf
Definition: snprintf.h:34
x265_csp_eight
static enum AVPixelFormat x265_csp_eight[]
Definition: libx265.c:646
x265_csp_twelve
static enum AVPixelFormat x265_csp_twelve[]
Definition: libx265.c:675
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:768
is_keyframe
static int is_keyframe(NalUnitType naltype)
Definition: libx265.c:67