FFmpeg
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/mem.h"
27 #include "libavutil/pixdesc.h"
28 #include "libavutil/opt.h"
30 
31 #include "atsc_a53.h"
32 #include "avcodec.h"
33 #include "cbs.h"
34 #include "cbs_h265.h"
35 #include "codec_internal.h"
36 #include "h2645data.h"
37 #include "h265_profile_level.h"
38 #include "hevc.h"
39 #include "vaapi_encode.h"
40 
41 enum {
44  SEI_A53_CC = 0x20,
45 };
46 
47 typedef struct VAAPIEncodeH265Picture {
49 
50  int64_t last_idr_frame;
51 
54  int pic_type;
56 
57 typedef struct VAAPIEncodeH265Context {
59 
60  // Encoder features.
61  uint32_t va_features;
62  // Block size info.
63  uint32_t va_bs;
64  uint32_t ctu_size;
65  uint32_t min_cb_size;
66 
67  // User options.
68  int qp;
69  int aud;
70  int profile;
71  int tier;
72  int level;
73  int sei;
74 
75  // Derived settings.
79 
80  // Writer structures.
86 
91 
97 
98 
100  char *data, size_t *data_len,
102 {
103  VAAPIEncodeH265Context *priv = avctx->priv_data;
104  int err;
105 
106  err = ff_cbs_write_fragment_data(priv->cbc, au);
107  if (err < 0) {
108  av_log(avctx, AV_LOG_ERROR, "Failed to write packed header.\n");
109  return err;
110  }
111 
112  if (*data_len < 8 * au->data_size - au->data_bit_padding) {
113  av_log(avctx, AV_LOG_ERROR, "Access unit too large: "
114  "%zu < %zu.\n", *data_len,
115  8 * au->data_size - au->data_bit_padding);
116  return AVERROR(ENOSPC);
117  }
118 
119  memcpy(data, au->data, au->data_size);
120  *data_len = 8 * au->data_size - au->data_bit_padding;
121 
122  return 0;
123 }
124 
127  void *nal_unit)
128 {
129  H265RawNALUnitHeader *header = nal_unit;
130  int err;
131 
132  err = ff_cbs_insert_unit_content(au, -1,
133  header->nal_unit_type, nal_unit, NULL);
134  if (err < 0) {
135  av_log(avctx, AV_LOG_ERROR, "Failed to add NAL unit: "
136  "type = %d.\n", header->nal_unit_type);
137  return err;
138  }
139 
140  return 0;
141 }
142 
144  char *data, size_t *data_len)
145 {
146  VAAPIEncodeH265Context *priv = avctx->priv_data;
148  int err;
149 
150  if (priv->aud_needed) {
151  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_aud);
152  if (err < 0)
153  goto fail;
154  priv->aud_needed = 0;
155  }
156 
157  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_vps);
158  if (err < 0)
159  goto fail;
160 
161  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_sps);
162  if (err < 0)
163  goto fail;
164 
165  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_pps);
166  if (err < 0)
167  goto fail;
168 
169  err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
170 fail:
172  return err;
173 }
174 
176  VAAPIEncodePicture *pic,
177  VAAPIEncodeSlice *slice,
178  char *data, size_t *data_len)
179 {
180  VAAPIEncodeH265Context *priv = avctx->priv_data;
182  int err;
183 
184  if (priv->aud_needed) {
185  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_aud);
186  if (err < 0)
187  goto fail;
188  priv->aud_needed = 0;
189  }
190 
191  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_slice);
192  if (err < 0)
193  goto fail;
194 
195  err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
196 fail:
198  return err;
199 }
200 
202  VAAPIEncodePicture *pic,
203  int index, int *type,
204  char *data, size_t *data_len)
205 {
206  VAAPIEncodeH265Context *priv = avctx->priv_data;
208  int err;
209 
210  if (priv->sei_needed) {
211  if (priv->aud_needed) {
212  err = vaapi_encode_h265_add_nal(avctx, au, &priv->aud);
213  if (err < 0)
214  goto fail;
215  priv->aud_needed = 0;
216  }
217 
218  if (priv->sei_needed & SEI_MASTERING_DISPLAY) {
219  err = ff_cbs_sei_add_message(priv->cbc, au, 1,
221  &priv->sei_mastering_display, NULL);
222  if (err < 0)
223  goto fail;
224  }
225 
226  if (priv->sei_needed & SEI_CONTENT_LIGHT_LEVEL) {
227  err = ff_cbs_sei_add_message(priv->cbc, au, 1,
229  &priv->sei_content_light_level, NULL);
230  if (err < 0)
231  goto fail;
232  }
233  if (priv->sei_needed & SEI_A53_CC) {
234  err = ff_cbs_sei_add_message(priv->cbc, au, 1,
236  &priv->sei_a53cc, NULL);
237  if (err < 0)
238  goto fail;
239  }
240 
241  priv->sei_needed = 0;
242 
243  err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
244  if (err < 0)
245  goto fail;
246 
248 
249  *type = VAEncPackedHeaderRawData;
250  return 0;
251  } else {
252  return AVERROR_EOF;
253  }
254 
255 fail:
257  return err;
258 }
259 
261 {
262  VAAPIEncodeContext *ctx = avctx->priv_data;
263  VAAPIEncodeH265Context *priv = avctx->priv_data;
264  H265RawVPS *vps = &priv->raw_vps;
265  H265RawSPS *sps = &priv->raw_sps;
266  H265RawPPS *pps = &priv->raw_pps;
267  H265RawProfileTierLevel *ptl = &vps->profile_tier_level;
268  H265RawVUI *vui = &sps->vui;
269  VAEncSequenceParameterBufferHEVC *vseq = ctx->codec_sequence_params;
270  VAEncPictureParameterBufferHEVC *vpic = ctx->codec_picture_params;
271  const AVPixFmtDescriptor *desc;
272  int chroma_format, bit_depth;
273  int i;
274 
275  memset(vps, 0, sizeof(*vps));
276  memset(sps, 0, sizeof(*sps));
277  memset(pps, 0, sizeof(*pps));
278 
279 
281  av_assert0(desc);
282  if (desc->nb_components == 1) {
283  chroma_format = 0;
284  } else {
285  if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1) {
286  chroma_format = 1;
287  } else if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 0) {
288  chroma_format = 2;
289  } else if (desc->log2_chroma_w == 0 && desc->log2_chroma_h == 0) {
290  chroma_format = 3;
291  } else {
292  av_log(avctx, AV_LOG_ERROR, "Chroma format of input pixel format "
293  "%s is not supported.\n", desc->name);
294  return AVERROR(EINVAL);
295  }
296  }
297  bit_depth = desc->comp[0].depth;
298 
299 
300  // VPS
301 
302  vps->nal_unit_header = (H265RawNALUnitHeader) {
303  .nal_unit_type = HEVC_NAL_VPS,
304  .nuh_layer_id = 0,
305  .nuh_temporal_id_plus1 = 1,
306  };
307 
308  vps->vps_video_parameter_set_id = 0;
309 
310  vps->vps_base_layer_internal_flag = 1;
311  vps->vps_base_layer_available_flag = 1;
312  vps->vps_max_layers_minus1 = 0;
313  vps->vps_max_sub_layers_minus1 = 0;
314  vps->vps_temporal_id_nesting_flag = 1;
315 
317  ptl->general_profile_idc = avctx->profile;
318  ptl->general_tier_flag = priv->tier;
319 
321 
327  }
328 
333 
338 
339  ptl->general_max_422chroma_constraint_flag = chroma_format <= 2;
340  ptl->general_max_420chroma_constraint_flag = chroma_format <= 1;
341  ptl->general_max_monochrome_constraint_flag = chroma_format == 0;
342 
343  ptl->general_intra_constraint_flag = ctx->gop_size == 1;
345 
347 
348  if (avctx->level != AV_LEVEL_UNKNOWN) {
349  ptl->general_level_idc = avctx->level;
350  } else {
351  const H265LevelDescriptor *level;
352 
354  ctx->surface_width, ctx->surface_height,
355  ctx->nb_slices, ctx->tile_rows, ctx->tile_cols,
356  (ctx->b_per_p > 0) + 1);
357  if (level) {
358  av_log(avctx, AV_LOG_VERBOSE, "Using level %s.\n", level->name);
359  ptl->general_level_idc = level->level_idc;
360  } else {
361  av_log(avctx, AV_LOG_VERBOSE, "Stream will not conform to "
362  "any normal level; using level 8.5.\n");
363  ptl->general_level_idc = 255;
364  // The tier flag must be set in level 8.5.
365  ptl->general_tier_flag = 1;
366  }
367  }
368 
369  vps->vps_sub_layer_ordering_info_present_flag = 0;
370  vps->vps_max_dec_pic_buffering_minus1[0] = ctx->max_b_depth + 1;
371  vps->vps_max_num_reorder_pics[0] = ctx->max_b_depth;
372  vps->vps_max_latency_increase_plus1[0] = 0;
373 
374  vps->vps_max_layer_id = 0;
375  vps->vps_num_layer_sets_minus1 = 0;
376  vps->layer_id_included_flag[0][0] = 1;
377 
378  vps->vps_timing_info_present_flag = 1;
379  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
380  vps->vps_num_units_in_tick = avctx->framerate.den;
381  vps->vps_time_scale = avctx->framerate.num;
382  vps->vps_poc_proportional_to_timing_flag = 1;
383  vps->vps_num_ticks_poc_diff_one_minus1 = 0;
384  } else {
385  vps->vps_num_units_in_tick = avctx->time_base.num;
386  vps->vps_time_scale = avctx->time_base.den;
387  vps->vps_poc_proportional_to_timing_flag = 0;
388  }
389  vps->vps_num_hrd_parameters = 0;
390 
391 
392  // SPS
393 
394  sps->nal_unit_header = (H265RawNALUnitHeader) {
395  .nal_unit_type = HEVC_NAL_SPS,
396  .nuh_layer_id = 0,
397  .nuh_temporal_id_plus1 = 1,
398  };
399 
400  sps->sps_video_parameter_set_id = vps->vps_video_parameter_set_id;
401 
402  sps->sps_max_sub_layers_minus1 = vps->vps_max_sub_layers_minus1;
403  sps->sps_temporal_id_nesting_flag = vps->vps_temporal_id_nesting_flag;
404 
405  sps->profile_tier_level = vps->profile_tier_level;
406 
407  sps->sps_seq_parameter_set_id = 0;
408 
409  sps->chroma_format_idc = chroma_format;
410  sps->separate_colour_plane_flag = 0;
411 
412  sps->pic_width_in_luma_samples = ctx->surface_width;
413  sps->pic_height_in_luma_samples = ctx->surface_height;
414 
415  if (avctx->width != ctx->surface_width ||
416  avctx->height != ctx->surface_height) {
417  sps->conformance_window_flag = 1;
418  sps->conf_win_left_offset = 0;
419  sps->conf_win_right_offset =
420  (ctx->surface_width - avctx->width) >> desc->log2_chroma_w;
421  sps->conf_win_top_offset = 0;
422  sps->conf_win_bottom_offset =
423  (ctx->surface_height - avctx->height) >> desc->log2_chroma_h;
424  } else {
425  sps->conformance_window_flag = 0;
426  }
427 
428  sps->bit_depth_luma_minus8 = bit_depth - 8;
429  sps->bit_depth_chroma_minus8 = bit_depth - 8;
430 
431  sps->log2_max_pic_order_cnt_lsb_minus4 = 8;
432 
433  sps->sps_sub_layer_ordering_info_present_flag =
434  vps->vps_sub_layer_ordering_info_present_flag;
435  for (i = 0; i <= sps->sps_max_sub_layers_minus1; i++) {
436  sps->sps_max_dec_pic_buffering_minus1[i] =
437  vps->vps_max_dec_pic_buffering_minus1[i];
438  sps->sps_max_num_reorder_pics[i] =
439  vps->vps_max_num_reorder_pics[i];
440  sps->sps_max_latency_increase_plus1[i] =
441  vps->vps_max_latency_increase_plus1[i];
442  }
443 
444  // These values come from the capabilities of the first encoder
445  // implementation in the i965 driver on Intel Skylake. They may
446  // fail badly with other platforms or drivers.
447  // CTB size from 8x8 to 32x32.
448  sps->log2_min_luma_coding_block_size_minus3 = 0;
449  sps->log2_diff_max_min_luma_coding_block_size = 2;
450  // Transform size from 4x4 to 32x32.
451  sps->log2_min_luma_transform_block_size_minus2 = 0;
452  sps->log2_diff_max_min_luma_transform_block_size = 3;
453  // Full transform hierarchy allowed (2-5).
454  sps->max_transform_hierarchy_depth_inter = 3;
455  sps->max_transform_hierarchy_depth_intra = 3;
456  // AMP works.
457  sps->amp_enabled_flag = 1;
458  // SAO and temporal MVP do not work.
459  sps->sample_adaptive_offset_enabled_flag = 0;
460  sps->sps_temporal_mvp_enabled_flag = 0;
461 
462  sps->pcm_enabled_flag = 0;
463 
464 // update sps setting according to queried result
465 #if VA_CHECK_VERSION(1, 13, 0)
466  if (priv->va_features) {
467  VAConfigAttribValEncHEVCFeatures features = { .value = priv->va_features };
468 
469  // Enable feature if get queried result is VA_FEATURE_SUPPORTED | VA_FEATURE_REQUIRED
470  sps->amp_enabled_flag =
471  !!features.bits.amp;
472  sps->sample_adaptive_offset_enabled_flag =
473  !!features.bits.sao;
474  sps->sps_temporal_mvp_enabled_flag =
475  !!features.bits.temporal_mvp;
476  sps->pcm_enabled_flag =
477  !!features.bits.pcm;
478  }
479 
480  if (priv->va_bs) {
481  VAConfigAttribValEncHEVCBlockSizes bs = { .value = priv->va_bs };
482  sps->log2_min_luma_coding_block_size_minus3 =
483  ff_ctz(priv->min_cb_size) - 3;
484  sps->log2_diff_max_min_luma_coding_block_size =
485  ff_ctz(priv->ctu_size) - ff_ctz(priv->min_cb_size);
486 
487  sps->log2_min_luma_transform_block_size_minus2 =
488  bs.bits.log2_min_luma_transform_block_size_minus2;
489  sps->log2_diff_max_min_luma_transform_block_size =
490  bs.bits.log2_max_luma_transform_block_size_minus2 -
491  bs.bits.log2_min_luma_transform_block_size_minus2;
492 
493  sps->max_transform_hierarchy_depth_inter =
494  bs.bits.max_max_transform_hierarchy_depth_inter;
495  sps->max_transform_hierarchy_depth_intra =
496  bs.bits.max_max_transform_hierarchy_depth_intra;
497  }
498 #endif
499 
500  // STRPSs should ideally be here rather than defined individually in
501  // each slice, but the structure isn't completely fixed so for now
502  // don't bother.
503  sps->num_short_term_ref_pic_sets = 0;
504  sps->long_term_ref_pics_present_flag = 0;
505 
506  sps->vui_parameters_present_flag = 1;
507 
508  if (avctx->sample_aspect_ratio.num != 0 &&
509  avctx->sample_aspect_ratio.den != 0) {
510  int num, den, i;
511  av_reduce(&num, &den, avctx->sample_aspect_ratio.num,
512  avctx->sample_aspect_ratio.den, 65535);
513  for (i = 0; i < FF_ARRAY_ELEMS(ff_h2645_pixel_aspect); i++) {
514  if (num == ff_h2645_pixel_aspect[i].num &&
515  den == ff_h2645_pixel_aspect[i].den) {
516  vui->aspect_ratio_idc = i;
517  break;
518  }
519  }
521  vui->aspect_ratio_idc = 255;
522  vui->sar_width = num;
523  vui->sar_height = den;
524  }
526  }
527 
528  // Unspecified video format, from table E-2.
529  vui->video_format = 5;
530  vui->video_full_range_flag =
531  avctx->color_range == AVCOL_RANGE_JPEG;
532  vui->colour_primaries = avctx->color_primaries;
533  vui->transfer_characteristics = avctx->color_trc;
534  vui->matrix_coefficients = avctx->colorspace;
535  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
536  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
539  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED ||
542 
547  avctx->chroma_sample_location - 1;
548  }
549 
551  vui->vui_num_units_in_tick = vps->vps_num_units_in_tick;
552  vui->vui_time_scale = vps->vps_time_scale;
553  vui->vui_poc_proportional_to_timing_flag = vps->vps_poc_proportional_to_timing_flag;
554  vui->vui_num_ticks_poc_diff_one_minus1 = vps->vps_num_ticks_poc_diff_one_minus1;
556 
560  vui->max_bytes_per_pic_denom = 0;
561  vui->max_bits_per_min_cu_denom = 0;
563  vui->log2_max_mv_length_vertical = 15;
564 
565 
566  // PPS
567 
568  pps->nal_unit_header = (H265RawNALUnitHeader) {
569  .nal_unit_type = HEVC_NAL_PPS,
570  .nuh_layer_id = 0,
571  .nuh_temporal_id_plus1 = 1,
572  };
573 
574  pps->pps_pic_parameter_set_id = 0;
575  pps->pps_seq_parameter_set_id = sps->sps_seq_parameter_set_id;
576 
577  pps->num_ref_idx_l0_default_active_minus1 = 0;
578  pps->num_ref_idx_l1_default_active_minus1 = 0;
579 
580  pps->init_qp_minus26 = priv->fixed_qp_idr - 26;
581 
582  pps->cu_qp_delta_enabled_flag = (ctx->va_rc_mode != VA_RC_CQP);
583  pps->diff_cu_qp_delta_depth = 0;
584 
585 // update pps setting according to queried result
586 #if VA_CHECK_VERSION(1, 13, 0)
587  if (priv->va_features) {
588  VAConfigAttribValEncHEVCFeatures features = { .value = priv->va_features };
589  if (ctx->va_rc_mode != VA_RC_CQP)
590  pps->cu_qp_delta_enabled_flag =
591  !!features.bits.cu_qp_delta;
592 
593  pps->transform_skip_enabled_flag =
594  !!features.bits.transform_skip;
595  // set diff_cu_qp_delta_depth as its max value if cu_qp_delta enabled. Otherwise
596  // 0 will make cu_qp_delta invalid.
597  if (pps->cu_qp_delta_enabled_flag)
598  pps->diff_cu_qp_delta_depth = sps->log2_diff_max_min_luma_coding_block_size;
599  }
600 #endif
601 
602  if (ctx->tile_rows && ctx->tile_cols) {
603  int uniform_spacing;
604 
605  pps->tiles_enabled_flag = 1;
606  pps->num_tile_columns_minus1 = ctx->tile_cols - 1;
607  pps->num_tile_rows_minus1 = ctx->tile_rows - 1;
608 
609  // Test whether the spacing provided matches the H.265 uniform
610  // spacing, and set the flag if it does.
611  uniform_spacing = 1;
612  for (i = 0; i <= pps->num_tile_columns_minus1 &&
613  uniform_spacing; i++) {
614  if (ctx->col_width[i] !=
615  (i + 1) * ctx->slice_block_cols / ctx->tile_cols -
616  i * ctx->slice_block_cols / ctx->tile_cols)
617  uniform_spacing = 0;
618  }
619  for (i = 0; i <= pps->num_tile_rows_minus1 &&
620  uniform_spacing; i++) {
621  if (ctx->row_height[i] !=
622  (i + 1) * ctx->slice_block_rows / ctx->tile_rows -
623  i * ctx->slice_block_rows / ctx->tile_rows)
624  uniform_spacing = 0;
625  }
626  pps->uniform_spacing_flag = uniform_spacing;
627 
628  for (i = 0; i <= pps->num_tile_columns_minus1; i++)
629  pps->column_width_minus1[i] = ctx->col_width[i] - 1;
630  for (i = 0; i <= pps->num_tile_rows_minus1; i++)
631  pps->row_height_minus1[i] = ctx->row_height[i] - 1;
632 
633  pps->loop_filter_across_tiles_enabled_flag = 1;
634  }
635 
636  pps->pps_loop_filter_across_slices_enabled_flag = 1;
637 
638  // Fill VAAPI parameter buffers.
639 
640  *vseq = (VAEncSequenceParameterBufferHEVC) {
641  .general_profile_idc = vps->profile_tier_level.general_profile_idc,
642  .general_level_idc = vps->profile_tier_level.general_level_idc,
643  .general_tier_flag = vps->profile_tier_level.general_tier_flag,
644 
645  .intra_period = ctx->gop_size,
646  .intra_idr_period = ctx->gop_size,
647  .ip_period = ctx->b_per_p + 1,
648  .bits_per_second = ctx->va_bit_rate,
649 
650  .pic_width_in_luma_samples = sps->pic_width_in_luma_samples,
651  .pic_height_in_luma_samples = sps->pic_height_in_luma_samples,
652 
653  .seq_fields.bits = {
654  .chroma_format_idc = sps->chroma_format_idc,
655  .separate_colour_plane_flag = sps->separate_colour_plane_flag,
656  .bit_depth_luma_minus8 = sps->bit_depth_luma_minus8,
657  .bit_depth_chroma_minus8 = sps->bit_depth_chroma_minus8,
658  .scaling_list_enabled_flag = sps->scaling_list_enabled_flag,
659  .strong_intra_smoothing_enabled_flag =
660  sps->strong_intra_smoothing_enabled_flag,
661  .amp_enabled_flag = sps->amp_enabled_flag,
662  .sample_adaptive_offset_enabled_flag =
663  sps->sample_adaptive_offset_enabled_flag,
664  .pcm_enabled_flag = sps->pcm_enabled_flag,
665  .pcm_loop_filter_disabled_flag = sps->pcm_loop_filter_disabled_flag,
666  .sps_temporal_mvp_enabled_flag = sps->sps_temporal_mvp_enabled_flag,
667  },
668 
669  .log2_min_luma_coding_block_size_minus3 =
670  sps->log2_min_luma_coding_block_size_minus3,
671  .log2_diff_max_min_luma_coding_block_size =
672  sps->log2_diff_max_min_luma_coding_block_size,
673  .log2_min_transform_block_size_minus2 =
674  sps->log2_min_luma_transform_block_size_minus2,
675  .log2_diff_max_min_transform_block_size =
676  sps->log2_diff_max_min_luma_transform_block_size,
677  .max_transform_hierarchy_depth_inter =
678  sps->max_transform_hierarchy_depth_inter,
679  .max_transform_hierarchy_depth_intra =
680  sps->max_transform_hierarchy_depth_intra,
681 
682  .pcm_sample_bit_depth_luma_minus1 =
683  sps->pcm_sample_bit_depth_luma_minus1,
684  .pcm_sample_bit_depth_chroma_minus1 =
685  sps->pcm_sample_bit_depth_chroma_minus1,
686  .log2_min_pcm_luma_coding_block_size_minus3 =
687  sps->log2_min_pcm_luma_coding_block_size_minus3,
688  .log2_max_pcm_luma_coding_block_size_minus3 =
689  sps->log2_min_pcm_luma_coding_block_size_minus3 +
690  sps->log2_diff_max_min_pcm_luma_coding_block_size,
691 
692  .vui_parameters_present_flag = 0,
693  };
694 
695  *vpic = (VAEncPictureParameterBufferHEVC) {
696  .decoded_curr_pic = {
697  .picture_id = VA_INVALID_ID,
698  .flags = VA_PICTURE_HEVC_INVALID,
699  },
700 
701  .coded_buf = VA_INVALID_ID,
702 
703  .collocated_ref_pic_index = sps->sps_temporal_mvp_enabled_flag ?
704  0 : 0xff,
705  .last_picture = 0,
706 
707  .pic_init_qp = pps->init_qp_minus26 + 26,
708  .diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth,
709  .pps_cb_qp_offset = pps->pps_cb_qp_offset,
710  .pps_cr_qp_offset = pps->pps_cr_qp_offset,
711 
712  .num_tile_columns_minus1 = pps->num_tile_columns_minus1,
713  .num_tile_rows_minus1 = pps->num_tile_rows_minus1,
714 
715  .log2_parallel_merge_level_minus2 = pps->log2_parallel_merge_level_minus2,
716  .ctu_max_bitsize_allowed = 0,
717 
718  .num_ref_idx_l0_default_active_minus1 =
719  pps->num_ref_idx_l0_default_active_minus1,
720  .num_ref_idx_l1_default_active_minus1 =
721  pps->num_ref_idx_l1_default_active_minus1,
722 
723  .slice_pic_parameter_set_id = pps->pps_pic_parameter_set_id,
724 
725  .pic_fields.bits = {
726  .sign_data_hiding_enabled_flag = pps->sign_data_hiding_enabled_flag,
727  .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
728  .transform_skip_enabled_flag = pps->transform_skip_enabled_flag,
729  .cu_qp_delta_enabled_flag = pps->cu_qp_delta_enabled_flag,
730  .weighted_pred_flag = pps->weighted_pred_flag,
731  .weighted_bipred_flag = pps->weighted_bipred_flag,
732  .transquant_bypass_enabled_flag = pps->transquant_bypass_enabled_flag,
733  .tiles_enabled_flag = pps->tiles_enabled_flag,
734  .entropy_coding_sync_enabled_flag = pps->entropy_coding_sync_enabled_flag,
735  .loop_filter_across_tiles_enabled_flag =
736  pps->loop_filter_across_tiles_enabled_flag,
737  .pps_loop_filter_across_slices_enabled_flag =
738  pps->pps_loop_filter_across_slices_enabled_flag,
739  .scaling_list_data_present_flag = (sps->sps_scaling_list_data_present_flag |
740  pps->pps_scaling_list_data_present_flag),
741  .screen_content_flag = 0,
742  .enable_gpu_weighted_prediction = 0,
743  .no_output_of_prior_pics_flag = 0,
744  },
745  };
746 
747  if (pps->tiles_enabled_flag) {
748  for (i = 0; i <= vpic->num_tile_rows_minus1; i++)
749  vpic->row_height_minus1[i] = pps->row_height_minus1[i];
750  for (i = 0; i <= vpic->num_tile_columns_minus1; i++)
751  vpic->column_width_minus1[i] = pps->column_width_minus1[i];
752  }
753 
754  return 0;
755 }
756 
758  VAAPIEncodePicture *pic)
759 {
760  VAAPIEncodeContext *ctx = avctx->priv_data;
761  VAAPIEncodeH265Context *priv = avctx->priv_data;
762  VAAPIEncodeH265Picture *hpic = pic->priv_data;
763  VAAPIEncodePicture *prev = pic->prev;
764  VAAPIEncodeH265Picture *hprev = prev ? prev->priv_data : NULL;
765  VAEncPictureParameterBufferHEVC *vpic = pic->codec_picture_params;
766  int i, j = 0;
767 
768  if (pic->type == PICTURE_TYPE_IDR) {
769  av_assert0(pic->display_order == pic->encode_order);
770 
771  hpic->last_idr_frame = pic->display_order;
772 
774  hpic->slice_type = HEVC_SLICE_I;
775  hpic->pic_type = 0;
776  } else {
777  av_assert0(prev);
778  hpic->last_idr_frame = hprev->last_idr_frame;
779 
780  if (pic->type == PICTURE_TYPE_I) {
782  hpic->slice_type = HEVC_SLICE_I;
783  hpic->pic_type = 0;
784  } else if (pic->type == PICTURE_TYPE_P) {
785  av_assert0(pic->refs[0]);
787  hpic->slice_type = HEVC_SLICE_P;
788  hpic->pic_type = 1;
789  } else {
790  VAAPIEncodePicture *irap_ref;
791  av_assert0(pic->refs[0][0] && pic->refs[1][0]);
792  for (irap_ref = pic; irap_ref; irap_ref = irap_ref->refs[1][0]) {
793  if (irap_ref->type == PICTURE_TYPE_I)
794  break;
795  }
796  if (pic->b_depth == ctx->max_b_depth) {
797  hpic->slice_nal_unit = irap_ref ? HEVC_NAL_RASL_N
799  } else {
800  hpic->slice_nal_unit = irap_ref ? HEVC_NAL_RASL_R
802  }
803  hpic->slice_type = HEVC_SLICE_B;
804  hpic->pic_type = 2;
805  }
806  }
807  hpic->pic_order_cnt = pic->display_order - hpic->last_idr_frame;
808 
809  if (priv->aud) {
810  priv->aud_needed = 1;
811  priv->raw_aud = (H265RawAUD) {
812  .nal_unit_header = {
814  .nuh_layer_id = 0,
815  .nuh_temporal_id_plus1 = 1,
816  },
817  .pic_type = hpic->pic_type,
818  };
819  } else {
820  priv->aud_needed = 0;
821  }
822 
823  priv->sei_needed = 0;
824 
825  // Only look for the metadata on I/IDR frame on the output. We
826  // may force an IDR frame on the output where the medadata gets
827  // changed on the input frame.
828  if ((priv->sei & SEI_MASTERING_DISPLAY) &&
829  (pic->type == PICTURE_TYPE_I || pic->type == PICTURE_TYPE_IDR)) {
830  AVFrameSideData *sd =
833 
834  if (sd) {
837 
838  // SEI is needed when both the primaries and luminance are set
839  if (mdm->has_primaries && mdm->has_luminance) {
841  &priv->sei_mastering_display;
842  const int mapping[3] = {1, 2, 0};
843  const int chroma_den = 50000;
844  const int luma_den = 10000;
845 
846  for (i = 0; i < 3; i++) {
847  const int j = mapping[i];
848  mdcv->display_primaries_x[i] =
849  FFMIN(lrint(chroma_den *
850  av_q2d(mdm->display_primaries[j][0])),
851  chroma_den);
852  mdcv->display_primaries_y[i] =
853  FFMIN(lrint(chroma_den *
854  av_q2d(mdm->display_primaries[j][1])),
855  chroma_den);
856  }
857 
858  mdcv->white_point_x =
859  FFMIN(lrint(chroma_den * av_q2d(mdm->white_point[0])),
860  chroma_den);
861  mdcv->white_point_y =
862  FFMIN(lrint(chroma_den * av_q2d(mdm->white_point[1])),
863  chroma_den);
864 
866  lrint(luma_den * av_q2d(mdm->max_luminance));
868  FFMIN(lrint(luma_den * av_q2d(mdm->min_luminance)),
870 
872  }
873  }
874  }
875 
876  if ((priv->sei & SEI_CONTENT_LIGHT_LEVEL) &&
877  (pic->type == PICTURE_TYPE_I || pic->type == PICTURE_TYPE_IDR)) {
878  AVFrameSideData *sd =
881 
882  if (sd) {
887 
888  clli->max_content_light_level = FFMIN(clm->MaxCLL, 65535);
889  clli->max_pic_average_light_level = FFMIN(clm->MaxFALL, 65535);
890 
892  }
893  }
894 
895  if (priv->sei & SEI_A53_CC) {
896  int err;
897  size_t sei_a53cc_len;
898  av_freep(&priv->sei_a53cc_data);
899  err = ff_alloc_a53_sei(pic->input_image, 0, &priv->sei_a53cc_data, &sei_a53cc_len);
900  if (err < 0)
901  return err;
902  if (priv->sei_a53cc_data != NULL) {
903  priv->sei_a53cc.itu_t_t35_country_code = 181;
904  priv->sei_a53cc.data = (uint8_t *)priv->sei_a53cc_data + 1;
905  priv->sei_a53cc.data_length = sei_a53cc_len - 1;
906 
907  priv->sei_needed |= SEI_A53_CC;
908  }
909  }
910 
911  vpic->decoded_curr_pic = (VAPictureHEVC) {
912  .picture_id = pic->recon_surface,
913  .pic_order_cnt = hpic->pic_order_cnt,
914  .flags = 0,
915  };
916 
917  for (int k = 0; k < MAX_REFERENCE_LIST_NUM; k++) {
918  for (i = 0; i < pic->nb_refs[k]; i++) {
919  VAAPIEncodePicture *ref = pic->refs[k][i];
921 
922  av_assert0(ref && ref->encode_order < pic->encode_order);
923  href = ref->priv_data;
924 
925  vpic->reference_frames[j++] = (VAPictureHEVC) {
926  .picture_id = ref->recon_surface,
927  .pic_order_cnt = href->pic_order_cnt,
928  .flags = (ref->display_order < pic->display_order ?
929  VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE : 0) |
930  (ref->display_order > pic->display_order ?
931  VA_PICTURE_HEVC_RPS_ST_CURR_AFTER : 0),
932  };
933  }
934  }
935 
936  for (; j < FF_ARRAY_ELEMS(vpic->reference_frames); j++) {
937  vpic->reference_frames[j] = (VAPictureHEVC) {
938  .picture_id = VA_INVALID_ID,
939  .flags = VA_PICTURE_HEVC_INVALID,
940  };
941  }
942 
943  vpic->coded_buf = pic->output_buffer;
944 
945  vpic->nal_unit_type = hpic->slice_nal_unit;
946 
947  vpic->pic_fields.bits.reference_pic_flag = pic->is_reference;
948  switch (pic->type) {
949  case PICTURE_TYPE_IDR:
950  vpic->pic_fields.bits.idr_pic_flag = 1;
951  vpic->pic_fields.bits.coding_type = 1;
952  break;
953  case PICTURE_TYPE_I:
954  vpic->pic_fields.bits.idr_pic_flag = 0;
955  vpic->pic_fields.bits.coding_type = 1;
956  break;
957  case PICTURE_TYPE_P:
958  vpic->pic_fields.bits.idr_pic_flag = 0;
959  vpic->pic_fields.bits.coding_type = 2;
960  break;
961  case PICTURE_TYPE_B:
962  vpic->pic_fields.bits.idr_pic_flag = 0;
963  vpic->pic_fields.bits.coding_type = 3;
964  break;
965  default:
966  av_assert0(0 && "invalid picture type");
967  }
968 
969  return 0;
970 }
971 
973  VAAPIEncodePicture *pic,
974  VAAPIEncodeSlice *slice)
975 {
976  VAAPIEncodeContext *ctx = avctx->priv_data;
977  VAAPIEncodeH265Context *priv = avctx->priv_data;
978  VAAPIEncodeH265Picture *hpic = pic->priv_data;
979  const H265RawSPS *sps = &priv->raw_sps;
980  const H265RawPPS *pps = &priv->raw_pps;
981  H265RawSliceHeader *sh = &priv->raw_slice.header;
982  VAEncPictureParameterBufferHEVC *vpic = pic->codec_picture_params;
983  VAEncSliceParameterBufferHEVC *vslice = slice->codec_slice_params;
984  int i;
985 
987  .nal_unit_type = hpic->slice_nal_unit,
988  .nuh_layer_id = 0,
989  .nuh_temporal_id_plus1 = 1,
990  };
991 
992  sh->slice_pic_parameter_set_id = pps->pps_pic_parameter_set_id;
993 
994  sh->first_slice_segment_in_pic_flag = slice->index == 0;
995  sh->slice_segment_address = slice->block_start;
996 
997  sh->slice_type = hpic->slice_type;
998 
999  if (sh->slice_type == HEVC_SLICE_P && ctx->p_to_gpb)
1000  sh->slice_type = HEVC_SLICE_B;
1001 
1003  (1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4)) - 1;
1004 
1005  if (pic->type != PICTURE_TYPE_IDR) {
1006  H265RawSTRefPicSet *rps;
1007  const VAAPIEncodeH265Picture *strp;
1008  int rps_poc[MAX_DPB_SIZE];
1009  int rps_used[MAX_DPB_SIZE];
1010  int i, j, poc, rps_pics;
1011 
1013 
1014  rps = &sh->short_term_ref_pic_set;
1015  memset(rps, 0, sizeof(*rps));
1016 
1017  rps_pics = 0;
1018  for (i = 0; i < MAX_REFERENCE_LIST_NUM; i++) {
1019  for (j = 0; j < pic->nb_refs[i]; j++) {
1020  strp = pic->refs[i][j]->priv_data;
1021  rps_poc[rps_pics] = strp->pic_order_cnt;
1022  rps_used[rps_pics] = 1;
1023  ++rps_pics;
1024  }
1025  }
1026 
1027  for (i = 0; i < pic->nb_dpb_pics; i++) {
1028  if (pic->dpb[i] == pic)
1029  continue;
1030 
1031  for (j = 0; j < pic->nb_refs[0]; j++) {
1032  if (pic->dpb[i] == pic->refs[0][j])
1033  break;
1034  }
1035  if (j < pic->nb_refs[0])
1036  continue;
1037 
1038  for (j = 0; j < pic->nb_refs[1]; j++) {
1039  if (pic->dpb[i] == pic->refs[1][j])
1040  break;
1041  }
1042  if (j < pic->nb_refs[1])
1043  continue;
1044 
1045  strp = pic->dpb[i]->priv_data;
1046  rps_poc[rps_pics] = strp->pic_order_cnt;
1047  rps_used[rps_pics] = 0;
1048  ++rps_pics;
1049  }
1050 
1051  for (i = 1; i < rps_pics; i++) {
1052  for (j = i; j > 0; j--) {
1053  if (rps_poc[j] > rps_poc[j - 1])
1054  break;
1055  av_assert0(rps_poc[j] != rps_poc[j - 1]);
1056  FFSWAP(int, rps_poc[j], rps_poc[j - 1]);
1057  FFSWAP(int, rps_used[j], rps_used[j - 1]);
1058  }
1059  }
1060 
1061  av_log(avctx, AV_LOG_DEBUG, "RPS for POC %d:",
1062  hpic->pic_order_cnt);
1063  for (i = 0; i < rps_pics; i++) {
1064  av_log(avctx, AV_LOG_DEBUG, " (%d,%d)",
1065  rps_poc[i], rps_used[i]);
1066  }
1067  av_log(avctx, AV_LOG_DEBUG, "\n");
1068 
1069  for (i = 0; i < rps_pics; i++) {
1070  av_assert0(rps_poc[i] != hpic->pic_order_cnt);
1071  if (rps_poc[i] > hpic->pic_order_cnt)
1072  break;
1073  }
1074 
1075  rps->num_negative_pics = i;
1076  poc = hpic->pic_order_cnt;
1077  for (j = i - 1; j >= 0; j--) {
1078  rps->delta_poc_s0_minus1[i - 1 - j] = poc - rps_poc[j] - 1;
1079  rps->used_by_curr_pic_s0_flag[i - 1 - j] = rps_used[j];
1080  poc = rps_poc[j];
1081  }
1082 
1083  rps->num_positive_pics = rps_pics - i;
1084  poc = hpic->pic_order_cnt;
1085  for (j = i; j < rps_pics; j++) {
1086  rps->delta_poc_s1_minus1[j - i] = rps_poc[j] - poc - 1;
1087  rps->used_by_curr_pic_s1_flag[j - i] = rps_used[j];
1088  poc = rps_poc[j];
1089  }
1090 
1091  sh->num_long_term_sps = 0;
1092  sh->num_long_term_pics = 0;
1093 
1094  // when this flag is not present, it is inerred to 1.
1095  sh->collocated_from_l0_flag = 1;
1097  sps->sps_temporal_mvp_enabled_flag;
1099  if (sh->slice_type == HEVC_SLICE_B)
1100  sh->collocated_from_l0_flag = 1;
1101  sh->collocated_ref_idx = 0;
1102  }
1103 
1105  sh->num_ref_idx_l0_active_minus1 = pps->num_ref_idx_l0_default_active_minus1;
1106  sh->num_ref_idx_l1_active_minus1 = pps->num_ref_idx_l1_default_active_minus1;
1107  }
1108 
1110  sps->sample_adaptive_offset_enabled_flag;
1111 
1112  if (pic->type == PICTURE_TYPE_B)
1113  sh->slice_qp_delta = priv->fixed_qp_b - (pps->init_qp_minus26 + 26);
1114  else if (pic->type == PICTURE_TYPE_P)
1115  sh->slice_qp_delta = priv->fixed_qp_p - (pps->init_qp_minus26 + 26);
1116  else
1117  sh->slice_qp_delta = priv->fixed_qp_idr - (pps->init_qp_minus26 + 26);
1118 
1119 
1120  *vslice = (VAEncSliceParameterBufferHEVC) {
1121  .slice_segment_address = sh->slice_segment_address,
1122  .num_ctu_in_slice = slice->block_size,
1123 
1124  .slice_type = sh->slice_type,
1125  .slice_pic_parameter_set_id = sh->slice_pic_parameter_set_id,
1126 
1127  .num_ref_idx_l0_active_minus1 = sh->num_ref_idx_l0_active_minus1,
1128  .num_ref_idx_l1_active_minus1 = sh->num_ref_idx_l1_active_minus1,
1129 
1130  .luma_log2_weight_denom = sh->luma_log2_weight_denom,
1131  .delta_chroma_log2_weight_denom = sh->delta_chroma_log2_weight_denom,
1132 
1133  .max_num_merge_cand = 5 - sh->five_minus_max_num_merge_cand,
1134 
1135  .slice_qp_delta = sh->slice_qp_delta,
1136  .slice_cb_qp_offset = sh->slice_cb_qp_offset,
1137  .slice_cr_qp_offset = sh->slice_cr_qp_offset,
1138 
1139  .slice_beta_offset_div2 = sh->slice_beta_offset_div2,
1140  .slice_tc_offset_div2 = sh->slice_tc_offset_div2,
1141 
1142  .slice_fields.bits = {
1143  .last_slice_of_pic_flag = slice->index == pic->nb_slices - 1,
1144  .dependent_slice_segment_flag = sh->dependent_slice_segment_flag,
1145  .colour_plane_id = sh->colour_plane_id,
1146  .slice_temporal_mvp_enabled_flag =
1148  .slice_sao_luma_flag = sh->slice_sao_luma_flag,
1149  .slice_sao_chroma_flag = sh->slice_sao_chroma_flag,
1150  .num_ref_idx_active_override_flag =
1152  .mvd_l1_zero_flag = sh->mvd_l1_zero_flag,
1153  .cabac_init_flag = sh->cabac_init_flag,
1154  .slice_deblocking_filter_disabled_flag =
1156  .slice_loop_filter_across_slices_enabled_flag =
1158  .collocated_from_l0_flag = sh->collocated_from_l0_flag,
1159  },
1160  };
1161 
1162  for (i = 0; i < FF_ARRAY_ELEMS(vslice->ref_pic_list0); i++) {
1163  vslice->ref_pic_list0[i].picture_id = VA_INVALID_ID;
1164  vslice->ref_pic_list0[i].flags = VA_PICTURE_HEVC_INVALID;
1165  vslice->ref_pic_list1[i].picture_id = VA_INVALID_ID;
1166  vslice->ref_pic_list1[i].flags = VA_PICTURE_HEVC_INVALID;
1167  }
1168 
1169  if (pic->nb_refs[0]) {
1170  // Backward reference for P- or B-frame.
1171  av_assert0(pic->type == PICTURE_TYPE_P ||
1172  pic->type == PICTURE_TYPE_B);
1173  vslice->ref_pic_list0[0] = vpic->reference_frames[0];
1174  if (ctx->p_to_gpb && pic->type == PICTURE_TYPE_P)
1175  // Reference for GPB B-frame, L0 == L1
1176  vslice->ref_pic_list1[0] = vpic->reference_frames[0];
1177  }
1178  if (pic->nb_refs[1]) {
1179  // Forward reference for B-frame.
1180  av_assert0(pic->type == PICTURE_TYPE_B);
1181  vslice->ref_pic_list1[0] = vpic->reference_frames[1];
1182  }
1183 
1184  if (pic->type == PICTURE_TYPE_P && ctx->p_to_gpb) {
1185  vslice->slice_type = HEVC_SLICE_B;
1186  for (i = 0; i < FF_ARRAY_ELEMS(vslice->ref_pic_list0); i++) {
1187  vslice->ref_pic_list1[i].picture_id = vslice->ref_pic_list0[i].picture_id;
1188  vslice->ref_pic_list1[i].flags = vslice->ref_pic_list0[i].flags;
1189  }
1190  }
1191 
1192  return 0;
1193 }
1194 
1196 {
1197  VAAPIEncodeContext *ctx = avctx->priv_data;
1198  VAAPIEncodeH265Context *priv = avctx->priv_data;
1199 
1200 #if VA_CHECK_VERSION(1, 13, 0)
1201  {
1202  VAConfigAttribValEncHEVCBlockSizes block_size;
1203  VAConfigAttrib attr;
1204  VAStatus vas;
1205 
1206  attr.type = VAConfigAttribEncHEVCFeatures;
1207  vas = vaGetConfigAttributes(ctx->hwctx->display, ctx->va_profile,
1208  ctx->va_entrypoint, &attr, 1);
1209  if (vas != VA_STATUS_SUCCESS) {
1210  av_log(avctx, AV_LOG_ERROR, "Failed to query encoder "
1211  "features, using guessed defaults.\n");
1212  return AVERROR_EXTERNAL;
1213  } else if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1214  av_log(avctx, AV_LOG_WARNING, "Driver does not advertise "
1215  "encoder features, using guessed defaults.\n");
1216  } else {
1217  priv->va_features = attr.value;
1218  }
1219 
1220  attr.type = VAConfigAttribEncHEVCBlockSizes;
1221  vas = vaGetConfigAttributes(ctx->hwctx->display, ctx->va_profile,
1222  ctx->va_entrypoint, &attr, 1);
1223  if (vas != VA_STATUS_SUCCESS) {
1224  av_log(avctx, AV_LOG_ERROR, "Failed to query encoder "
1225  "block size, using guessed defaults.\n");
1226  return AVERROR_EXTERNAL;
1227  } else if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1228  av_log(avctx, AV_LOG_WARNING, "Driver does not advertise "
1229  "encoder block size, using guessed defaults.\n");
1230  } else {
1231  priv->va_bs = block_size.value = attr.value;
1232 
1233  priv->ctu_size =
1234  1 << block_size.bits.log2_max_coding_tree_block_size_minus3 + 3;
1235  priv->min_cb_size =
1236  1 << block_size.bits.log2_min_luma_coding_block_size_minus3 + 3;
1237  }
1238  }
1239 #endif
1240 
1241  if (!priv->ctu_size) {
1242  priv->ctu_size = 32;
1243  priv->min_cb_size = 16;
1244  }
1245  av_log(avctx, AV_LOG_VERBOSE, "Using CTU size %dx%d, "
1246  "min CB size %dx%d.\n", priv->ctu_size, priv->ctu_size,
1247  priv->min_cb_size, priv->min_cb_size);
1248 
1249  ctx->surface_width = FFALIGN(avctx->width, priv->min_cb_size);
1250  ctx->surface_height = FFALIGN(avctx->height, priv->min_cb_size);
1251 
1252  ctx->slice_block_width = ctx->slice_block_height = priv->ctu_size;
1253 
1254  return 0;
1255 }
1256 
1258 {
1259  VAAPIEncodeContext *ctx = avctx->priv_data;
1260  VAAPIEncodeH265Context *priv = avctx->priv_data;
1261  int err;
1262 
1263  err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_HEVC, avctx);
1264  if (err < 0)
1265  return err;
1266 
1267  if (ctx->va_rc_mode == VA_RC_CQP) {
1268  // Note that VAAPI only supports positive QP values - the range is
1269  // therefore always bounded below by 1, even in 10-bit mode where
1270  // it should go down to -12.
1271 
1272  priv->fixed_qp_p = av_clip(ctx->rc_quality, 1, 51);
1273  if (avctx->i_quant_factor > 0.0)
1274  priv->fixed_qp_idr =
1275  av_clip((avctx->i_quant_factor * priv->fixed_qp_p +
1276  avctx->i_quant_offset) + 0.5, 1, 51);
1277  else
1278  priv->fixed_qp_idr = priv->fixed_qp_p;
1279  if (avctx->b_quant_factor > 0.0)
1280  priv->fixed_qp_b =
1281  av_clip((avctx->b_quant_factor * priv->fixed_qp_p +
1282  avctx->b_quant_offset) + 0.5, 1, 51);
1283  else
1284  priv->fixed_qp_b = priv->fixed_qp_p;
1285 
1286  av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
1287  "%d / %d / %d for IDR- / P- / B-frames.\n",
1288  priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
1289 
1290  } else {
1291  // These still need to be set for init_qp/slice_qp_delta.
1292  priv->fixed_qp_idr = 30;
1293  priv->fixed_qp_p = 30;
1294  priv->fixed_qp_b = 30;
1295  }
1296 
1297  ctx->roi_quant_range = 51 + 6 * (ctx->profile->depth - 8);
1298 
1299  return 0;
1300 }
1301 
1303  { AV_PROFILE_HEVC_MAIN, 8, 3, 1, 1, VAProfileHEVCMain },
1304  { AV_PROFILE_HEVC_REXT, 8, 3, 1, 1, VAProfileHEVCMain },
1305 #if VA_CHECK_VERSION(0, 37, 0)
1306  { AV_PROFILE_HEVC_MAIN_10, 10, 3, 1, 1, VAProfileHEVCMain10 },
1307  { AV_PROFILE_HEVC_REXT, 10, 3, 1, 1, VAProfileHEVCMain10 },
1308 #endif
1309 #if VA_CHECK_VERSION(1, 2, 0)
1310  { AV_PROFILE_HEVC_REXT, 12, 3, 1, 1, VAProfileHEVCMain12 },
1311  { AV_PROFILE_HEVC_REXT, 8, 3, 1, 0, VAProfileHEVCMain422_10 },
1312  { AV_PROFILE_HEVC_REXT, 10, 3, 1, 0, VAProfileHEVCMain422_10 },
1313  { AV_PROFILE_HEVC_REXT, 12, 3, 1, 0, VAProfileHEVCMain422_12 },
1314  { AV_PROFILE_HEVC_REXT, 8, 3, 0, 0, VAProfileHEVCMain444 },
1315  { AV_PROFILE_HEVC_REXT, 10, 3, 0, 0, VAProfileHEVCMain444_10 },
1316  { AV_PROFILE_HEVC_REXT, 12, 3, 0, 0, VAProfileHEVCMain444_12 },
1317 #endif
1318  { AV_PROFILE_UNKNOWN }
1319 };
1320 
1323 
1324  .flags = FLAG_SLICE_CONTROL |
1325  FLAG_B_PICTURES |
1328 
1329  .default_quality = 25,
1330 
1331  .get_encoder_caps = &vaapi_encode_h265_get_encoder_caps,
1332  .configure = &vaapi_encode_h265_configure,
1333 
1334  .picture_priv_data_size = sizeof(VAAPIEncodeH265Picture),
1335 
1336  .sequence_params_size = sizeof(VAEncSequenceParameterBufferHEVC),
1337  .init_sequence_params = &vaapi_encode_h265_init_sequence_params,
1338 
1339  .picture_params_size = sizeof(VAEncPictureParameterBufferHEVC),
1340  .init_picture_params = &vaapi_encode_h265_init_picture_params,
1341 
1342  .slice_params_size = sizeof(VAEncSliceParameterBufferHEVC),
1343  .init_slice_params = &vaapi_encode_h265_init_slice_params,
1344 
1345  .sequence_header_type = VAEncPackedHeaderSequence,
1346  .write_sequence_header = &vaapi_encode_h265_write_sequence_header,
1347 
1348  .slice_header_type = VAEncPackedHeaderHEVC_Slice,
1349  .write_slice_header = &vaapi_encode_h265_write_slice_header,
1350 
1351  .write_extra_header = &vaapi_encode_h265_write_extra_header,
1352 };
1353 
1355 {
1356  VAAPIEncodeContext *ctx = avctx->priv_data;
1357  VAAPIEncodeH265Context *priv = avctx->priv_data;
1358 
1359  ctx->codec = &vaapi_encode_type_h265;
1360 
1361  if (avctx->profile == AV_PROFILE_UNKNOWN)
1362  avctx->profile = priv->profile;
1363  if (avctx->level == AV_LEVEL_UNKNOWN)
1364  avctx->level = priv->level;
1365 
1366  if (avctx->level != AV_LEVEL_UNKNOWN && avctx->level & ~0xff) {
1367  av_log(avctx, AV_LOG_ERROR, "Invalid level %d: must fit "
1368  "in 8-bit unsigned integer.\n", avctx->level);
1369  return AVERROR(EINVAL);
1370  }
1371 
1372  ctx->desired_packed_headers =
1373  VA_ENC_PACKED_HEADER_SEQUENCE | // VPS, SPS and PPS.
1374  VA_ENC_PACKED_HEADER_SLICE | // Slice headers.
1375  VA_ENC_PACKED_HEADER_MISC; // SEI
1376 
1377  if (priv->qp > 0)
1378  ctx->explicit_qp = priv->qp;
1379 
1380  return ff_vaapi_encode_init(avctx);
1381 }
1382 
1384 {
1385  VAAPIEncodeH265Context *priv = avctx->priv_data;
1386 
1388  ff_cbs_close(&priv->cbc);
1389  av_freep(&priv->sei_a53cc_data);
1390 
1391  return ff_vaapi_encode_close(avctx);
1392 }
1393 
1394 #define OFFSET(x) offsetof(VAAPIEncodeH265Context, x)
1395 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
1399 
1400  { "qp", "Constant QP (for P-frames; scaled by qfactor/qoffset for I/B)",
1401  OFFSET(qp), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 52, FLAGS },
1402 
1403  { "aud", "Include AUD",
1404  OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
1405 
1406  { "profile", "Set profile (general_profile_idc)",
1408  { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, 0xff, FLAGS, .unit = "profile" },
1409 
1410 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1411  { .i64 = value }, 0, 0, FLAGS, .unit = "profile"
1412  { PROFILE("main", AV_PROFILE_HEVC_MAIN) },
1413  { PROFILE("main10", AV_PROFILE_HEVC_MAIN_10) },
1414  { PROFILE("rext", AV_PROFILE_HEVC_REXT) },
1415 #undef PROFILE
1416 
1417  { "tier", "Set tier (general_tier_flag)",
1419  { .i64 = 0 }, 0, 1, FLAGS, .unit = "tier" },
1420  { "main", NULL, 0, AV_OPT_TYPE_CONST,
1421  { .i64 = 0 }, 0, 0, FLAGS, .unit = "tier" },
1422  { "high", NULL, 0, AV_OPT_TYPE_CONST,
1423  { .i64 = 1 }, 0, 0, FLAGS, .unit = "tier" },
1424 
1425  { "level", "Set level (general_level_idc)",
1427  { .i64 = AV_LEVEL_UNKNOWN }, AV_LEVEL_UNKNOWN, 0xff, FLAGS, .unit = "level" },
1428 
1429 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1430  { .i64 = value }, 0, 0, FLAGS, .unit = "level"
1431  { LEVEL("1", 30) },
1432  { LEVEL("2", 60) },
1433  { LEVEL("2.1", 63) },
1434  { LEVEL("3", 90) },
1435  { LEVEL("3.1", 93) },
1436  { LEVEL("4", 120) },
1437  { LEVEL("4.1", 123) },
1438  { LEVEL("5", 150) },
1439  { LEVEL("5.1", 153) },
1440  { LEVEL("5.2", 156) },
1441  { LEVEL("6", 180) },
1442  { LEVEL("6.1", 183) },
1443  { LEVEL("6.2", 186) },
1444 #undef LEVEL
1445 
1446  { "sei", "Set SEI to include",
1449  0, INT_MAX, FLAGS, .unit = "sei" },
1450  { "hdr",
1451  "Include HDR metadata for mastering display colour volume "
1452  "and content light level information",
1453  0, AV_OPT_TYPE_CONST,
1455  INT_MIN, INT_MAX, FLAGS, .unit = "sei" },
1456  { "a53_cc",
1457  "Include A/53 caption data",
1458  0, AV_OPT_TYPE_CONST,
1459  { .i64 = SEI_A53_CC },
1460  INT_MIN, INT_MAX, FLAGS, .unit = "sei" },
1461 
1462  { "tiles", "Tile columns x rows",
1463  OFFSET(common.tile_cols), AV_OPT_TYPE_IMAGE_SIZE,
1464  { .str = NULL }, 0, 0, FLAGS },
1465 
1466  { NULL },
1467 };
1468 
1470  { "b", "0" },
1471  { "bf", "2" },
1472  { "g", "120" },
1473  { "i_qfactor", "1" },
1474  { "i_qoffset", "0" },
1475  { "b_qfactor", "6/5" },
1476  { "b_qoffset", "0" },
1477  { "qmin", "-1" },
1478  { "qmax", "-1" },
1479  { NULL },
1480 };
1481 
1483  .class_name = "h265_vaapi",
1484  .item_name = av_default_item_name,
1485  .option = vaapi_encode_h265_options,
1486  .version = LIBAVUTIL_VERSION_INT,
1487 };
1488 
1490  .p.name = "hevc_vaapi",
1491  CODEC_LONG_NAME("H.265/HEVC (VAAPI)"),
1492  .p.type = AVMEDIA_TYPE_VIDEO,
1493  .p.id = AV_CODEC_ID_HEVC,
1494  .priv_data_size = sizeof(VAAPIEncodeH265Context),
1497  .close = &vaapi_encode_h265_close,
1498  .p.priv_class = &vaapi_encode_h265_class,
1499  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE |
1501  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
1503  .defaults = vaapi_encode_h265_defaults,
1504  .p.pix_fmts = (const enum AVPixelFormat[]) {
1507  },
1508  .hw_configs = ff_vaapi_encode_hw_configs,
1509  .p.wrapper_name = "vaapi",
1510 };
H265RawSliceHeader::slice_sao_chroma_flag
uint8_t slice_sao_chroma_flag
Definition: cbs_h265.h:476
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
H265RawSliceHeader::collocated_from_l0_flag
uint8_t collocated_from_l0_flag
Definition: cbs_h265.h:489
H265RawVUI::log2_max_mv_length_horizontal
uint8_t log2_max_mv_length_horizontal
Definition: cbs_h265.h:173
SEIRawMasteringDisplayColourVolume::display_primaries_x
uint16_t display_primaries_x[3]
Definition: cbs_sei.h:47
ff_alloc_a53_sei
int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len, void **data, size_t *sei_size)
Check AVFrame for A53 side data and allocate and fill SEI message with A53 info.
Definition: atsc_a53.c:26
H265RawSliceHeader::colour_plane_id
uint8_t colour_plane_id
Definition: cbs_h265.h:457
VAAPIEncodeH265Context::va_features
uint32_t va_features
Definition: vaapi_encode_h265.c:61
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
VAAPIEncodeSlice::codec_slice_params
void * codec_slice_params
Definition: vaapi_encode.h:70
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
H265RawSliceHeader::first_slice_segment_in_pic_flag
uint8_t first_slice_segment_in_pic_flag
Definition: cbs_h265.h:446
H265RawSliceHeader::num_ref_idx_l0_active_minus1
uint8_t num_ref_idx_l0_active_minus1
Definition: cbs_h265.h:479
level
uint8_t level
Definition: svq3.c:205
av_clip
#define av_clip
Definition: common.h:99
MAX_REFERENCE_LIST_NUM
@ MAX_REFERENCE_LIST_NUM
Definition: vaapi_encode.h:52
H265RawVUI::bitstream_restriction_flag
uint8_t bitstream_restriction_flag
Definition: cbs_h265.h:166
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
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
H265RawSliceHeader::num_ref_idx_active_override_flag
uint8_t num_ref_idx_active_override_flag
Definition: cbs_h265.h:478
H265RawProfileTierLevel::general_interlaced_source_flag
uint8_t general_interlaced_source_flag
Definition: cbs_h265.h:43
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
SEIRawUserDataRegistered
Definition: cbs_sei.h:33
ff_ctz
#define ff_ctz
Definition: intmath.h:107
H265RawProfileTierLevel::general_level_idc
uint8_t general_level_idc
Definition: cbs_h265.h:60
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:947
ff_cbs_fragment_free
av_cold void ff_cbs_fragment_free(CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:186
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_CODEC_CAP_HARDWARE
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:145
ff_cbs_sei_add_message
int ff_cbs_sei_add_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, int prefix, uint32_t payload_type, void *payload_data, void *payload_ref)
Add an SEI message to an access unit.
Definition: cbs_sei.c:269
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
H265RawSliceHeader::slice_deblocking_filter_disabled_flag
uint8_t slice_deblocking_filter_disabled_flag
Definition: cbs_h265.h:519
VAAPIEncodeH265Context::raw_aud
H265RawAUD raw_aud
Definition: vaapi_encode_h265.c:81
H265RawVUI::colour_primaries
uint8_t colour_primaries
Definition: cbs_h265.h:140
ff_cbs_insert_unit_content
int ff_cbs_insert_unit_content(CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, void *content_ref)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:783
H265RawSlice::header
H265RawSliceHeader header
Definition: cbs_h265.h:534
VAAPIEncodeH265Context::cbc
CodedBitstreamContext * cbc
Definition: vaapi_encode_h265.c:92
VAAPIEncodeH265Context::raw_pps
H265RawPPS raw_pps
Definition: vaapi_encode_h265.c:84
AV_PROFILE_HEVC_MAIN
#define AV_PROFILE_HEVC_MAIN
Definition: defs.h:158
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:111
H265RawVUI
Definition: cbs_h265.h:127
vaapi_encode_h265_add_nal
static int vaapi_encode_h265_add_nal(AVCodecContext *avctx, CodedBitstreamFragment *au, void *nal_unit)
Definition: vaapi_encode_h265.c:125
pixdesc.h
VAAPIEncodeH265Context::raw_sps
H265RawSPS raw_sps
Definition: vaapi_encode_h265.c:83
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:686
ff_cbs_fragment_reset
void ff_cbs_fragment_reset(CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment's own data buffer, but not the units a...
Definition: cbs.c:172
H265RawSTRefPicSet::delta_poc_s1_minus1
uint16_t delta_poc_s1_minus1[HEVC_MAX_REFS]
Definition: cbs_h265.h:233
H265RawProfileTierLevel::general_max_8bit_constraint_flag
uint8_t general_max_8bit_constraint_flag
Definition: cbs_h265.h:49
H265RawVUI::aspect_ratio_info_present_flag
uint8_t aspect_ratio_info_present_flag
Definition: cbs_h265.h:128
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:219
VAAPIEncodeSlice
Definition: vaapi_encode.h:64
AVOption
AVOption.
Definition: opt.h:357
H265RawSTRefPicSet::used_by_curr_pic_s1_flag
uint8_t used_by_curr_pic_s1_flag[HEVC_MAX_REFS]
Definition: cbs_h265.h:234
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
H265RawSliceHeader::slice_temporal_mvp_enabled_flag
uint8_t slice_temporal_mvp_enabled_flag
Definition: cbs_h265.h:473
data
const char data[16]
Definition: mxf.c:148
AVCodecContext::b_quant_offset
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:811
VAAPIEncodeSlice::block_start
int block_start
Definition: vaapi_encode.h:68
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:34
FFCodec
Definition: codec_internal.h:126
HEVC_NAL_RASL_N
@ HEVC_NAL_RASL_N
Definition: hevc.h:37
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
H265RawVUI::vui_timing_info_present_flag
uint8_t vui_timing_info_present_flag
Definition: cbs_h265.h:158
ff_vaapi_encode_close
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
Definition: vaapi_encode.c:2983
cbs.h
cbs_h265.h
VAAPIEncodeSlice::index
int index
Definition: vaapi_encode.h:65
VAAPIEncodeH265Context::raw_vps
H265RawVPS raw_vps
Definition: vaapi_encode_h265.c:82
H265RawProfileTierLevel::general_frame_only_constraint_flag
uint8_t general_frame_only_constraint_flag
Definition: cbs_h265.h:45
H265RawSliceHeader::num_long_term_sps
uint8_t num_long_term_sps
Definition: cbs_h265.h:465
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:246
H265RawSliceHeader::luma_log2_weight_denom
uint8_t luma_log2_weight_denom
Definition: cbs_h265.h:492
H265RawVUI::log2_max_mv_length_vertical
uint8_t log2_max_mv_length_vertical
Definition: cbs_h265.h:174
VAAPIEncodeH265Context::profile
int profile
Definition: vaapi_encode_h265.c:70
H265RawSliceHeader::five_minus_max_num_merge_cand
uint8_t five_minus_max_num_merge_cand
Definition: cbs_h265.h:507
ff_cbs_close
av_cold void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:142
H265LevelDescriptor
Definition: h265_profile_level.h:27
H265RawProfileTierLevel::general_max_422chroma_constraint_flag
uint8_t general_max_422chroma_constraint_flag
Definition: cbs_h265.h:50
VAAPIEncodePicture::refs
struct VAAPIEncodePicture * refs[MAX_REFERENCE_LIST_NUM][MAX_PICTURE_REFERENCES]
Definition: vaapi_encode.h:125
H265RawSPS
Definition: cbs_h265.h:244
H265RawVPS
Definition: cbs_h265.h:183
vaapi_encode_h265_close
static av_cold int vaapi_encode_h265_close(AVCodecContext *avctx)
Definition: vaapi_encode_h265.c:1383
FLAG_NON_IDR_KEY_PICTURES
@ FLAG_NON_IDR_KEY_PICTURES
Definition: vaapi_encode.h:413
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
H265RawPPS
Definition: cbs_h265.h:346
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
SEIRawContentLightLevelInfo
Definition: cbs_sei.h:55
VAAPIEncodePicture::nb_refs
int nb_refs[MAX_REFERENCE_LIST_NUM]
Definition: vaapi_encode.h:124
H265RawVUI::video_format
uint8_t video_format
Definition: cbs_h265.h:137
H265RawVUI::max_bits_per_min_cu_denom
uint8_t max_bits_per_min_cu_denom
Definition: cbs_h265.h:172
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:820
H265RawProfileTierLevel::general_progressive_source_flag
uint8_t general_progressive_source_flag
Definition: cbs_h265.h:42
FFCodecDefault
Definition: codec_internal.h:96
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
H265RawSTRefPicSet::used_by_curr_pic_s0_flag
uint8_t used_by_curr_pic_s0_flag[HEVC_MAX_REFS]
Definition: cbs_h265.h:232
H265RawSliceHeader::num_long_term_pics
uint8_t num_long_term_pics
Definition: cbs_h265.h:466
vaapi_encode.h
fail
#define fail()
Definition: checkasm.h:183
vaapi_encode_h265_init_sequence_params
static int vaapi_encode_h265_init_sequence_params(AVCodecContext *avctx)
Definition: vaapi_encode_h265.c:260
H265RawSTRefPicSet::delta_poc_s0_minus1
uint16_t delta_poc_s0_minus1[HEVC_MAX_REFS]
Definition: cbs_h265.h:231
VAAPIEncodePicture
Definition: vaapi_encode.h:73
H265RawSliceHeader::short_term_ref_pic_set
H265RawSTRefPicSet short_term_ref_pic_set
Definition: cbs_h265.h:462
SEIRawMasteringDisplayColourVolume::max_display_mastering_luminance
uint32_t max_display_mastering_luminance
Definition: cbs_sei.h:51
vaapi_encode_h265_class
static const AVClass vaapi_encode_h265_class
Definition: vaapi_encode_h265.c:1482
H265RawProfileTierLevel::general_max_12bit_constraint_flag
uint8_t general_max_12bit_constraint_flag
Definition: cbs_h265.h:47
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
H265RawSliceHeader::mvd_l1_zero_flag
uint8_t mvd_l1_zero_flag
Definition: cbs_h265.h:487
H265RawProfileTierLevel::general_intra_constraint_flag
uint8_t general_intra_constraint_flag
Definition: cbs_h265.h:53
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
VAAPIEncodeH265Context::fixed_qp_idr
int fixed_qp_idr
Definition: vaapi_encode_h265.c:76
H265RawVUI::sar_height
uint16_t sar_height
Definition: cbs_h265.h:131
H265RawSliceHeader::collocated_ref_idx
uint8_t collocated_ref_idx
Definition: cbs_h265.h:490
avassert.h
lrint
#define lrint
Definition: tablegen.h:53
SEIRawUserDataRegistered::itu_t_t35_country_code
uint8_t itu_t_t35_country_code
Definition: cbs_sei.h:34
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
H265RawSliceHeader::slice_cb_qp_offset
int8_t slice_cb_qp_offset
Definition: cbs_h265.h:511
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
H265RawSliceHeader::slice_pic_order_cnt_lsb
uint16_t slice_pic_order_cnt_lsb
Definition: cbs_h265.h:459
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
SEI_A53_CC
@ SEI_A53_CC
Definition: vaapi_encode_h265.c:44
ptl
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
VAAPIEncodePicture::codec_picture_params
void * codec_picture_params
Definition: vaapi_encode.h:111
ff_h265_guess_level
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.
Definition: h265_profile_level.c:162
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:122
PICTURE_TYPE_I
@ PICTURE_TYPE_I
Definition: vaapi_encode.h:59
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
SEIRawMasteringDisplayColourVolume::white_point_y
uint16_t white_point_y
Definition: cbs_sei.h:50
CodedBitstreamFragment::data_size
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:135
H265RawProfileTierLevel::general_profile_idc
uint8_t general_profile_idc
Definition: cbs_h265.h:38
FLAGS
#define FLAGS
Definition: vaapi_encode_h265.c:1395
H265RawProfileTierLevel::general_non_packed_constraint_flag
uint8_t general_non_packed_constraint_flag
Definition: cbs_h265.h:44
H265RawSliceHeader::slice_sao_luma_flag
uint8_t slice_sao_luma_flag
Definition: cbs_h265.h:475
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
H265RawSliceHeader::num_ref_idx_l1_active_minus1
uint8_t num_ref_idx_l1_active_minus1
Definition: cbs_h265.h:480
H265RawSTRefPicSet::num_positive_pics
uint8_t num_positive_pics
Definition: cbs_h265.h:230
H265RawSliceHeader::slice_pic_parameter_set_id
uint8_t slice_pic_parameter_set_id
Definition: cbs_h265.h:448
ctx
AVFormatContext * ctx
Definition: movenc.c:49
VAAPIEncodeH265Context::aud
int aud
Definition: vaapi_encode_h265.c:69
H265RawProfileTierLevel::general_max_14bit_constraint_flag
uint8_t general_max_14bit_constraint_flag
Definition: cbs_h265.h:56
SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
@ SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
Definition: sei.h:34
ff_vaapi_encode_receive_packet
int ff_vaapi_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: vaapi_encode.c:1397
H265RawVUI::vui_time_scale
uint32_t vui_time_scale
Definition: cbs_h265.h:160
H265RawVUI::video_signal_type_present_flag
uint8_t video_signal_type_present_flag
Definition: cbs_h265.h:136
tier
int tier
Definition: av1_levels.c:48
HEVC_SLICE_I
@ HEVC_SLICE_I
Definition: hevc.h:98
VAAPIEncodeH265Context::tier
int tier
Definition: vaapi_encode_h265.c:71
CodedBitstreamFragment::data_bit_padding
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:139
h2645data.h
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
VAAPIEncodeType
Definition: vaapi_encode.h:419
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
VAAPIEncodeH265Picture
Definition: vaapi_encode_h265.c:47
VAAPIEncodeContext
Definition: vaapi_encode.h:195
VAAPIEncodePicture::prev
struct VAAPIEncodePicture * prev
Definition: vaapi_encode.h:128
if
if(ret)
Definition: filter_design.txt:179
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
SEIRawMasteringDisplayColourVolume::min_display_mastering_luminance
uint32_t min_display_mastering_luminance
Definition: cbs_sei.h:52
HEVC_SLICE_B
@ HEVC_SLICE_B
Definition: hevc.h:96
H265RawVUI::matrix_coefficients
uint8_t matrix_coefficients
Definition: cbs_h265.h:142
H265RawSliceHeader::slice_segment_address
uint16_t slice_segment_address
Definition: cbs_h265.h:451
NULL
#define NULL
Definition: coverity.c:32
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:210
H265RawAUD
Definition: cbs_h265.h:437
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
PROFILE
#define PROFILE(name, value)
H265RawSliceHeader::slice_tc_offset_div2
int8_t slice_tc_offset_div2
Definition: cbs_h265.h:521
HEVC_NAL_PPS
@ HEVC_NAL_PPS
Definition: hevc.h:63
H265RawSliceHeader::short_term_ref_pic_set_sps_flag
uint8_t short_term_ref_pic_set_sps_flag
Definition: cbs_h265.h:461
VAAPIEncodePicture::dpb
struct VAAPIEncodePicture * dpb[MAX_DPB_SIZE]
Definition: vaapi_encode.h:120
AV_LEVEL_UNKNOWN
#define AV_LEVEL_UNKNOWN
Definition: defs.h:196
vaapi_encode_h265_write_slice_header
static int vaapi_encode_h265_write_slice_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice, char *data, size_t *data_len)
Definition: vaapi_encode_h265.c:175
VAAPIEncodeType::profiles
const VAAPIEncodeProfile * profiles
Definition: vaapi_encode.h:422
VAAPIEncodeH265Context::aud_needed
int aud_needed
Definition: vaapi_encode_h265.c:94
SEIRawMasteringDisplayColourVolume
Definition: cbs_sei.h:46
FF_CODEC_RECEIVE_PACKET_CB
#define FF_CODEC_RECEIVE_PACKET_CB(func)
Definition: codec_internal.h:301
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive ints
Definition: opt.h:255
OFFSET
#define OFFSET(x)
Definition: vaapi_encode_h265.c:1394
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:120
HEVC_NAL_CRA_NUT
@ HEVC_NAL_CRA_NUT
Definition: hevc.h:50
vaapi_encode_h265_write_access_unit
static int vaapi_encode_h265_write_access_unit(AVCodecContext *avctx, char *data, size_t *data_len, CodedBitstreamFragment *au)
Definition: vaapi_encode_h265.c:99
H265RawVUI::chroma_sample_loc_type_bottom_field
uint8_t chroma_sample_loc_type_bottom_field
Definition: cbs_h265.h:146
vaapi_encode_h265_options
static const AVOption vaapi_encode_h265_options[]
Definition: vaapi_encode_h265.c:1396
FLAG_B_PICTURES
@ FLAG_B_PICTURES
Definition: vaapi_encode.h:408
vaapi_encode_h265_init_picture_params
static int vaapi_encode_h265_init_picture_params(AVCodecContext *avctx, VAAPIEncodePicture *pic)
Definition: vaapi_encode_h265.c:757
vps
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
Definition: cbs_h265_syntax_template.c:423
H265RawProfileTierLevel::general_max_10bit_constraint_flag
uint8_t general_max_10bit_constraint_flag
Definition: cbs_h265.h:48
H265RawVUI::vui_num_ticks_poc_diff_one_minus1
uint32_t vui_num_ticks_poc_diff_one_minus1
Definition: cbs_h265.h:162
H265RawSliceHeader::slice_type
uint8_t slice_type
Definition: cbs_h265.h:454
VAAPIEncodeH265Context::sei_content_light_level
SEIRawContentLightLevelInfo sei_content_light_level
Definition: vaapi_encode_h265.c:88
H265RawVUI::video_full_range_flag
uint8_t video_full_range_flag
Definition: cbs_h265.h:138
H265RawProfileTierLevel::general_tier_flag
uint8_t general_tier_flag
Definition: cbs_h265.h:37
H265RawNALUnitHeader::nal_unit_type
uint8_t nal_unit_type
Definition: cbs_h265.h:30
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:824
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1784
H265RawSliceHeader::slice_qp_delta
int8_t slice_qp_delta
Definition: cbs_h265.h:510
AV_PROFILE_HEVC_MAIN_10
#define AV_PROFILE_HEVC_MAIN_10
Definition: defs.h:159
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:652
HEVC_NAL_RASL_R
@ HEVC_NAL_RASL_R
Definition: hevc.h:38
H265RawNALUnitHeader
Definition: cbs_h265.h:29
AV_PROFILE_HEVC_REXT
#define AV_PROFILE_HEVC_REXT
Definition: defs.h:161
index
int index
Definition: gxfenc.c:90
VAAPIEncodeH265Context::va_bs
uint32_t va_bs
Definition: vaapi_encode_h265.c:63
vaapi_encode_h265_init
static av_cold int vaapi_encode_h265_init(AVCodecContext *avctx)
Definition: vaapi_encode_h265.c:1354
VAAPIEncodeH265Context::fixed_qp_b
int fixed_qp_b
Definition: vaapi_encode_h265.c:78
VAAPIEncodeH265Context::ctu_size
uint32_t ctu_size
Definition: vaapi_encode_h265.c:64
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:544
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:841
VAAPIEncodeH265Picture::slice_type
int slice_type
Definition: vaapi_encode_h265.c:53
H265RawVUI::chroma_loc_info_present_flag
uint8_t chroma_loc_info_present_flag
Definition: cbs_h265.h:144
H265RawVUI::sar_width
uint16_t sar_width
Definition: cbs_h265.h:130
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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
PICTURE_TYPE_B
@ PICTURE_TYPE_B
Definition: vaapi_encode.h:61
MAX_DPB_SIZE
@ MAX_DPB_SIZE
Definition: vaapi_encode.h:43
VAAPIEncodePicture::type
int type
Definition: vaapi_encode.h:92
codec_internal.h
VAAPI_ENCODE_RC_OPTIONS
#define VAAPI_ENCODE_RC_OPTIONS
Definition: vaapi_encode.h:532
H265RawSliceHeader::cabac_init_flag
uint8_t cabac_init_flag
Definition: cbs_h265.h:488
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
H265RawProfileTierLevel::general_lower_bit_rate_constraint_flag
uint8_t general_lower_bit_rate_constraint_flag
Definition: cbs_h265.h:55
SEI_MASTERING_DISPLAY
@ SEI_MASTERING_DISPLAY
Definition: vaapi_encode_h265.c:42
vaapi_encode_h265_get_encoder_caps
static av_cold int vaapi_encode_h265_get_encoder_caps(AVCodecContext *avctx)
Definition: vaapi_encode_h265.c:1195
SEIRawUserDataRegistered::data
uint8_t * data
RefStruct reference.
Definition: cbs_sei.h:36
CodedBitstreamFragment::data
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:128
VAAPIEncodeH265Context::raw_slice
H265RawSlice raw_slice
Definition: vaapi_encode_h265.c:85
H265RawProfileTierLevel::general_max_monochrome_constraint_flag
uint8_t general_max_monochrome_constraint_flag
Definition: cbs_h265.h:52
AVFrameSideData::data
uint8_t * data
Definition: frame.h:252
h265_profile_level.h
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:706
H265RawSliceHeader::dependent_slice_segment_flag
uint8_t dependent_slice_segment_flag
Definition: cbs_h265.h:450
H265RawSliceHeader::slice_cr_qp_offset
int8_t slice_cr_qp_offset
Definition: cbs_h265.h:512
header
static const uint8_t header[24]
Definition: sdr2.c:68
H265RawProfileTierLevel::general_one_picture_only_constraint_flag
uint8_t general_one_picture_only_constraint_flag
Definition: cbs_h265.h:54
H265RawAUD::nal_unit_header
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:438
vaapi_encode_type_h265
static const VAAPIEncodeType vaapi_encode_type_h265
Definition: vaapi_encode_h265.c:1321
vaapi_encode_h265_profiles
static const VAAPIEncodeProfile vaapi_encode_h265_profiles[]
Definition: vaapi_encode_h265.c:1302
VAAPI_ENCODE_COMMON_OPTIONS
#define VAAPI_ENCODE_COMMON_OPTIONS
Definition: vaapi_encode.h:505
SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME
@ SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME
Definition: sei.h:96
VAAPIEncodePicture::recon_surface
VASurfaceID recon_surface
Definition: vaapi_encode.h:101
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
VAAPIEncodePicture::output_buffer
VABufferID output_buffer
Definition: vaapi_encode.h:108
VAAPIEncodePicture::priv_data
void * priv_data
Definition: vaapi_encode.h:110
vaapi_encode_h265_configure
static av_cold int vaapi_encode_h265_configure(AVCodecContext *avctx)
Definition: vaapi_encode_h265.c:1257
vaapi_encode_h265_init_slice_params
static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice)
Definition: vaapi_encode_h265.c:972
H265RawVUI::chroma_sample_loc_type_top_field
uint8_t chroma_sample_loc_type_top_field
Definition: cbs_h265.h:145
SEIRawUserDataRegistered::data_length
size_t data_length
Definition: cbs_sei.h:37
ff_hevc_vaapi_encoder
const FFCodec ff_hevc_vaapi_encoder
Definition: vaapi_encode_h265.c:1489
VAAPIEncodePicture::display_order
int64_t display_order
Definition: vaapi_encode.h:76
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
VAAPIEncodePicture::nb_dpb_pics
int nb_dpb_pics
Definition: vaapi_encode.h:119
VAAPIEncodePicture::b_depth
int b_depth
Definition: vaapi_encode.h:93
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:804
H265RawVUI::max_bytes_per_pic_denom
uint8_t max_bytes_per_pic_denom
Definition: cbs_h265.h:171
H265RawSliceHeader
Definition: cbs_h265.h:443
VAAPIEncodeH265Context::sei_a53cc_data
void * sei_a53cc_data
Definition: vaapi_encode_h265.c:90
HEVC_NAL_TRAIL_R
@ HEVC_NAL_TRAIL_R
Definition: hevc.h:30
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:137
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
VAAPIEncodeH265Picture::slice_nal_unit
int slice_nal_unit
Definition: vaapi_encode_h265.c:52
H265RawVUI::vui_hrd_parameters_present_flag
uint8_t vui_hrd_parameters_present_flag
Definition: cbs_h265.h:163
SEIRawMasteringDisplayColourVolume::white_point_x
uint16_t white_point_x
Definition: cbs_sei.h:49
VAAPIEncodeContext::input_frames
AVHWFramesContext * input_frames
Definition: vaapi_encode.h:275
VAAPIEncodeH265Context
Definition: vaapi_encode_h265.c:57
common.h
H265RawVUI::vui_num_units_in_tick
uint32_t vui_num_units_in_tick
Definition: cbs_h265.h:159
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
HEVC_SLICE_P
@ HEVC_SLICE_P
Definition: hevc.h:97
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
H265RawSliceHeader::nal_unit_header
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:444
H265RawSliceHeader::slice_beta_offset_div2
int8_t slice_beta_offset_div2
Definition: cbs_h265.h:520
H265RawSTRefPicSet
Definition: cbs_h265.h:219
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
ff_h2645_pixel_aspect
const AVRational ff_h2645_pixel_aspect[]
Definition: h2645data.c:21
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:702
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
profile
int profile
Definition: mxfenc.c:2227
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
VAAPIEncodeH265Context::sei_mastering_display
SEIRawMasteringDisplayColourVolume sei_mastering_display
Definition: vaapi_encode_h265.c:87
AVCodecContext::height
int height
Definition: avcodec.h:618
H265RawProfileTierLevel
Definition: cbs_h265.h:35
SEIRawMasteringDisplayColourVolume::display_primaries_y
uint16_t display_primaries_y[3]
Definition: cbs_sei.h:48
H265RawProfileTierLevel::general_max_420chroma_constraint_flag
uint8_t general_max_420chroma_constraint_flag
Definition: cbs_h265.h:51
ff_cbs_write_fragment_data
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:409
hevc.h
H265RawProfileTierLevel::general_profile_space
uint8_t general_profile_space
Definition: cbs_h265.h:36
avcodec.h
HEVC_NAL_VPS
@ HEVC_NAL_VPS
Definition: hevc.h:61
ff_vaapi_encode_hw_configs
const AVCodecHWConfigInternal *const ff_vaapi_encode_hw_configs[]
Definition: vaapi_encode.c:36
FLAG_SLICE_CONTROL
@ FLAG_SLICE_CONTROL
Definition: vaapi_encode.h:402
HEVC_NAL_IDR_W_RADL
@ HEVC_NAL_IDR_W_RADL
Definition: hevc.h:48
H265RawProfileTierLevel::general_profile_compatibility_flag
uint8_t general_profile_compatibility_flag[32]
Definition: cbs_h265.h:40
ff_vaapi_encode_init
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
Definition: vaapi_encode.c:2774
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
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
VAAPIEncodeH265Context::common
VAAPIEncodeContext common
Definition: vaapi_encode_h265.c:58
atsc_a53.h
SEIRawContentLightLevelInfo::max_content_light_level
uint16_t max_content_light_level
Definition: cbs_sei.h:56
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
VAAPIEncodeH265Context::fixed_qp_p
int fixed_qp_p
Definition: vaapi_encode_h265.c:77
LEVEL
#define LEVEL(name, value)
HEVC_NAL_TRAIL_N
@ HEVC_NAL_TRAIL_N
Definition: hevc.h:29
H265RawSliceHeader::slice_loop_filter_across_slices_enabled_flag
uint8_t slice_loop_filter_across_slices_enabled_flag
Definition: cbs_h265.h:522
FLAG_B_PICTURE_REFERENCES
@ FLAG_B_PICTURE_REFERENCES
Definition: vaapi_encode.h:410
HEVC_NAL_AUD
@ HEVC_NAL_AUD
Definition: hevc.h:64
AVCodecContext
main external API structure.
Definition: avcodec.h:445
PICTURE_TYPE_IDR
@ PICTURE_TYPE_IDR
Definition: vaapi_encode.h:58
H265RawSTRefPicSet::num_negative_pics
uint8_t num_negative_pics
Definition: cbs_h265.h:229
vaapi_encode_h265_write_sequence_header
static int vaapi_encode_h265_write_sequence_header(AVCodecContext *avctx, char *data, size_t *data_len)
Definition: vaapi_encode_h265.c:143
AVRational::den
int den
Denominator.
Definition: rational.h:60
VAAPIEncodePicture::is_reference
int is_reference
Definition: vaapi_encode.h:114
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
H265RawVUI::colour_description_present_flag
uint8_t colour_description_present_flag
Definition: cbs_h265.h:139
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1640
VAAPIEncodeH265Context::qp
int qp
Definition: vaapi_encode_h265.c:68
AVCodecContext::i_quant_offset
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:827
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
VAAPIEncodeH265Picture::pic_type
int pic_type
Definition: vaapi_encode_h265.c:54
H265RawVUI::transfer_characteristics
uint8_t transfer_characteristics
Definition: cbs_h265.h:141
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
HEVC_NAL_SPS
@ HEVC_NAL_SPS
Definition: hevc.h:62
mem.h
mastering_display_metadata.h
vaapi_encode_h265_write_extra_header
static int vaapi_encode_h265_write_extra_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, int index, int *type, char *data, size_t *data_len)
Definition: vaapi_encode_h265.c:201
VAAPIEncodePicture::input_image
AVFrame * input_image
Definition: vaapi_encode.h:97
VAAPIEncodeSlice::block_size
int block_size
Definition: vaapi_encode.h:69
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:250
VAAPIEncodeH265Picture::last_idr_frame
int64_t last_idr_frame
Definition: vaapi_encode_h265.c:50
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
ff_cbs_init
av_cold 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:90
VAAPIEncodeH265Context::sei
int sei
Definition: vaapi_encode_h265.c:73
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
VAAPIEncodePicture::encode_order
int64_t encode_order
Definition: vaapi_encode.h:77
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
SEI_CONTENT_LIGHT_LEVEL
@ SEI_CONTENT_LIGHT_LEVEL
Definition: vaapi_encode_h265.c:43
VAAPIEncodeH265Context::current_access_unit
CodedBitstreamFragment current_access_unit
Definition: vaapi_encode_h265.c:93
VAAPIEncodeH265Context::sei_a53cc
SEIRawUserDataRegistered sei_a53cc
Definition: vaapi_encode_h265.c:89
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:244
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
H265RawVUI::vui_poc_proportional_to_timing_flag
uint8_t vui_poc_proportional_to_timing_flag
Definition: cbs_h265.h:161
SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO
@ SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO
Definition: sei.h:103
VAAPIEncodeH265Context::level
int level
Definition: vaapi_encode_h265.c:72
H265RawVUI::aspect_ratio_idc
uint8_t aspect_ratio_idc
Definition: cbs_h265.h:129
H265RawVUI::restricted_ref_pic_lists_flag
uint8_t restricted_ref_pic_lists_flag
Definition: cbs_h265.h:169
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
H265RawSliceHeader::delta_chroma_log2_weight_denom
int8_t delta_chroma_log2_weight_denom
Definition: cbs_h265.h:493
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:642
VAAPIEncodeH265Context::min_cb_size
uint32_t min_cb_size
Definition: vaapi_encode_h265.c:65
VAAPIEncodeProfile
Definition: vaapi_encode.h:150
H265RawVUI::motion_vectors_over_pic_boundaries_flag
uint8_t motion_vectors_over_pic_boundaries_flag
Definition: cbs_h265.h:168
H265RawSlice
Definition: cbs_h265.h:533
VAAPIEncodePicture::nb_slices
int nb_slices
Definition: vaapi_encode.h:135
PICTURE_TYPE_P
@ PICTURE_TYPE_P
Definition: vaapi_encode.h:60
vaapi_encode_h265_defaults
static const FFCodecDefault vaapi_encode_h265_defaults[]
Definition: vaapi_encode_h265.c:1469
VAAPIEncodeH265Context::sei_needed
int sei_needed
Definition: vaapi_encode_h265.c:95
VAAPIEncodeH265Picture::pic_order_cnt
int pic_order_cnt
Definition: vaapi_encode_h265.c:48