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