FFmpeg  4.3.7
vaapi_encode_h265.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include <string.h>
20 
21 #include <va/va.h>
22 #include <va/va_enc_hevc.h>
23 
24 #include "libavutil/avassert.h"
25 #include "libavutil/common.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/opt.h"
29 
30 #include "avcodec.h"
31 #include "cbs.h"
32 #include "cbs_h265.h"
33 #include "h265_profile_level.h"
34 #include "hevc.h"
35 #include "hevc_sei.h"
36 #include "internal.h"
37 #include "put_bits.h"
38 #include "vaapi_encode.h"
39 
40 enum {
43 };
44 
45 typedef struct VAAPIEncodeH265Picture {
47 
48  int64_t last_idr_frame;
49 
52  int pic_type;
54 
55 typedef struct VAAPIEncodeH265Context {
57 
58  // User options.
59  int qp;
60  int aud;
61  int profile;
62  int tier;
63  int level;
64  int sei;
65 
66  // Derived settings.
70 
71  // Writer structures.
78 
81 
87 
88 
90  char *data, size_t *data_len,
92 {
93  VAAPIEncodeH265Context *priv = avctx->priv_data;
94  int err;
95 
96  err = ff_cbs_write_fragment_data(priv->cbc, au);
97  if (err < 0) {
98  av_log(avctx, AV_LOG_ERROR, "Failed to write packed header.\n");
99  return err;
100  }
101 
102  if (*data_len < 8 * au->data_size - au->data_bit_padding) {
103  av_log(avctx, AV_LOG_ERROR, "Access unit too large: "
104  "%zu < %zu.\n", *data_len,
105  8 * au->data_size - au->data_bit_padding);
106  return AVERROR(ENOSPC);
107  }
108 
109  memcpy(data, au->data, au->data_size);
110  *data_len = 8 * au->data_size - au->data_bit_padding;
111 
112  return 0;
113 }
114 
117  void *nal_unit)
118 {
119  VAAPIEncodeH265Context *priv = avctx->priv_data;
120  H265RawNALUnitHeader *header = nal_unit;
121  int err;
122 
123  err = ff_cbs_insert_unit_content(priv->cbc, au, -1,
124  header->nal_unit_type, nal_unit, NULL);
125  if (err < 0) {
126  av_log(avctx, AV_LOG_ERROR, "Failed to add NAL unit: "
127  "type = %d.\n", header->nal_unit_type);
128  return err;
129  }
130 
131  return 0;
132 }
133 
135  char *data, size_t *data_len)
136 {
137  VAAPIEncodeH265Context *priv = avctx->priv_data;
139  int err;
140 
141  if (priv->aud_needed) {
142  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_aud);
143  if (err < 0)
144  goto fail;
145  priv->aud_needed = 0;
146  }
147 
148  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_vps);
149  if (err < 0)
150  goto fail;
151 
152  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_sps);
153  if (err < 0)
154  goto fail;
155 
156  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_pps);
157  if (err < 0)
158  goto fail;
159 
160  err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
161 fail:
162  ff_cbs_fragment_reset(priv->cbc, au);
163  return err;
164 }
165 
167  VAAPIEncodePicture *pic,
168  VAAPIEncodeSlice *slice,
169  char *data, size_t *data_len)
170 {
171  VAAPIEncodeH265Context *priv = avctx->priv_data;
173  int err;
174 
175  if (priv->aud_needed) {
176  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_aud);
177  if (err < 0)
178  goto fail;
179  priv->aud_needed = 0;
180  }
181 
182  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_slice);
183  if (err < 0)
184  goto fail;
185 
186  err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
187 fail:
188  ff_cbs_fragment_reset(priv->cbc, au);
189  return err;
190 }
191 
193  VAAPIEncodePicture *pic,
194  int index, int *type,
195  char *data, size_t *data_len)
196 {
197  VAAPIEncodeH265Context *priv = avctx->priv_data;
199  int err, i;
200 
201  if (priv->sei_needed) {
202  H265RawSEI *sei = &priv->raw_sei;
203 
204  if (priv->aud_needed) {
205  err = vaapi_encode_h265_add_nal(avctx, au, &priv->aud);
206  if (err < 0)
207  goto fail;
208  priv->aud_needed = 0;
209  }
210 
211  *sei = (H265RawSEI) {
212  .nal_unit_header = {
214  .nuh_layer_id = 0,
215  .nuh_temporal_id_plus1 = 1,
216  },
217  };
218 
219  i = 0;
220 
221  if (priv->sei_needed & SEI_MASTERING_DISPLAY) {
224  ++i;
225  }
226 
227  if (priv->sei_needed & SEI_CONTENT_LIGHT_LEVEL) {
230  ++i;
231  }
232 
233  sei->payload_count = i;
234  av_assert0(sei->payload_count > 0);
235 
236  err = vaapi_encode_h265_add_nal(avctx, au, sei);
237  if (err < 0)
238  goto fail;
239  priv->sei_needed = 0;
240 
241  err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
242  if (err < 0)
243  goto fail;
244 
245  ff_cbs_fragment_reset(priv->cbc, au);
246 
247  *type = VAEncPackedHeaderRawData;
248  return 0;
249  } else {
250  return AVERROR_EOF;
251  }
252 
253 fail:
254  ff_cbs_fragment_reset(priv->cbc, au);
255  return err;
256 }
257 
259 {
260  VAAPIEncodeContext *ctx = avctx->priv_data;
261  VAAPIEncodeH265Context *priv = avctx->priv_data;
262  H265RawVPS *vps = &priv->raw_vps;
263  H265RawSPS *sps = &priv->raw_sps;
264  H265RawPPS *pps = &priv->raw_pps;
266  H265RawVUI *vui = &sps->vui;
267  VAEncSequenceParameterBufferHEVC *vseq = ctx->codec_sequence_params;
268  VAEncPictureParameterBufferHEVC *vpic = ctx->codec_picture_params;
269  const AVPixFmtDescriptor *desc;
270  int chroma_format, bit_depth;
271  int i;
272 
273  memset(vps, 0, sizeof(*vps));
274  memset(sps, 0, sizeof(*sps));
275  memset(pps, 0, sizeof(*pps));
276 
277 
279  av_assert0(desc);
280  if (desc->nb_components == 1) {
281  chroma_format = 0;
282  } else {
283  if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1) {
284  chroma_format = 1;
285  } else if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 0) {
286  chroma_format = 2;
287  } else if (desc->log2_chroma_w == 0 && desc->log2_chroma_h == 0) {
288  chroma_format = 3;
289  } else {
290  av_log(avctx, AV_LOG_ERROR, "Chroma format of input pixel format "
291  "%s is not supported.\n", desc->name);
292  return AVERROR(EINVAL);
293  }
294  }
295  bit_depth = desc->comp[0].depth;
296 
297 
298  // VPS
299 
302  .nuh_layer_id = 0,
303  .nuh_temporal_id_plus1 = 1,
304  };
305 
307 
310  vps->vps_max_layers_minus1 = 0;
311  vps->vps_max_sub_layers_minus1 = 0;
313 
314  ptl->general_profile_space = 0;
315  ptl->general_profile_idc = avctx->profile;
316  ptl->general_tier_flag = priv->tier;
317 
318  if (chroma_format == 1) {
319  ptl->general_profile_compatibility_flag[1] = bit_depth == 8;
320  ptl->general_profile_compatibility_flag[2] = bit_depth <= 10;
321  }
323 
328 
329  ptl->general_max_12bit_constraint_flag = bit_depth <= 12;
330  ptl->general_max_10bit_constraint_flag = bit_depth <= 10;
331  ptl->general_max_8bit_constraint_flag = bit_depth == 8;
332 
333  ptl->general_max_422chroma_constraint_flag = chroma_format <= 2;
334  ptl->general_max_420chroma_constraint_flag = chroma_format <= 1;
335  ptl->general_max_monochrome_constraint_flag = chroma_format == 0;
336 
337  ptl->general_intra_constraint_flag = ctx->gop_size == 1;
338 
340 
341  if (avctx->level != FF_LEVEL_UNKNOWN) {
342  ptl->general_level_idc = avctx->level;
343  } else {
344  const H265LevelDescriptor *level;
345 
346  level = ff_h265_guess_level(ptl, avctx->bit_rate,
347  ctx->surface_width, ctx->surface_height,
348  ctx->nb_slices, 1, 1,
349  (ctx->b_per_p > 0) + 1);
350  if (level) {
351  av_log(avctx, AV_LOG_VERBOSE, "Using level %s.\n", level->name);
352  ptl->general_level_idc = level->level_idc;
353  } else {
354  av_log(avctx, AV_LOG_VERBOSE, "Stream will not conform to "
355  "any normal level; using level 8.5.\n");
356  ptl->general_level_idc = 255;
357  // The tier flag must be set in level 8.5.
358  ptl->general_tier_flag = 1;
359  }
360  }
361 
364  vps->vps_max_num_reorder_pics[0] = ctx->max_b_depth;
365  vps->vps_max_latency_increase_plus1[0] = 0;
366 
367  vps->vps_max_layer_id = 0;
368  vps->vps_num_layer_sets_minus1 = 0;
369  vps->layer_id_included_flag[0][0] = 1;
370 
372  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
373  vps->vps_num_units_in_tick = avctx->framerate.den;
374  vps->vps_time_scale = avctx->framerate.num;
377  } else {
378  vps->vps_num_units_in_tick = avctx->time_base.num;
379  vps->vps_time_scale = avctx->time_base.den;
381  }
382  vps->vps_num_hrd_parameters = 0;
383 
384 
385  // SPS
386 
389  .nuh_layer_id = 0,
390  .nuh_temporal_id_plus1 = 1,
391  };
392 
394 
397 
399 
400  sps->sps_seq_parameter_set_id = 0;
401 
402  sps->chroma_format_idc = chroma_format;
404 
407 
408  if (avctx->width != ctx->surface_width ||
409  avctx->height != ctx->surface_height) {
410  sps->conformance_window_flag = 1;
411  sps->conf_win_left_offset = 0;
412  sps->conf_win_right_offset =
413  (ctx->surface_width - avctx->width) >> desc->log2_chroma_w;
414  sps->conf_win_top_offset = 0;
416  (ctx->surface_height - avctx->height) >> desc->log2_chroma_h;
417  } else {
418  sps->conformance_window_flag = 0;
419  }
420 
421  sps->bit_depth_luma_minus8 = bit_depth - 8;
422  sps->bit_depth_chroma_minus8 = bit_depth - 8;
423 
425 
428  for (i = 0; i <= sps->sps_max_sub_layers_minus1; i++) {
435  }
436 
437  // These have to come from the capabilities of the encoder. We have no
438  // way to query them, so just hardcode parameters which work on the Intel
439  // driver.
440  // CTB size from 8x8 to 32x32.
443  // Transform size from 4x4 to 32x32.
446  // Full transform hierarchy allowed (2-5).
449  // AMP works.
450  sps->amp_enabled_flag = 1;
451  // SAO and temporal MVP do not work.
454 
455  sps->pcm_enabled_flag = 0;
456 
457  // STRPSs should ideally be here rather than defined individually in
458  // each slice, but the structure isn't completely fixed so for now
459  // don't bother.
462 
464 
465  if (avctx->sample_aspect_ratio.num != 0 &&
466  avctx->sample_aspect_ratio.den != 0) {
467  static const AVRational sar_idc[] = {
468  { 0, 0 },
469  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
470  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
471  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
472  { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
473  };
474  int num, den, i;
475  av_reduce(&num, &den, avctx->sample_aspect_ratio.num,
476  avctx->sample_aspect_ratio.den, 65535);
477  for (i = 0; i < FF_ARRAY_ELEMS(sar_idc); i++) {
478  if (num == sar_idc[i].num &&
479  den == sar_idc[i].den) {
480  vui->aspect_ratio_idc = i;
481  break;
482  }
483  }
484  if (i >= FF_ARRAY_ELEMS(sar_idc)) {
485  vui->aspect_ratio_idc = 255;
486  vui->sar_width = num;
487  vui->sar_height = den;
488  }
490  }
491 
492  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED ||
494  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
495  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
497  vui->video_format = 5; // Unspecified.
498  vui->video_full_range_flag =
499  avctx->color_range == AVCOL_RANGE_JPEG;
500 
501  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
502  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
503  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
505  vui->colour_primaries = avctx->color_primaries;
506  vui->transfer_characteristics = avctx->color_trc;
507  vui->matrix_coefficients = avctx->colorspace;
508  }
509  } else {
510  vui->video_format = 5;
511  vui->video_full_range_flag = 0;
512  vui->colour_primaries = avctx->color_primaries;
513  vui->transfer_characteristics = avctx->color_trc;
514  vui->matrix_coefficients = avctx->colorspace;
515  }
516 
521  avctx->chroma_sample_location - 1;
522  }
523 
526  vui->vui_time_scale = vps->vps_time_scale;
530 
534  vui->max_bytes_per_pic_denom = 0;
535  vui->max_bits_per_min_cu_denom = 0;
537  vui->log2_max_mv_length_vertical = 15;
538 
539 
540  // PPS
541 
544  .nuh_layer_id = 0,
545  .nuh_temporal_id_plus1 = 1,
546  };
547 
548  pps->pps_pic_parameter_set_id = 0;
550 
553 
554  pps->init_qp_minus26 = priv->fixed_qp_idr - 26;
555 
556  pps->cu_qp_delta_enabled_flag = (ctx->va_rc_mode != VA_RC_CQP);
557  pps->diff_cu_qp_delta_depth = 0;
558 
560 
561 
562  // Fill VAAPI parameter buffers.
563 
564  *vseq = (VAEncSequenceParameterBufferHEVC) {
565  .general_profile_idc = vps->profile_tier_level.general_profile_idc,
566  .general_level_idc = vps->profile_tier_level.general_level_idc,
567  .general_tier_flag = vps->profile_tier_level.general_tier_flag,
568 
569  .intra_period = ctx->gop_size,
570  .intra_idr_period = ctx->gop_size,
571  .ip_period = ctx->b_per_p + 1,
572  .bits_per_second = ctx->va_bit_rate,
573 
574  .pic_width_in_luma_samples = sps->pic_width_in_luma_samples,
575  .pic_height_in_luma_samples = sps->pic_height_in_luma_samples,
576 
577  .seq_fields.bits = {
578  .chroma_format_idc = sps->chroma_format_idc,
579  .separate_colour_plane_flag = sps->separate_colour_plane_flag,
580  .bit_depth_luma_minus8 = sps->bit_depth_luma_minus8,
581  .bit_depth_chroma_minus8 = sps->bit_depth_chroma_minus8,
582  .scaling_list_enabled_flag = sps->scaling_list_enabled_flag,
583  .strong_intra_smoothing_enabled_flag =
585  .amp_enabled_flag = sps->amp_enabled_flag,
586  .sample_adaptive_offset_enabled_flag =
588  .pcm_enabled_flag = sps->pcm_enabled_flag,
589  .pcm_loop_filter_disabled_flag = sps->pcm_loop_filter_disabled_flag,
590  .sps_temporal_mvp_enabled_flag = sps->sps_temporal_mvp_enabled_flag,
591  },
592 
593  .log2_min_luma_coding_block_size_minus3 =
595  .log2_diff_max_min_luma_coding_block_size =
597  .log2_min_transform_block_size_minus2 =
599  .log2_diff_max_min_transform_block_size =
601  .max_transform_hierarchy_depth_inter =
603  .max_transform_hierarchy_depth_intra =
605 
606  .pcm_sample_bit_depth_luma_minus1 =
608  .pcm_sample_bit_depth_chroma_minus1 =
610  .log2_min_pcm_luma_coding_block_size_minus3 =
612  .log2_max_pcm_luma_coding_block_size_minus3 =
615 
616  .vui_parameters_present_flag = 0,
617  };
618 
619  *vpic = (VAEncPictureParameterBufferHEVC) {
620  .decoded_curr_pic = {
621  .picture_id = VA_INVALID_ID,
622  .flags = VA_PICTURE_HEVC_INVALID,
623  },
624 
625  .coded_buf = VA_INVALID_ID,
626 
627  .collocated_ref_pic_index = 0xff,
628 
629  .last_picture = 0,
630 
631  .pic_init_qp = pps->init_qp_minus26 + 26,
632  .diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth,
633  .pps_cb_qp_offset = pps->pps_cb_qp_offset,
634  .pps_cr_qp_offset = pps->pps_cr_qp_offset,
635 
636  .num_tile_columns_minus1 = pps->num_tile_columns_minus1,
637  .num_tile_rows_minus1 = pps->num_tile_rows_minus1,
638 
639  .log2_parallel_merge_level_minus2 = pps->log2_parallel_merge_level_minus2,
640  .ctu_max_bitsize_allowed = 0,
641 
642  .num_ref_idx_l0_default_active_minus1 =
644  .num_ref_idx_l1_default_active_minus1 =
646 
647  .slice_pic_parameter_set_id = pps->pps_pic_parameter_set_id,
648 
649  .pic_fields.bits = {
650  .sign_data_hiding_enabled_flag = pps->sign_data_hiding_enabled_flag,
651  .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
652  .transform_skip_enabled_flag = pps->transform_skip_enabled_flag,
653  .cu_qp_delta_enabled_flag = pps->cu_qp_delta_enabled_flag,
654  .weighted_pred_flag = pps->weighted_pred_flag,
655  .weighted_bipred_flag = pps->weighted_bipred_flag,
656  .transquant_bypass_enabled_flag = pps->transquant_bypass_enabled_flag,
657  .tiles_enabled_flag = pps->tiles_enabled_flag,
658  .entropy_coding_sync_enabled_flag = pps->entropy_coding_sync_enabled_flag,
659  .loop_filter_across_tiles_enabled_flag =
661  .scaling_list_data_present_flag = (sps->sps_scaling_list_data_present_flag |
663  .screen_content_flag = 0,
664  .enable_gpu_weighted_prediction = 0,
665  .no_output_of_prior_pics_flag = 0,
666  },
667  };
668 
669  return 0;
670 }
671 
673  VAAPIEncodePicture *pic)
674 {
675  VAAPIEncodeContext *ctx = avctx->priv_data;
676  VAAPIEncodeH265Context *priv = avctx->priv_data;
677  VAAPIEncodeH265Picture *hpic = pic->priv_data;
678  VAAPIEncodePicture *prev = pic->prev;
679  VAAPIEncodeH265Picture *hprev = prev ? prev->priv_data : NULL;
680  VAEncPictureParameterBufferHEVC *vpic = pic->codec_picture_params;
681  int i;
682 
683  if (pic->type == PICTURE_TYPE_IDR) {
684  av_assert0(pic->display_order == pic->encode_order);
685 
686  hpic->last_idr_frame = pic->display_order;
687 
689  hpic->slice_type = HEVC_SLICE_I;
690  hpic->pic_type = 0;
691  } else {
692  av_assert0(prev);
693  hpic->last_idr_frame = hprev->last_idr_frame;
694 
695  if (pic->type == PICTURE_TYPE_I) {
697  hpic->slice_type = HEVC_SLICE_I;
698  hpic->pic_type = 0;
699  } else if (pic->type == PICTURE_TYPE_P) {
700  av_assert0(pic->refs[0]);
702  hpic->slice_type = HEVC_SLICE_P;
703  hpic->pic_type = 1;
704  } else {
705  VAAPIEncodePicture *irap_ref;
706  av_assert0(pic->refs[0] && pic->refs[1]);
707  for (irap_ref = pic; irap_ref; irap_ref = irap_ref->refs[1]) {
708  if (irap_ref->type == PICTURE_TYPE_I)
709  break;
710  }
711  if (pic->b_depth == ctx->max_b_depth) {
712  hpic->slice_nal_unit = irap_ref ? HEVC_NAL_RASL_N
714  } else {
715  hpic->slice_nal_unit = irap_ref ? HEVC_NAL_RASL_R
717  }
718  hpic->slice_type = HEVC_SLICE_B;
719  hpic->pic_type = 2;
720  }
721  }
722  hpic->pic_order_cnt = pic->display_order - hpic->last_idr_frame;
723 
724  if (priv->aud) {
725  priv->aud_needed = 1;
726  priv->raw_aud = (H265RawAUD) {
727  .nal_unit_header = {
729  .nuh_layer_id = 0,
730  .nuh_temporal_id_plus1 = 1,
731  },
732  .pic_type = hpic->pic_type,
733  };
734  } else {
735  priv->aud_needed = 0;
736  }
737 
738  priv->sei_needed = 0;
739 
740  // Only look for the metadata on I/IDR frame on the output. We
741  // may force an IDR frame on the output where the medadata gets
742  // changed on the input frame.
743  if ((priv->sei & SEI_MASTERING_DISPLAY) &&
744  (pic->type == PICTURE_TYPE_I || pic->type == PICTURE_TYPE_IDR)) {
745  AVFrameSideData *sd =
748 
749  if (sd) {
752 
753  // SEI is needed when both the primaries and luminance are set
754  if (mdm->has_primaries && mdm->has_luminance) {
756  &priv->sei_mastering_display;
757  const int mapping[3] = {1, 2, 0};
758  const int chroma_den = 50000;
759  const int luma_den = 10000;
760 
761  for (i = 0; i < 3; i++) {
762  const int j = mapping[i];
763  mdcv->display_primaries_x[i] =
764  FFMIN(lrint(chroma_den *
765  av_q2d(mdm->display_primaries[j][0])),
766  chroma_den);
767  mdcv->display_primaries_y[i] =
768  FFMIN(lrint(chroma_den *
769  av_q2d(mdm->display_primaries[j][1])),
770  chroma_den);
771  }
772 
773  mdcv->white_point_x =
774  FFMIN(lrint(chroma_den * av_q2d(mdm->white_point[0])),
775  chroma_den);
776  mdcv->white_point_y =
777  FFMIN(lrint(chroma_den * av_q2d(mdm->white_point[1])),
778  chroma_den);
779 
781  lrint(luma_den * av_q2d(mdm->max_luminance));
783  FFMIN(lrint(luma_den * av_q2d(mdm->min_luminance)),
785 
787  }
788  }
789  }
790 
791  if ((priv->sei & SEI_CONTENT_LIGHT_LEVEL) &&
792  (pic->type == PICTURE_TYPE_I || pic->type == PICTURE_TYPE_IDR)) {
793  AVFrameSideData *sd =
796 
797  if (sd) {
802 
803  clli->max_content_light_level = FFMIN(clm->MaxCLL, 65535);
804  clli->max_pic_average_light_level = FFMIN(clm->MaxFALL, 65535);
805 
807  }
808  }
809 
810  vpic->decoded_curr_pic = (VAPictureHEVC) {
811  .picture_id = pic->recon_surface,
812  .pic_order_cnt = hpic->pic_order_cnt,
813  .flags = 0,
814  };
815 
816  for (i = 0; i < pic->nb_refs; i++) {
817  VAAPIEncodePicture *ref = pic->refs[i];
819 
820  av_assert0(ref && ref->encode_order < pic->encode_order);
821  href = ref->priv_data;
822 
823  vpic->reference_frames[i] = (VAPictureHEVC) {
824  .picture_id = ref->recon_surface,
825  .pic_order_cnt = href->pic_order_cnt,
826  .flags = (ref->display_order < pic->display_order ?
827  VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE : 0) |
828  (ref->display_order > pic->display_order ?
829  VA_PICTURE_HEVC_RPS_ST_CURR_AFTER : 0),
830  };
831  }
832  for (; i < FF_ARRAY_ELEMS(vpic->reference_frames); i++) {
833  vpic->reference_frames[i] = (VAPictureHEVC) {
834  .picture_id = VA_INVALID_ID,
835  .flags = VA_PICTURE_HEVC_INVALID,
836  };
837  }
838 
839  vpic->coded_buf = pic->output_buffer;
840 
841  vpic->nal_unit_type = hpic->slice_nal_unit;
842 
843  switch (pic->type) {
844  case PICTURE_TYPE_IDR:
845  vpic->pic_fields.bits.idr_pic_flag = 1;
846  vpic->pic_fields.bits.coding_type = 1;
847  vpic->pic_fields.bits.reference_pic_flag = 1;
848  break;
849  case PICTURE_TYPE_I:
850  vpic->pic_fields.bits.idr_pic_flag = 0;
851  vpic->pic_fields.bits.coding_type = 1;
852  vpic->pic_fields.bits.reference_pic_flag = 1;
853  break;
854  case PICTURE_TYPE_P:
855  vpic->pic_fields.bits.idr_pic_flag = 0;
856  vpic->pic_fields.bits.coding_type = 2;
857  vpic->pic_fields.bits.reference_pic_flag = 1;
858  break;
859  case PICTURE_TYPE_B:
860  vpic->pic_fields.bits.idr_pic_flag = 0;
861  vpic->pic_fields.bits.coding_type = 3;
862  vpic->pic_fields.bits.reference_pic_flag = 0;
863  break;
864  default:
865  av_assert0(0 && "invalid picture type");
866  }
867 
868  return 0;
869 }
870 
872  VAAPIEncodePicture *pic,
873  VAAPIEncodeSlice *slice)
874 {
875  VAAPIEncodeH265Context *priv = avctx->priv_data;
876  VAAPIEncodeH265Picture *hpic = pic->priv_data;
877  const H265RawSPS *sps = &priv->raw_sps;
878  const H265RawPPS *pps = &priv->raw_pps;
879  H265RawSliceHeader *sh = &priv->raw_slice.header;
880  VAEncPictureParameterBufferHEVC *vpic = pic->codec_picture_params;
881  VAEncSliceParameterBufferHEVC *vslice = slice->codec_slice_params;
882  int i;
883 
885  .nal_unit_type = hpic->slice_nal_unit,
886  .nuh_layer_id = 0,
887  .nuh_temporal_id_plus1 = 1,
888  };
889 
891 
892  sh->first_slice_segment_in_pic_flag = slice->index == 0;
893  sh->slice_segment_address = slice->block_start;
894 
895  sh->slice_type = hpic->slice_type;
896 
898  (1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4)) - 1;
899 
900  if (pic->type != PICTURE_TYPE_IDR) {
901  H265RawSTRefPicSet *rps;
902  const VAAPIEncodeH265Picture *strp;
903  int rps_poc[MAX_DPB_SIZE];
904  int rps_used[MAX_DPB_SIZE];
905  int i, j, poc, rps_pics;
906 
908 
909  rps = &sh->short_term_ref_pic_set;
910  memset(rps, 0, sizeof(*rps));
911 
912  rps_pics = 0;
913  for (i = 0; i < pic->nb_refs; i++) {
914  strp = pic->refs[i]->priv_data;
915  rps_poc[rps_pics] = strp->pic_order_cnt;
916  rps_used[rps_pics] = 1;
917  ++rps_pics;
918  }
919  for (i = 0; i < pic->nb_dpb_pics; i++) {
920  if (pic->dpb[i] == pic)
921  continue;
922  for (j = 0; j < pic->nb_refs; j++) {
923  if (pic->dpb[i] == pic->refs[j])
924  break;
925  }
926  if (j < pic->nb_refs)
927  continue;
928  strp = pic->dpb[i]->priv_data;
929  rps_poc[rps_pics] = strp->pic_order_cnt;
930  rps_used[rps_pics] = 0;
931  ++rps_pics;
932  }
933 
934  for (i = 1; i < rps_pics; i++) {
935  for (j = i; j > 0; j--) {
936  if (rps_poc[j] > rps_poc[j - 1])
937  break;
938  av_assert0(rps_poc[j] != rps_poc[j - 1]);
939  FFSWAP(int, rps_poc[j], rps_poc[j - 1]);
940  FFSWAP(int, rps_used[j], rps_used[j - 1]);
941  }
942  }
943 
944  av_log(avctx, AV_LOG_DEBUG, "RPS for POC %d:",
945  hpic->pic_order_cnt);
946  for (i = 0; i < rps_pics; i++) {
947  av_log(avctx, AV_LOG_DEBUG, " (%d,%d)",
948  rps_poc[i], rps_used[i]);
949  }
950  av_log(avctx, AV_LOG_DEBUG, "\n");
951 
952  for (i = 0; i < rps_pics; i++) {
953  av_assert0(rps_poc[i] != hpic->pic_order_cnt);
954  if (rps_poc[i] > hpic->pic_order_cnt)
955  break;
956  }
957 
958  rps->num_negative_pics = i;
959  poc = hpic->pic_order_cnt;
960  for (j = i - 1; j >= 0; j--) {
961  rps->delta_poc_s0_minus1[i - 1 - j] = poc - rps_poc[j] - 1;
962  rps->used_by_curr_pic_s0_flag[i - 1 - j] = rps_used[j];
963  poc = rps_poc[j];
964  }
965 
966  rps->num_positive_pics = rps_pics - i;
967  poc = hpic->pic_order_cnt;
968  for (j = i; j < rps_pics; j++) {
969  rps->delta_poc_s1_minus1[j - i] = rps_poc[j] - poc - 1;
970  rps->used_by_curr_pic_s1_flag[j - i] = rps_used[j];
971  poc = rps_poc[j];
972  }
973 
974  sh->num_long_term_sps = 0;
975  sh->num_long_term_pics = 0;
976 
981  sh->collocated_ref_idx = 0;
982  }
983 
987  }
988 
991 
992  if (pic->type == PICTURE_TYPE_B)
993  sh->slice_qp_delta = priv->fixed_qp_b - (pps->init_qp_minus26 + 26);
994  else if (pic->type == PICTURE_TYPE_P)
995  sh->slice_qp_delta = priv->fixed_qp_p - (pps->init_qp_minus26 + 26);
996  else
997  sh->slice_qp_delta = priv->fixed_qp_idr - (pps->init_qp_minus26 + 26);
998 
999 
1000  *vslice = (VAEncSliceParameterBufferHEVC) {
1001  .slice_segment_address = sh->slice_segment_address,
1002  .num_ctu_in_slice = slice->block_size,
1003 
1004  .slice_type = sh->slice_type,
1005  .slice_pic_parameter_set_id = sh->slice_pic_parameter_set_id,
1006 
1007  .num_ref_idx_l0_active_minus1 = sh->num_ref_idx_l0_active_minus1,
1008  .num_ref_idx_l1_active_minus1 = sh->num_ref_idx_l1_active_minus1,
1009 
1010  .luma_log2_weight_denom = sh->luma_log2_weight_denom,
1011  .delta_chroma_log2_weight_denom = sh->delta_chroma_log2_weight_denom,
1012 
1013  .max_num_merge_cand = 5 - sh->five_minus_max_num_merge_cand,
1014 
1015  .slice_qp_delta = sh->slice_qp_delta,
1016  .slice_cb_qp_offset = sh->slice_cb_qp_offset,
1017  .slice_cr_qp_offset = sh->slice_cr_qp_offset,
1018 
1019  .slice_beta_offset_div2 = sh->slice_beta_offset_div2,
1020  .slice_tc_offset_div2 = sh->slice_tc_offset_div2,
1021 
1022  .slice_fields.bits = {
1023  .last_slice_of_pic_flag = slice->index == pic->nb_slices - 1,
1024  .dependent_slice_segment_flag = sh->dependent_slice_segment_flag,
1025  .colour_plane_id = sh->colour_plane_id,
1026  .slice_temporal_mvp_enabled_flag =
1028  .slice_sao_luma_flag = sh->slice_sao_luma_flag,
1029  .slice_sao_chroma_flag = sh->slice_sao_chroma_flag,
1030  .num_ref_idx_active_override_flag =
1032  .mvd_l1_zero_flag = sh->mvd_l1_zero_flag,
1033  .cabac_init_flag = sh->cabac_init_flag,
1034  .slice_deblocking_filter_disabled_flag =
1036  .slice_loop_filter_across_slices_enabled_flag =
1038  .collocated_from_l0_flag = sh->collocated_from_l0_flag,
1039  },
1040  };
1041 
1042  for (i = 0; i < FF_ARRAY_ELEMS(vslice->ref_pic_list0); i++) {
1043  vslice->ref_pic_list0[i].picture_id = VA_INVALID_ID;
1044  vslice->ref_pic_list0[i].flags = VA_PICTURE_HEVC_INVALID;
1045  vslice->ref_pic_list1[i].picture_id = VA_INVALID_ID;
1046  vslice->ref_pic_list1[i].flags = VA_PICTURE_HEVC_INVALID;
1047  }
1048 
1049  av_assert0(pic->nb_refs <= 2);
1050  if (pic->nb_refs >= 1) {
1051  // Backward reference for P- or B-frame.
1052  av_assert0(pic->type == PICTURE_TYPE_P ||
1053  pic->type == PICTURE_TYPE_B);
1054  vslice->ref_pic_list0[0] = vpic->reference_frames[0];
1055  }
1056  if (pic->nb_refs >= 2) {
1057  // Forward reference for B-frame.
1058  av_assert0(pic->type == PICTURE_TYPE_B);
1059  vslice->ref_pic_list1[0] = vpic->reference_frames[1];
1060  }
1061 
1062  return 0;
1063 }
1064 
1066 {
1067  VAAPIEncodeContext *ctx = avctx->priv_data;
1068  VAAPIEncodeH265Context *priv = avctx->priv_data;
1069  int err;
1070 
1071  err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_HEVC, avctx);
1072  if (err < 0)
1073  return err;
1074 
1075  if (ctx->va_rc_mode == VA_RC_CQP) {
1076  // Note that VAAPI only supports positive QP values - the range is
1077  // therefore always bounded below by 1, even in 10-bit mode where
1078  // it should go down to -12.
1079 
1080  priv->fixed_qp_p = av_clip(ctx->rc_quality, 1, 51);
1081  if (avctx->i_quant_factor > 0.0)
1082  priv->fixed_qp_idr =
1083  av_clip((avctx->i_quant_factor * priv->fixed_qp_p +
1084  avctx->i_quant_offset) + 0.5, 1, 51);
1085  else
1086  priv->fixed_qp_idr = priv->fixed_qp_p;
1087  if (avctx->b_quant_factor > 0.0)
1088  priv->fixed_qp_b =
1089  av_clip((avctx->b_quant_factor * priv->fixed_qp_p +
1090  avctx->b_quant_offset) + 0.5, 1, 51);
1091  else
1092  priv->fixed_qp_b = priv->fixed_qp_p;
1093 
1094  av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
1095  "%d / %d / %d for IDR- / P- / B-frames.\n",
1096  priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
1097 
1098  } else {
1099  // These still need to be set for init_qp/slice_qp_delta.
1100  priv->fixed_qp_idr = 30;
1101  priv->fixed_qp_p = 30;
1102  priv->fixed_qp_b = 30;
1103  }
1104 
1105  ctx->roi_quant_range = 51 + 6 * (ctx->profile->depth - 8);
1106 
1107  return 0;
1108 }
1109 
1111  { FF_PROFILE_HEVC_MAIN, 8, 3, 1, 1, VAProfileHEVCMain },
1112  { FF_PROFILE_HEVC_REXT, 8, 3, 1, 1, VAProfileHEVCMain },
1113 #if VA_CHECK_VERSION(0, 37, 0)
1114  { FF_PROFILE_HEVC_MAIN_10, 10, 3, 1, 1, VAProfileHEVCMain10 },
1115  { FF_PROFILE_HEVC_REXT, 10, 3, 1, 1, VAProfileHEVCMain10 },
1116 #endif
1117  { FF_PROFILE_UNKNOWN }
1118 };
1119 
1122 
1123  .flags = FLAG_SLICE_CONTROL |
1124  FLAG_B_PICTURES |
1127 
1128  .default_quality = 25,
1129 
1130  .configure = &vaapi_encode_h265_configure,
1131 
1132  .picture_priv_data_size = sizeof(VAAPIEncodeH265Picture),
1133 
1134  .sequence_params_size = sizeof(VAEncSequenceParameterBufferHEVC),
1135  .init_sequence_params = &vaapi_encode_h265_init_sequence_params,
1136 
1137  .picture_params_size = sizeof(VAEncPictureParameterBufferHEVC),
1138  .init_picture_params = &vaapi_encode_h265_init_picture_params,
1139 
1140  .slice_params_size = sizeof(VAEncSliceParameterBufferHEVC),
1141  .init_slice_params = &vaapi_encode_h265_init_slice_params,
1142 
1143  .sequence_header_type = VAEncPackedHeaderSequence,
1144  .write_sequence_header = &vaapi_encode_h265_write_sequence_header,
1145 
1146  .slice_header_type = VAEncPackedHeaderHEVC_Slice,
1147  .write_slice_header = &vaapi_encode_h265_write_slice_header,
1148 
1149  .write_extra_header = &vaapi_encode_h265_write_extra_header,
1150 };
1151 
1153 {
1154  VAAPIEncodeContext *ctx = avctx->priv_data;
1155  VAAPIEncodeH265Context *priv = avctx->priv_data;
1156 
1157  ctx->codec = &vaapi_encode_type_h265;
1158 
1159  if (avctx->profile == FF_PROFILE_UNKNOWN)
1160  avctx->profile = priv->profile;
1161  if (avctx->level == FF_LEVEL_UNKNOWN)
1162  avctx->level = priv->level;
1163 
1164  if (avctx->level != FF_LEVEL_UNKNOWN && avctx->level & ~0xff) {
1165  av_log(avctx, AV_LOG_ERROR, "Invalid level %d: must fit "
1166  "in 8-bit unsigned integer.\n", avctx->level);
1167  return AVERROR(EINVAL);
1168  }
1169 
1170  ctx->desired_packed_headers =
1171  VA_ENC_PACKED_HEADER_SEQUENCE | // VPS, SPS and PPS.
1172  VA_ENC_PACKED_HEADER_SLICE | // Slice headers.
1173  VA_ENC_PACKED_HEADER_MISC; // SEI
1174 
1175  ctx->surface_width = FFALIGN(avctx->width, 16);
1176  ctx->surface_height = FFALIGN(avctx->height, 16);
1177 
1178  // CTU size is currently hard-coded to 32.
1179  ctx->slice_block_width = ctx->slice_block_height = 32;
1180 
1181  if (priv->qp > 0)
1182  ctx->explicit_qp = priv->qp;
1183 
1184  return ff_vaapi_encode_init(avctx);
1185 }
1186 
1188 {
1189  VAAPIEncodeH265Context *priv = avctx->priv_data;
1190 
1192  ff_cbs_close(&priv->cbc);
1193 
1194  return ff_vaapi_encode_close(avctx);
1195 }
1196 
1197 #define OFFSET(x) offsetof(VAAPIEncodeH265Context, x)
1198 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
1202 
1203  { "qp", "Constant QP (for P-frames; scaled by qfactor/qoffset for I/B)",
1204  OFFSET(qp), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 52, FLAGS },
1205 
1206  { "aud", "Include AUD",
1207  OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
1208 
1209  { "profile", "Set profile (general_profile_idc)",
1211  { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 0xff, FLAGS, "profile" },
1212 
1213 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1214  { .i64 = value }, 0, 0, FLAGS, "profile"
1215  { PROFILE("main", FF_PROFILE_HEVC_MAIN) },
1216  { PROFILE("main10", FF_PROFILE_HEVC_MAIN_10) },
1217  { PROFILE("rext", FF_PROFILE_HEVC_REXT) },
1218 #undef PROFILE
1219 
1220  { "tier", "Set tier (general_tier_flag)",
1221  OFFSET(tier), AV_OPT_TYPE_INT,
1222  { .i64 = 0 }, 0, 1, FLAGS, "tier" },
1223  { "main", NULL, 0, AV_OPT_TYPE_CONST,
1224  { .i64 = 0 }, 0, 0, FLAGS, "tier" },
1225  { "high", NULL, 0, AV_OPT_TYPE_CONST,
1226  { .i64 = 1 }, 0, 0, FLAGS, "tier" },
1227 
1228  { "level", "Set level (general_level_idc)",
1230  { .i64 = FF_LEVEL_UNKNOWN }, FF_LEVEL_UNKNOWN, 0xff, FLAGS, "level" },
1231 
1232 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1233  { .i64 = value }, 0, 0, FLAGS, "level"
1234  { LEVEL("1", 30) },
1235  { LEVEL("2", 60) },
1236  { LEVEL("2.1", 63) },
1237  { LEVEL("3", 90) },
1238  { LEVEL("3.1", 93) },
1239  { LEVEL("4", 120) },
1240  { LEVEL("4.1", 123) },
1241  { LEVEL("5", 150) },
1242  { LEVEL("5.1", 153) },
1243  { LEVEL("5.2", 156) },
1244  { LEVEL("6", 180) },
1245  { LEVEL("6.1", 183) },
1246  { LEVEL("6.2", 186) },
1247 #undef LEVEL
1248 
1249  { "sei", "Set SEI to include",
1252  0, INT_MAX, FLAGS, "sei" },
1253  { "hdr",
1254  "Include HDR metadata for mastering display colour volume "
1255  "and content light level information",
1256  0, AV_OPT_TYPE_CONST,
1258  INT_MIN, INT_MAX, FLAGS, "sei" },
1259 
1260  { NULL },
1261 };
1262 
1264  { "b", "0" },
1265  { "bf", "2" },
1266  { "g", "120" },
1267  { "i_qfactor", "1" },
1268  { "i_qoffset", "0" },
1269  { "b_qfactor", "6/5" },
1270  { "b_qoffset", "0" },
1271  { "qmin", "-1" },
1272  { "qmax", "-1" },
1273  { NULL },
1274 };
1275 
1277  .class_name = "h265_vaapi",
1278  .item_name = av_default_item_name,
1279  .option = vaapi_encode_h265_options,
1280  .version = LIBAVUTIL_VERSION_INT,
1281 };
1282 
1284  .name = "hevc_vaapi",
1285  .long_name = NULL_IF_CONFIG_SMALL("H.265/HEVC (VAAPI)"),
1286  .type = AVMEDIA_TYPE_VIDEO,
1287  .id = AV_CODEC_ID_HEVC,
1288  .priv_data_size = sizeof(VAAPIEncodeH265Context),
1290  .send_frame = &ff_vaapi_encode_send_frame,
1291  .receive_packet = &ff_vaapi_encode_receive_packet,
1292  .close = &vaapi_encode_h265_close,
1293  .priv_class = &vaapi_encode_h265_class,
1294  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE,
1295  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1296  .defaults = vaapi_encode_h265_defaults,
1297  .pix_fmts = (const enum AVPixelFormat[]) {
1300  },
1301  .hw_configs = ff_vaapi_encode_hw_configs,
1302  .wrapper_name = "vaapi",
1303 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
uint8_t sps_video_parameter_set_id
Definition: cbs_h265.h:255
uint8_t loop_filter_across_tiles_enabled_flag
Definition: cbs_h265.h:392
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:2069
uint8_t transfer_characteristics
Definition: cbs_h265.h:149
uint8_t pps_pic_parameter_set_id
Definition: cbs_h265.h:357
uint8_t vps_poc_proportional_to_timing_flag
Definition: cbs_h265.h:216
uint8_t num_long_term_pics
Definition: cbs_h265.h:474
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2549
unsigned MaxCLL
Max content light level (cd/m^2).
uint8_t num_ref_idx_l0_default_active_minus1
Definition: cbs_h265.h:366
uint8_t log2_max_mv_length_horizontal
Definition: cbs_h265.h:181
AVOption.
Definition: opt.h:246
uint8_t motion_vectors_over_pic_boundaries_flag
Definition: cbs_h265.h:176
uint8_t sps_sub_layer_ordering_info_present_flag
Definition: cbs_h265.h:281
uint8_t slice_temporal_mvp_enabled_flag
Definition: cbs_h265.h:481
uint8_t general_max_8bit_constraint_flag
Definition: cbs_h265.h:57
static int vaapi_encode_h265_add_nal(AVCodecContext *avctx, CodedBitstreamFragment *au, void *nal_unit)
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
uint8_t bitstream_restriction_flag
Definition: cbs_h265.h:174
const char * desc
Definition: nvenc.c:79
uint8_t bit_depth_luma_minus8
Definition: cbs_h265.h:276
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:150
H265RawSEIContentLightLevelInfo content_light_level
Definition: cbs_h265.h:708
uint8_t vui_timing_info_present_flag
Definition: cbs_h265.h:166
int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:74
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1161
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Content light level (based on CTA-861.3).
Definition: frame.h:136
uint8_t sps_max_sub_layers_minus1
Definition: cbs_h265.h:257
uint16_t slice_pic_order_cnt_lsb
Definition: cbs_h265.h:467
int num
Numerator.
Definition: rational.h:59
uint8_t sps_max_num_reorder_pics[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:283
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
static const AVClass vaapi_encode_h265_class
uint8_t tiles_enabled_flag
Definition: cbs_h265.h:384
int ff_cbs_insert_unit_content(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, AVBufferRef *content_buf)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:722
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:905
int8_t slice_qp_delta
Definition: cbs_h265.h:518
uint8_t restricted_ref_pic_lists_flag
Definition: cbs_h265.h:177
Mastering display metadata associated with a video frame.
Definition: frame.h:119
H265RawProfileTierLevel profile_tier_level
Definition: cbs_h265.h:260
int8_t slice_beta_offset_div2
Definition: cbs_h265.h:528
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
static av_cold int vaapi_encode_h265_close(AVCodecContext *avctx)
uint8_t collocated_from_l0_flag
Definition: cbs_h265.h:497
CodedBitstreamContext * cbc
void * codec_sequence_params
Definition: vaapi_encode.h:271
uint8_t sample_adaptive_offset_enabled_flag
Definition: cbs_h265.h:298
uint8_t vui_parameters_present_flag
Definition: cbs_h265.h:318
uint8_t pcm_sample_bit_depth_luma_minus1
Definition: cbs_h265.h:301
static const AVCodecDefault vaapi_encode_h265_defaults[]
uint8_t bit_depth_chroma_minus8
Definition: cbs_h265.h:277
int profile
profile
Definition: avcodec.h:1859
AVCodec.
Definition: codec.h:190
int8_t delta_chroma_log2_weight_denom
Definition: cbs_h265.h:501
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:838
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
uint8_t general_profile_idc
Definition: cbs_h265.h:46
uint8_t used_by_curr_pic_s0_flag[HEVC_MAX_REFS]
Definition: cbs_h265.h:240
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:649
uint16_t slice_segment_address
Definition: cbs_h265.h:459
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:739
uint32_t vps_num_units_in_tick
Definition: cbs_h265.h:214
uint8_t sign_data_hiding_enabled_flag
Definition: cbs_h265.h:363
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1983
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:72
uint16_t conf_win_right_offset
Definition: cbs_h265.h:272
#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:75
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
H265RawSEIContentLightLevelInfo sei_content_light_level
int ff_vaapi_encode_send_frame(AVCodecContext *avctx, const AVFrame *frame)
uint8_t slice_deblocking_filter_disabled_flag
Definition: cbs_h265.h:527
uint16_t pic_height_in_luma_samples
Definition: cbs_h265.h:268
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
#define av_cold
Definition: attributes.h:88
int8_t slice_tc_offset_div2
Definition: cbs_h265.h:529
AVOptions.
int8_t slice_cb_qp_offset
Definition: cbs_h265.h:519
uint8_t colour_primaries
Definition: cbs_h265.h:148
uint8_t vps_sub_layer_ordering_info_present_flag
Definition: cbs_h265.h:204
uint8_t general_max_12bit_constraint_flag
Definition: cbs_h265.h:55
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:795
uint8_t five_minus_max_num_merge_cand
Definition: cbs_h265.h:515
#define FF_PROFILE_HEVC_MAIN
Definition: avcodec.h:1947
uint8_t video_format
Definition: cbs_h265.h:145
H265RawSTRefPicSet short_term_ref_pic_set
Definition: cbs_h265.h:470
uint8_t vps_timing_info_present_flag
Definition: cbs_h265.h:213
uint8_t log2_max_pic_order_cnt_lsb_minus4
Definition: cbs_h265.h:279
uint8_t constrained_intra_pred_flag
Definition: cbs_h265.h:371
uint32_t sps_max_latency_increase_plus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:284
const char data[16]
Definition: mxf.c:91
Structure to hold side data for an AVFrame.
Definition: frame.h:206
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
uint8_t matrix_coefficients
Definition: cbs_h265.h:150
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
uint8_t aspect_ratio_info_present_flag
Definition: cbs_h265.h:136
uint8_t vps_max_sub_layers_minus1
Definition: cbs_h265.h:199
struct VAAPIEncodePicture * prev
Definition: vaapi_encode.h:116
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
H265RawSEIPayload payload[H265_MAX_SEI_PAYLOADS]
Definition: cbs_h265.h:724
uint8_t general_max_monochrome_constraint_flag
Definition: cbs_h265.h:60
VASurfaceID recon_surface
Definition: vaapi_encode.h:91
uint8_t log2_min_luma_transform_block_size_minus2
Definition: cbs_h265.h:288
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
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
static const uint8_t header[24]
Definition: sdr2.c:67
uint8_t sps_scaling_list_data_present_flag
Definition: cbs_h265.h:294
uint8_t log2_min_pcm_luma_coding_block_size_minus3
Definition: cbs_h265.h:303
static int vaapi_encode_h265_write_access_unit(AVCodecContext *avctx, char *data, size_t *data_len, CodedBitstreamFragment *au)
#define FF_PROFILE_HEVC_MAIN_10
Definition: avcodec.h:1948
uint8_t video_full_range_flag
Definition: cbs_h265.h:146
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1168
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
uint8_t chroma_sample_loc_type_bottom_field
Definition: cbs_h265.h:154
uint16_t vps_num_layer_sets_minus1
Definition: cbs_h265.h:210
uint8_t video_signal_type_present_flag
Definition: cbs_h265.h:144
const char * name
Definition: pixdesc.h:82
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:129
H265RawVUI vui
Definition: cbs_h265.h:319
void ff_cbs_fragment_free(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:157
unsigned int va_rc_mode
Definition: vaapi_encode.h:227
uint32_t vui_num_ticks_poc_diff_one_minus1
Definition: cbs_h265.h:170
uint8_t vps_max_dec_pic_buffering_minus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:205
uint8_t log2_max_mv_length_vertical
Definition: cbs_h265.h:182
AVHWFramesContext * input_frames
Definition: vaapi_encode.h:246
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
union H265RawSEIPayload::@33 payload
uint8_t vps_video_parameter_set_id
Definition: cbs_h265.h:194
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
uint8_t conformance_window_flag
Definition: cbs_h265.h:270
uint8_t max_bits_per_min_cu_denom
Definition: cbs_h265.h:180
#define AVERROR(e)
Definition: error.h:43
static av_cold int vaapi_encode_h265_init(AVCodecContext *avctx)
uint8_t dependent_slice_segment_flag
Definition: cbs_h265.h:458
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:188
uint8_t chroma_loc_info_present_flag
Definition: cbs_h265.h:152
#define PROFILE(name, value)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static int vaapi_encode_h265_init_sequence_params(AVCodecContext *avctx)
uint8_t num_negative_pics
Definition: cbs_h265.h:237
const AVCodecHWConfigInternal * ff_vaapi_encode_hw_configs[]
Definition: vaapi_encode.c:30
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: codec.h:197
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:831
static const AVOption vaapi_encode_h265_options[]
uint8_t general_interlaced_source_flag
Definition: cbs_h265.h:51
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
unsigned int va_bit_rate
Definition: vaapi_encode.h:229
uint8_t general_tier_flag
Definition: cbs_h265.h:45
uint8_t transform_skip_enabled_flag
Definition: cbs_h265.h:372
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:192
uint8_t pcm_sample_bit_depth_chroma_minus1
Definition: cbs_h265.h:302
uint16_t sar_height
Definition: cbs_h265.h:139
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
void * codec_picture_params
Definition: vaapi_encode.h:100
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:133
#define fail()
Definition: checkasm.h:123
uint8_t chroma_sample_loc_type_top_field
Definition: cbs_h265.h:153
uint8_t vps_max_layers_minus1
Definition: cbs_h265.h:198
uint32_t vui_time_scale
Definition: cbs_h265.h:168
static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice)
uint16_t conf_win_bottom_offset
Definition: cbs_h265.h:274
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:446
static const VAAPIEncodeType vaapi_encode_type_h265
uint8_t slice_type
Definition: cbs_h265.h:462
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
uint8_t scaling_list_enabled_flag
Definition: cbs_h265.h:293
uint32_t payload_type
Definition: cbs_h265.h:694
H265RawProfileTierLevel profile_tier_level
Definition: cbs_h265.h:202
#define FFMIN(a, b)
Definition: common.h:96
uint8_t general_max_422chroma_constraint_flag
Definition: cbs_h265.h:58
uint16_t sar_width
Definition: cbs_h265.h:138
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
uint8_t transquant_bypass_enabled_flag
Definition: cbs_h265.h:383
int width
picture width / height.
Definition: avcodec.h:699
uint8_t general_intra_constraint_flag
Definition: cbs_h265.h:61
uint32_t vps_max_latency_increase_plus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:207
uint8_t vui_hrd_parameters_present_flag
Definition: cbs_h265.h:171
#define FLAGS
uint16_t delta_poc_s1_minus1[HEVC_MAX_REFS]
Definition: cbs_h265.h:241
const VAAPIEncodeProfile * profile
Definition: vaapi_encode.h:214
uint8_t diff_cu_qp_delta_depth
Definition: cbs_h265.h:374
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1860
const VAAPIEncodeProfile * profiles
Definition: vaapi_encode.h:352
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
AVCodec ff_hevc_vaapi_encoder
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:254
uint8_t general_non_packed_constraint_flag
Definition: cbs_h265.h:52
AVFormatContext * ctx
Definition: movenc.c:48
uint8_t colour_plane_id
Definition: cbs_h265.h:465
uint8_t sps_seq_parameter_set_id
Definition: cbs_h265.h:262
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1140
int level
level
Definition: avcodec.h:1982
AVFrame * input_image
Definition: vaapi_encode.h:87
uint16_t pic_width_in_luma_samples
Definition: cbs_h265.h:267
void * codec_picture_params
Definition: vaapi_encode.h:275
static int vaapi_encode_h265_init_picture_params(AVCodecContext *avctx, VAAPIEncodePicture *pic)
uint8_t vps_base_layer_available_flag
Definition: cbs_h265.h:197
int ff_vaapi_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
uint8_t log2_min_luma_coding_block_size_minus3
Definition: cbs_h265.h:286
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:122
uint8_t pps_seq_parameter_set_id
Definition: cbs_h265.h:358
#define FF_ARRAY_ELEMS(a)
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:535
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:340
uint16_t vps_num_hrd_parameters
Definition: cbs_h265.h:218
uint8_t num_ref_idx_l1_active_minus1
Definition: cbs_h265.h:488
uint8_t general_max_420chroma_constraint_flag
Definition: cbs_h265.h:59
struct VAAPIEncodePicture * refs[MAX_PICTURE_REFERENCES]
Definition: vaapi_encode.h:113
uint8_t used_by_curr_pic_s1_flag[HEVC_MAX_REFS]
Definition: cbs_h265.h:242
#define OFFSET(x)
const H265LevelDescriptor * ff_h265_guess_level(const H265RawProfileTierLevel *ptl, int64_t bitrate, int width, int height, int slice_segments, int tile_rows, int tile_cols, int max_dec_pic_buffering)
Guess the level of a stream from some parameters.
uint8_t max_bytes_per_pic_denom
Definition: cbs_h265.h:179
uint8_t num_ref_idx_l0_active_minus1
Definition: cbs_h265.h:487
uint8_t payload_count
Definition: cbs_h265.h:725
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:253
static int vaapi_encode_h265_write_slice_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice, char *data, size_t *data_len)
const struct VAAPIEncodeType * codec
Definition: vaapi_encode.h:176
uint8_t log2_diff_max_min_pcm_luma_coding_block_size
Definition: cbs_h265.h:304
Libavcodec external API header.
#define VAAPI_ENCODE_RC_OPTIONS
Definition: vaapi_encode.h:447
uint8_t entropy_coding_sync_enabled_flag
Definition: cbs_h265.h:385
uint8_t weighted_bipred_flag
Definition: cbs_h265.h:381
uint16_t conf_win_top_offset
Definition: cbs_h265.h:273
uint8_t sps_temporal_mvp_enabled_flag
Definition: cbs_h265.h:315
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
uint8_t general_level_idc
Definition: cbs_h265.h:68
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
main external API structure.
Definition: avcodec.h:526
int8_t slice_cr_qp_offset
Definition: cbs_h265.h:520
uint32_t vui_num_units_in_tick
Definition: cbs_h265.h:167
uint8_t short_term_ref_pic_set_sps_flag
Definition: cbs_h265.h:469
uint8_t slice_loop_filter_across_slices_enabled_flag
Definition: cbs_h265.h:530
uint8_t luma_log2_weight_denom
Definition: cbs_h265.h:500
uint8_t max_transform_hierarchy_depth_intra
Definition: cbs_h265.h:291
uint8_t mvd_l1_zero_flag
Definition: cbs_h265.h:495
uint8_t * data
Definition: frame.h:208
uint8_t pps_loop_filter_across_slices_enabled_flag
Definition: cbs_h265.h:394
uint8_t weighted_pred_flag
Definition: cbs_h265.h:380
uint8_t sps_temporal_id_nesting_flag
Definition: cbs_h265.h:258
int8_t pps_cb_qp_offset
Definition: cbs_h265.h:376
H265RawSEIMasteringDisplayColourVolume mastering_display
Definition: cbs_h265.h:707
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
uint8_t vps_max_layer_id
Definition: cbs_h265.h:209
uint16_t conf_win_left_offset
Definition: cbs_h265.h:271
Describe the class of an AVClass context structure.
Definition: log.h:67
uint8_t collocated_ref_idx
Definition: cbs_h265.h:498
void ff_cbs_fragment_reset(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment&#39;s own data buffer, but not the units a...
Definition: cbs.c:142
uint8_t amp_enabled_flag
Definition: cbs_h265.h:297
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Context structure for coded bitstream operations.
Definition: cbs.h:168
int index
Definition: gxfenc.c:89
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
Mastering display metadata capable of representing the color volume of the display used to master the...
uint8_t general_max_10bit_constraint_flag
Definition: cbs_h265.h:56
static int vaapi_encode_h265_write_extra_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, int index, int *type, char *data, size_t *data_len)
cl_device_type type
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
uint8_t chroma_format_idc
Definition: cbs_h265.h:264
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:115
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:808
uint8_t general_lower_bit_rate_constraint_flag
Definition: cbs_h265.h:63
uint8_t general_profile_compatibility_flag[32]
Definition: cbs_h265.h:48
uint8_t vps_base_layer_internal_flag
Definition: cbs_h265.h:196
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
mfxU16 profile
Definition: qsvenc.c:45
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
uint8_t pcm_loop_filter_disabled_flag
Definition: cbs_h265.h:305
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:355
#define VAAPI_ENCODE_COMMON_OPTIONS
Definition: vaapi_encode.h:429
static int vaapi_encode_h265_write_sequence_header(AVCodecContext *avctx, char *data, size_t *data_len)
uint8_t num_positive_pics
Definition: cbs_h265.h:238
uint8_t general_frame_only_constraint_flag
Definition: cbs_h265.h:53
uint8_t level
Definition: svq3.c:210
int8_t pps_cr_qp_offset
Definition: cbs_h265.h:377
static const VAAPIEncodeProfile vaapi_encode_h265_profiles[]
uint8_t slice_pic_parameter_set_id
Definition: cbs_h265.h:456
uint8_t vui_poc_proportional_to_timing_flag
Definition: cbs_h265.h:169
uint8_t general_progressive_source_flag
Definition: cbs_h265.h:50
uint8_t max_transform_hierarchy_depth_inter
Definition: cbs_h265.h:290
static av_cold int vaapi_encode_h265_configure(AVCodecContext *avctx)
VAAPIEncodeContext common
common internal api header.
common internal and external API header
if(ret< 0)
Definition: vf_mcdeint.c:279
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
uint8_t pps_scaling_list_data_present_flag
Definition: cbs_h265.h:401
uint8_t cabac_init_flag
Definition: cbs_h265.h:496
uint8_t num_tile_rows_minus1
Definition: cbs_h265.h:388
uint8_t pcm_enabled_flag
Definition: cbs_h265.h:300
uint8_t slice_sao_luma_flag
Definition: cbs_h265.h:483
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
uint8_t num_tile_columns_minus1
Definition: cbs_h265.h:387
int den
Denominator.
Definition: rational.h:60
uint16_t delta_poc_s0_minus1[HEVC_MAX_REFS]
Definition: cbs_h265.h:239
uint8_t log2_diff_max_min_luma_coding_block_size
Definition: cbs_h265.h:287
CodedBitstreamFragment current_access_unit
uint8_t slice_sao_chroma_flag
Definition: cbs_h265.h:484
#define FF_PROFILE_HEVC_REXT
Definition: avcodec.h:1950
void * priv_data
Definition: avcodec.h:553
uint8_t vps_max_num_reorder_pics[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:206
H265RawSliceHeader header
Definition: cbs_h265.h:542
H265RawSEIMasteringDisplayColourVolume sei_mastering_display
uint32_t vps_time_scale
Definition: cbs_h265.h:215
uint8_t num_short_term_ref_pic_sets
Definition: cbs_h265.h:307
void * codec_slice_params
Definition: vaapi_encode.h:64
uint8_t log2_parallel_merge_level_minus2
Definition: cbs_h265.h:405
uint8_t vps_temporal_id_nesting_flag
Definition: cbs_h265.h:200
#define lrint
Definition: tablegen.h:53
uint8_t aspect_ratio_idc
Definition: cbs_h265.h:137
unsigned int desired_packed_headers
Definition: vaapi_encode.h:198
#define LEVEL(name, value)
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:452
uint8_t num_long_term_sps
Definition: cbs_h265.h:473
uint8_t general_profile_space
Definition: cbs_h265.h:44
uint8_t sps_max_dec_pic_buffering_minus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:282
#define FFSWAP(type, a, b)
Definition: common.h:99
int8_t init_qp_minus26
Definition: cbs_h265.h:369
uint32_t vps_num_ticks_poc_diff_one_minus1
Definition: cbs_h265.h:217
int depth
Number of bits in the component.
Definition: pixdesc.h:58
uint8_t separate_colour_plane_flag
Definition: cbs_h265.h:265
VABufferID output_buffer
Definition: vaapi_encode.h:97
uint8_t strong_intra_smoothing_enabled_flag
Definition: cbs_h265.h:316
uint8_t colour_description_present_flag
Definition: cbs_h265.h:147
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:222
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
unsigned MaxFALL
Max average light level per frame (cd/m^2).
struct VAAPIEncodePicture * dpb[MAX_DPB_SIZE]
Definition: vaapi_encode.h:109
uint8_t log2_diff_max_min_luma_transform_block_size
Definition: cbs_h265.h:289
uint8_t long_term_ref_pics_present_flag
Definition: cbs_h265.h:310
uint8_t num_ref_idx_active_override_flag
Definition: cbs_h265.h:486
uint8_t layer_id_included_flag[HEVC_MAX_LAYER_SETS][HEVC_MAX_LAYERS]
Definition: cbs_h265.h:211
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
uint8_t nal_unit_type
Definition: cbs_h265.h:38
uint8_t num_ref_idx_l1_default_active_minus1
Definition: cbs_h265.h:367
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:722
uint8_t first_slice_segment_in_pic_flag
Definition: cbs_h265.h:454
uint8_t cu_qp_delta_enabled_flag
Definition: cbs_h265.h:373
bitstream writer API