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/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.
77 
80 
86 
87 
89  char *data, size_t *data_len,
91 {
92  VAAPIEncodeH265Context *priv = avctx->priv_data;
93  int err;
94 
95  err = ff_cbs_write_fragment_data(priv->cbc, au);
96  if (err < 0) {
97  av_log(avctx, AV_LOG_ERROR, "Failed to write packed header.\n");
98  return err;
99  }
100 
101  if (*data_len < 8 * au->data_size - au->data_bit_padding) {
102  av_log(avctx, AV_LOG_ERROR, "Access unit too large: "
103  "%zu < %zu.\n", *data_len,
104  8 * au->data_size - au->data_bit_padding);
105  return AVERROR(ENOSPC);
106  }
107 
108  memcpy(data, au->data, au->data_size);
109  *data_len = 8 * au->data_size - au->data_bit_padding;
110 
111  return 0;
112 }
113 
116  void *nal_unit)
117 {
118  H265RawNALUnitHeader *header = nal_unit;
119  int err;
120 
121  err = ff_cbs_insert_unit_content(au, -1,
122  header->nal_unit_type, nal_unit, NULL);
123  if (err < 0) {
124  av_log(avctx, AV_LOG_ERROR, "Failed to add NAL unit: "
125  "type = %d.\n", header->nal_unit_type);
126  return err;
127  }
128 
129  return 0;
130 }
131 
133  char *data, size_t *data_len)
134 {
135  VAAPIEncodeH265Context *priv = avctx->priv_data;
137  int err;
138 
139  if (priv->aud_needed) {
140  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_aud);
141  if (err < 0)
142  goto fail;
143  priv->aud_needed = 0;
144  }
145 
146  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_vps);
147  if (err < 0)
148  goto fail;
149 
150  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_sps);
151  if (err < 0)
152  goto fail;
153 
154  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_pps);
155  if (err < 0)
156  goto fail;
157 
158  err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
159 fail:
161  return err;
162 }
163 
165  VAAPIEncodePicture *pic,
166  VAAPIEncodeSlice *slice,
167  char *data, size_t *data_len)
168 {
169  VAAPIEncodeH265Context *priv = avctx->priv_data;
171  int err;
172 
173  if (priv->aud_needed) {
174  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_aud);
175  if (err < 0)
176  goto fail;
177  priv->aud_needed = 0;
178  }
179 
180  err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_slice);
181  if (err < 0)
182  goto fail;
183 
184  err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
185 fail:
187  return err;
188 }
189 
191  VAAPIEncodePicture *pic,
192  int index, int *type,
193  char *data, size_t *data_len)
194 {
195  VAAPIEncodeH265Context *priv = avctx->priv_data;
197  int err;
198 
199  if (priv->sei_needed) {
200  if (priv->aud_needed) {
201  err = vaapi_encode_h265_add_nal(avctx, au, &priv->aud);
202  if (err < 0)
203  goto fail;
204  priv->aud_needed = 0;
205  }
206 
207  if (priv->sei_needed & SEI_MASTERING_DISPLAY) {
208  err = ff_cbs_sei_add_message(priv->cbc, au, 1,
210  &priv->sei_mastering_display, NULL);
211  if (err < 0)
212  goto fail;
213  }
214 
215  if (priv->sei_needed & SEI_CONTENT_LIGHT_LEVEL) {
216  err = ff_cbs_sei_add_message(priv->cbc, au, 1,
218  &priv->sei_content_light_level, NULL);
219  if (err < 0)
220  goto fail;
221  }
222 
223  priv->sei_needed = 0;
224 
225  err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
226  if (err < 0)
227  goto fail;
228 
230 
231  *type = VAEncPackedHeaderRawData;
232  return 0;
233  } else {
234  return AVERROR_EOF;
235  }
236 
237 fail:
239  return err;
240 }
241 
243 {
244  VAAPIEncodeContext *ctx = avctx->priv_data;
245  VAAPIEncodeH265Context *priv = avctx->priv_data;
246  H265RawVPS *vps = &priv->raw_vps;
247  H265RawSPS *sps = &priv->raw_sps;
248  H265RawPPS *pps = &priv->raw_pps;
250  H265RawVUI *vui = &sps->vui;
251  VAEncSequenceParameterBufferHEVC *vseq = ctx->codec_sequence_params;
252  VAEncPictureParameterBufferHEVC *vpic = ctx->codec_picture_params;
253  const AVPixFmtDescriptor *desc;
254  int chroma_format, bit_depth;
255  int i;
256 
257  memset(vps, 0, sizeof(*vps));
258  memset(sps, 0, sizeof(*sps));
259  memset(pps, 0, sizeof(*pps));
260 
261 
263  av_assert0(desc);
264  if (desc->nb_components == 1) {
265  chroma_format = 0;
266  } else {
267  if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1) {
268  chroma_format = 1;
269  } else if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 0) {
270  chroma_format = 2;
271  } else if (desc->log2_chroma_w == 0 && desc->log2_chroma_h == 0) {
272  chroma_format = 3;
273  } else {
274  av_log(avctx, AV_LOG_ERROR, "Chroma format of input pixel format "
275  "%s is not supported.\n", desc->name);
276  return AVERROR(EINVAL);
277  }
278  }
279  bit_depth = desc->comp[0].depth;
280 
281 
282  // VPS
283 
286  .nuh_layer_id = 0,
287  .nuh_temporal_id_plus1 = 1,
288  };
289 
291 
294  vps->vps_max_layers_minus1 = 0;
295  vps->vps_max_sub_layers_minus1 = 0;
297 
298  ptl->general_profile_space = 0;
299  ptl->general_profile_idc = avctx->profile;
300  ptl->general_tier_flag = priv->tier;
301 
302  if (chroma_format == 1) {
303  ptl->general_profile_compatibility_flag[1] = bit_depth == 8;
304  ptl->general_profile_compatibility_flag[2] = bit_depth <= 10;
305  }
307 
312 
313  ptl->general_max_12bit_constraint_flag = bit_depth <= 12;
314  ptl->general_max_10bit_constraint_flag = bit_depth <= 10;
315  ptl->general_max_8bit_constraint_flag = bit_depth == 8;
316 
317  ptl->general_max_422chroma_constraint_flag = chroma_format <= 2;
318  ptl->general_max_420chroma_constraint_flag = chroma_format <= 1;
319  ptl->general_max_monochrome_constraint_flag = chroma_format == 0;
320 
321  ptl->general_intra_constraint_flag = ctx->gop_size == 1;
322 
324 
325  if (avctx->level != FF_LEVEL_UNKNOWN) {
326  ptl->general_level_idc = avctx->level;
327  } else {
328  const H265LevelDescriptor *level;
329 
330  level = ff_h265_guess_level(ptl, avctx->bit_rate,
331  ctx->surface_width, ctx->surface_height,
332  ctx->nb_slices, ctx->tile_rows, ctx->tile_cols,
333  (ctx->b_per_p > 0) + 1);
334  if (level) {
335  av_log(avctx, AV_LOG_VERBOSE, "Using level %s.\n", level->name);
336  ptl->general_level_idc = level->level_idc;
337  } else {
338  av_log(avctx, AV_LOG_VERBOSE, "Stream will not conform to "
339  "any normal level; using level 8.5.\n");
340  ptl->general_level_idc = 255;
341  // The tier flag must be set in level 8.5.
342  ptl->general_tier_flag = 1;
343  }
344  }
345 
348  vps->vps_max_num_reorder_pics[0] = ctx->max_b_depth;
349  vps->vps_max_latency_increase_plus1[0] = 0;
350 
351  vps->vps_max_layer_id = 0;
352  vps->vps_num_layer_sets_minus1 = 0;
353  vps->layer_id_included_flag[0][0] = 1;
354 
356  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
357  vps->vps_num_units_in_tick = avctx->framerate.den;
358  vps->vps_time_scale = avctx->framerate.num;
361  } else {
362  vps->vps_num_units_in_tick = avctx->time_base.num;
363  vps->vps_time_scale = avctx->time_base.den;
365  }
366  vps->vps_num_hrd_parameters = 0;
367 
368 
369  // SPS
370 
373  .nuh_layer_id = 0,
374  .nuh_temporal_id_plus1 = 1,
375  };
376 
378 
381 
383 
384  sps->sps_seq_parameter_set_id = 0;
385 
386  sps->chroma_format_idc = chroma_format;
388 
391 
392  if (avctx->width != ctx->surface_width ||
393  avctx->height != ctx->surface_height) {
394  sps->conformance_window_flag = 1;
395  sps->conf_win_left_offset = 0;
396  sps->conf_win_right_offset =
397  (ctx->surface_width - avctx->width) >> desc->log2_chroma_w;
398  sps->conf_win_top_offset = 0;
400  (ctx->surface_height - avctx->height) >> desc->log2_chroma_h;
401  } else {
402  sps->conformance_window_flag = 0;
403  }
404 
405  sps->bit_depth_luma_minus8 = bit_depth - 8;
406  sps->bit_depth_chroma_minus8 = bit_depth - 8;
407 
409 
412  for (i = 0; i <= sps->sps_max_sub_layers_minus1; i++) {
419  }
420 
421  // These have to come from the capabilities of the encoder. We have no
422  // way to query them, so just hardcode parameters which work on the Intel
423  // driver.
424  // CTB size from 8x8 to 32x32.
427  // Transform size from 4x4 to 32x32.
430  // Full transform hierarchy allowed (2-5).
433  // AMP works.
434  sps->amp_enabled_flag = 1;
435  // SAO and temporal MVP do not work.
438 
439  sps->pcm_enabled_flag = 0;
440 
441  // STRPSs should ideally be here rather than defined individually in
442  // each slice, but the structure isn't completely fixed so for now
443  // don't bother.
446 
448 
449  if (avctx->sample_aspect_ratio.num != 0 &&
450  avctx->sample_aspect_ratio.den != 0) {
451  static const AVRational sar_idc[] = {
452  { 0, 0 },
453  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
454  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
455  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
456  { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
457  };
458  int num, den, i;
459  av_reduce(&num, &den, avctx->sample_aspect_ratio.num,
460  avctx->sample_aspect_ratio.den, 65535);
461  for (i = 0; i < FF_ARRAY_ELEMS(sar_idc); i++) {
462  if (num == sar_idc[i].num &&
463  den == sar_idc[i].den) {
464  vui->aspect_ratio_idc = i;
465  break;
466  }
467  }
468  if (i >= FF_ARRAY_ELEMS(sar_idc)) {
469  vui->aspect_ratio_idc = 255;
470  vui->sar_width = num;
471  vui->sar_height = den;
472  }
474  }
475 
476  // Unspecified video format, from table E-2.
477  vui->video_format = 5;
478  vui->video_full_range_flag =
479  avctx->color_range == AVCOL_RANGE_JPEG;
480  vui->colour_primaries = avctx->color_primaries;
481  vui->transfer_characteristics = avctx->color_trc;
482  vui->matrix_coefficients = avctx->colorspace;
483  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
484  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
487  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED ||
490 
495  avctx->chroma_sample_location - 1;
496  }
497 
500  vui->vui_time_scale = vps->vps_time_scale;
504 
508  vui->max_bytes_per_pic_denom = 0;
509  vui->max_bits_per_min_cu_denom = 0;
511  vui->log2_max_mv_length_vertical = 15;
512 
513 
514  // PPS
515 
518  .nuh_layer_id = 0,
519  .nuh_temporal_id_plus1 = 1,
520  };
521 
522  pps->pps_pic_parameter_set_id = 0;
524 
527 
528  pps->init_qp_minus26 = priv->fixed_qp_idr - 26;
529 
530  pps->cu_qp_delta_enabled_flag = (ctx->va_rc_mode != VA_RC_CQP);
531  pps->diff_cu_qp_delta_depth = 0;
532 
533  if (ctx->tile_rows && ctx->tile_cols) {
534  int uniform_spacing;
535 
536  pps->tiles_enabled_flag = 1;
537  pps->num_tile_columns_minus1 = ctx->tile_cols - 1;
538  pps->num_tile_rows_minus1 = ctx->tile_rows - 1;
539 
540  // Test whether the spacing provided matches the H.265 uniform
541  // spacing, and set the flag if it does.
542  uniform_spacing = 1;
543  for (i = 0; i <= pps->num_tile_columns_minus1 &&
544  uniform_spacing; i++) {
545  if (ctx->col_width[i] !=
546  (i + 1) * ctx->slice_block_cols / ctx->tile_cols -
547  i * ctx->slice_block_cols / ctx->tile_cols)
548  uniform_spacing = 0;
549  }
550  for (i = 0; i <= pps->num_tile_rows_minus1 &&
551  uniform_spacing; i++) {
552  if (ctx->row_height[i] !=
553  (i + 1) * ctx->slice_block_rows / ctx->tile_rows -
554  i * ctx->slice_block_rows / ctx->tile_rows)
555  uniform_spacing = 0;
556  }
557  pps->uniform_spacing_flag = uniform_spacing;
558 
559  for (i = 0; i <= pps->num_tile_columns_minus1; i++)
560  pps->column_width_minus1[i] = ctx->col_width[i] - 1;
561  for (i = 0; i <= pps->num_tile_rows_minus1; i++)
562  pps->row_height_minus1[i] = ctx->row_height[i] - 1;
563 
565  }
566 
568 
569  // Fill VAAPI parameter buffers.
570 
571  *vseq = (VAEncSequenceParameterBufferHEVC) {
572  .general_profile_idc = vps->profile_tier_level.general_profile_idc,
573  .general_level_idc = vps->profile_tier_level.general_level_idc,
574  .general_tier_flag = vps->profile_tier_level.general_tier_flag,
575 
576  .intra_period = ctx->gop_size,
577  .intra_idr_period = ctx->gop_size,
578  .ip_period = ctx->b_per_p + 1,
579  .bits_per_second = ctx->va_bit_rate,
580 
581  .pic_width_in_luma_samples = sps->pic_width_in_luma_samples,
582  .pic_height_in_luma_samples = sps->pic_height_in_luma_samples,
583 
584  .seq_fields.bits = {
585  .chroma_format_idc = sps->chroma_format_idc,
586  .separate_colour_plane_flag = sps->separate_colour_plane_flag,
587  .bit_depth_luma_minus8 = sps->bit_depth_luma_minus8,
588  .bit_depth_chroma_minus8 = sps->bit_depth_chroma_minus8,
589  .scaling_list_enabled_flag = sps->scaling_list_enabled_flag,
590  .strong_intra_smoothing_enabled_flag =
592  .amp_enabled_flag = sps->amp_enabled_flag,
593  .sample_adaptive_offset_enabled_flag =
595  .pcm_enabled_flag = sps->pcm_enabled_flag,
596  .pcm_loop_filter_disabled_flag = sps->pcm_loop_filter_disabled_flag,
597  .sps_temporal_mvp_enabled_flag = sps->sps_temporal_mvp_enabled_flag,
598  },
599 
600  .log2_min_luma_coding_block_size_minus3 =
602  .log2_diff_max_min_luma_coding_block_size =
604  .log2_min_transform_block_size_minus2 =
606  .log2_diff_max_min_transform_block_size =
608  .max_transform_hierarchy_depth_inter =
610  .max_transform_hierarchy_depth_intra =
612 
613  .pcm_sample_bit_depth_luma_minus1 =
615  .pcm_sample_bit_depth_chroma_minus1 =
617  .log2_min_pcm_luma_coding_block_size_minus3 =
619  .log2_max_pcm_luma_coding_block_size_minus3 =
622 
623  .vui_parameters_present_flag = 0,
624  };
625 
626  *vpic = (VAEncPictureParameterBufferHEVC) {
627  .decoded_curr_pic = {
628  .picture_id = VA_INVALID_ID,
629  .flags = VA_PICTURE_HEVC_INVALID,
630  },
631 
632  .coded_buf = VA_INVALID_ID,
633 
634  .collocated_ref_pic_index = 0xff,
635 
636  .last_picture = 0,
637 
638  .pic_init_qp = pps->init_qp_minus26 + 26,
639  .diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth,
640  .pps_cb_qp_offset = pps->pps_cb_qp_offset,
641  .pps_cr_qp_offset = pps->pps_cr_qp_offset,
642 
643  .num_tile_columns_minus1 = pps->num_tile_columns_minus1,
644  .num_tile_rows_minus1 = pps->num_tile_rows_minus1,
645 
646  .log2_parallel_merge_level_minus2 = pps->log2_parallel_merge_level_minus2,
647  .ctu_max_bitsize_allowed = 0,
648 
649  .num_ref_idx_l0_default_active_minus1 =
651  .num_ref_idx_l1_default_active_minus1 =
653 
654  .slice_pic_parameter_set_id = pps->pps_pic_parameter_set_id,
655 
656  .pic_fields.bits = {
657  .sign_data_hiding_enabled_flag = pps->sign_data_hiding_enabled_flag,
658  .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
659  .transform_skip_enabled_flag = pps->transform_skip_enabled_flag,
660  .cu_qp_delta_enabled_flag = pps->cu_qp_delta_enabled_flag,
661  .weighted_pred_flag = pps->weighted_pred_flag,
662  .weighted_bipred_flag = pps->weighted_bipred_flag,
663  .transquant_bypass_enabled_flag = pps->transquant_bypass_enabled_flag,
664  .tiles_enabled_flag = pps->tiles_enabled_flag,
665  .entropy_coding_sync_enabled_flag = pps->entropy_coding_sync_enabled_flag,
666  .loop_filter_across_tiles_enabled_flag =
668  .scaling_list_data_present_flag = (sps->sps_scaling_list_data_present_flag |
670  .screen_content_flag = 0,
671  .enable_gpu_weighted_prediction = 0,
672  .no_output_of_prior_pics_flag = 0,
673  },
674  };
675 
676  if (pps->tiles_enabled_flag) {
677  for (i = 0; i <= vpic->num_tile_rows_minus1; i++)
678  vpic->row_height_minus1[i] = pps->row_height_minus1[i];
679  for (i = 0; i <= vpic->num_tile_columns_minus1; i++)
680  vpic->column_width_minus1[i] = pps->column_width_minus1[i];
681  }
682 
683  return 0;
684 }
685 
687  VAAPIEncodePicture *pic)
688 {
689  VAAPIEncodeContext *ctx = avctx->priv_data;
690  VAAPIEncodeH265Context *priv = avctx->priv_data;
691  VAAPIEncodeH265Picture *hpic = pic->priv_data;
692  VAAPIEncodePicture *prev = pic->prev;
693  VAAPIEncodeH265Picture *hprev = prev ? prev->priv_data : NULL;
694  VAEncPictureParameterBufferHEVC *vpic = pic->codec_picture_params;
695  int i;
696 
697  if (pic->type == PICTURE_TYPE_IDR) {
698  av_assert0(pic->display_order == pic->encode_order);
699 
700  hpic->last_idr_frame = pic->display_order;
701 
703  hpic->slice_type = HEVC_SLICE_I;
704  hpic->pic_type = 0;
705  } else {
706  av_assert0(prev);
707  hpic->last_idr_frame = hprev->last_idr_frame;
708 
709  if (pic->type == PICTURE_TYPE_I) {
711  hpic->slice_type = HEVC_SLICE_I;
712  hpic->pic_type = 0;
713  } else if (pic->type == PICTURE_TYPE_P) {
714  av_assert0(pic->refs[0]);
716  hpic->slice_type = HEVC_SLICE_P;
717  hpic->pic_type = 1;
718  } else {
719  VAAPIEncodePicture *irap_ref;
720  av_assert0(pic->refs[0] && pic->refs[1]);
721  for (irap_ref = pic; irap_ref; irap_ref = irap_ref->refs[1]) {
722  if (irap_ref->type == PICTURE_TYPE_I)
723  break;
724  }
725  if (pic->b_depth == ctx->max_b_depth) {
726  hpic->slice_nal_unit = irap_ref ? HEVC_NAL_RASL_N
728  } else {
729  hpic->slice_nal_unit = irap_ref ? HEVC_NAL_RASL_R
731  }
732  hpic->slice_type = HEVC_SLICE_B;
733  hpic->pic_type = 2;
734  }
735  }
736  hpic->pic_order_cnt = pic->display_order - hpic->last_idr_frame;
737 
738  if (priv->aud) {
739  priv->aud_needed = 1;
740  priv->raw_aud = (H265RawAUD) {
741  .nal_unit_header = {
743  .nuh_layer_id = 0,
744  .nuh_temporal_id_plus1 = 1,
745  },
746  .pic_type = hpic->pic_type,
747  };
748  } else {
749  priv->aud_needed = 0;
750  }
751 
752  priv->sei_needed = 0;
753 
754  // Only look for the metadata on I/IDR frame on the output. We
755  // may force an IDR frame on the output where the medadata gets
756  // changed on the input frame.
757  if ((priv->sei & SEI_MASTERING_DISPLAY) &&
758  (pic->type == PICTURE_TYPE_I || pic->type == PICTURE_TYPE_IDR)) {
759  AVFrameSideData *sd =
762 
763  if (sd) {
766 
767  // SEI is needed when both the primaries and luminance are set
768  if (mdm->has_primaries && mdm->has_luminance) {
770  &priv->sei_mastering_display;
771  const int mapping[3] = {1, 2, 0};
772  const int chroma_den = 50000;
773  const int luma_den = 10000;
774 
775  for (i = 0; i < 3; i++) {
776  const int j = mapping[i];
777  mdcv->display_primaries_x[i] =
778  FFMIN(lrint(chroma_den *
779  av_q2d(mdm->display_primaries[j][0])),
780  chroma_den);
781  mdcv->display_primaries_y[i] =
782  FFMIN(lrint(chroma_den *
783  av_q2d(mdm->display_primaries[j][1])),
784  chroma_den);
785  }
786 
787  mdcv->white_point_x =
788  FFMIN(lrint(chroma_den * av_q2d(mdm->white_point[0])),
789  chroma_den);
790  mdcv->white_point_y =
791  FFMIN(lrint(chroma_den * av_q2d(mdm->white_point[1])),
792  chroma_den);
793 
795  lrint(luma_den * av_q2d(mdm->max_luminance));
797  FFMIN(lrint(luma_den * av_q2d(mdm->min_luminance)),
799 
801  }
802  }
803  }
804 
805  if ((priv->sei & SEI_CONTENT_LIGHT_LEVEL) &&
806  (pic->type == PICTURE_TYPE_I || pic->type == PICTURE_TYPE_IDR)) {
807  AVFrameSideData *sd =
810 
811  if (sd) {
816 
817  clli->max_content_light_level = FFMIN(clm->MaxCLL, 65535);
818  clli->max_pic_average_light_level = FFMIN(clm->MaxFALL, 65535);
819 
821  }
822  }
823 
824  vpic->decoded_curr_pic = (VAPictureHEVC) {
825  .picture_id = pic->recon_surface,
826  .pic_order_cnt = hpic->pic_order_cnt,
827  .flags = 0,
828  };
829 
830  for (i = 0; i < pic->nb_refs; i++) {
831  VAAPIEncodePicture *ref = pic->refs[i];
833 
834  av_assert0(ref && ref->encode_order < pic->encode_order);
835  href = ref->priv_data;
836 
837  vpic->reference_frames[i] = (VAPictureHEVC) {
838  .picture_id = ref->recon_surface,
839  .pic_order_cnt = href->pic_order_cnt,
840  .flags = (ref->display_order < pic->display_order ?
841  VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE : 0) |
842  (ref->display_order > pic->display_order ?
843  VA_PICTURE_HEVC_RPS_ST_CURR_AFTER : 0),
844  };
845  }
846  for (; i < FF_ARRAY_ELEMS(vpic->reference_frames); i++) {
847  vpic->reference_frames[i] = (VAPictureHEVC) {
848  .picture_id = VA_INVALID_ID,
849  .flags = VA_PICTURE_HEVC_INVALID,
850  };
851  }
852 
853  vpic->coded_buf = pic->output_buffer;
854 
855  vpic->nal_unit_type = hpic->slice_nal_unit;
856 
857  switch (pic->type) {
858  case PICTURE_TYPE_IDR:
859  vpic->pic_fields.bits.idr_pic_flag = 1;
860  vpic->pic_fields.bits.coding_type = 1;
861  vpic->pic_fields.bits.reference_pic_flag = 1;
862  break;
863  case PICTURE_TYPE_I:
864  vpic->pic_fields.bits.idr_pic_flag = 0;
865  vpic->pic_fields.bits.coding_type = 1;
866  vpic->pic_fields.bits.reference_pic_flag = 1;
867  break;
868  case PICTURE_TYPE_P:
869  vpic->pic_fields.bits.idr_pic_flag = 0;
870  vpic->pic_fields.bits.coding_type = 2;
871  vpic->pic_fields.bits.reference_pic_flag = 1;
872  break;
873  case PICTURE_TYPE_B:
874  vpic->pic_fields.bits.idr_pic_flag = 0;
875  vpic->pic_fields.bits.coding_type = 3;
876  vpic->pic_fields.bits.reference_pic_flag = 0;
877  break;
878  default:
879  av_assert0(0 && "invalid picture type");
880  }
881 
882  return 0;
883 }
884 
886  VAAPIEncodePicture *pic,
887  VAAPIEncodeSlice *slice)
888 {
889  VAAPIEncodeH265Context *priv = avctx->priv_data;
890  VAAPIEncodeH265Picture *hpic = pic->priv_data;
891  const H265RawSPS *sps = &priv->raw_sps;
892  const H265RawPPS *pps = &priv->raw_pps;
893  H265RawSliceHeader *sh = &priv->raw_slice.header;
894  VAEncPictureParameterBufferHEVC *vpic = pic->codec_picture_params;
895  VAEncSliceParameterBufferHEVC *vslice = slice->codec_slice_params;
896  int i;
897 
899  .nal_unit_type = hpic->slice_nal_unit,
900  .nuh_layer_id = 0,
901  .nuh_temporal_id_plus1 = 1,
902  };
903 
905 
906  sh->first_slice_segment_in_pic_flag = slice->index == 0;
907  sh->slice_segment_address = slice->block_start;
908 
909  sh->slice_type = hpic->slice_type;
910 
912  (1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4)) - 1;
913 
914  if (pic->type != PICTURE_TYPE_IDR) {
915  H265RawSTRefPicSet *rps;
916  const VAAPIEncodeH265Picture *strp;
917  int rps_poc[MAX_DPB_SIZE];
918  int rps_used[MAX_DPB_SIZE];
919  int i, j, poc, rps_pics;
920 
922 
923  rps = &sh->short_term_ref_pic_set;
924  memset(rps, 0, sizeof(*rps));
925 
926  rps_pics = 0;
927  for (i = 0; i < pic->nb_refs; i++) {
928  strp = pic->refs[i]->priv_data;
929  rps_poc[rps_pics] = strp->pic_order_cnt;
930  rps_used[rps_pics] = 1;
931  ++rps_pics;
932  }
933  for (i = 0; i < pic->nb_dpb_pics; i++) {
934  if (pic->dpb[i] == pic)
935  continue;
936  for (j = 0; j < pic->nb_refs; j++) {
937  if (pic->dpb[i] == pic->refs[j])
938  break;
939  }
940  if (j < pic->nb_refs)
941  continue;
942  strp = pic->dpb[i]->priv_data;
943  rps_poc[rps_pics] = strp->pic_order_cnt;
944  rps_used[rps_pics] = 0;
945  ++rps_pics;
946  }
947 
948  for (i = 1; i < rps_pics; i++) {
949  for (j = i; j > 0; j--) {
950  if (rps_poc[j] > rps_poc[j - 1])
951  break;
952  av_assert0(rps_poc[j] != rps_poc[j - 1]);
953  FFSWAP(int, rps_poc[j], rps_poc[j - 1]);
954  FFSWAP(int, rps_used[j], rps_used[j - 1]);
955  }
956  }
957 
958  av_log(avctx, AV_LOG_DEBUG, "RPS for POC %d:",
959  hpic->pic_order_cnt);
960  for (i = 0; i < rps_pics; i++) {
961  av_log(avctx, AV_LOG_DEBUG, " (%d,%d)",
962  rps_poc[i], rps_used[i]);
963  }
964  av_log(avctx, AV_LOG_DEBUG, "\n");
965 
966  for (i = 0; i < rps_pics; i++) {
967  av_assert0(rps_poc[i] != hpic->pic_order_cnt);
968  if (rps_poc[i] > hpic->pic_order_cnt)
969  break;
970  }
971 
972  rps->num_negative_pics = i;
973  poc = hpic->pic_order_cnt;
974  for (j = i - 1; j >= 0; j--) {
975  rps->delta_poc_s0_minus1[i - 1 - j] = poc - rps_poc[j] - 1;
976  rps->used_by_curr_pic_s0_flag[i - 1 - j] = rps_used[j];
977  poc = rps_poc[j];
978  }
979 
980  rps->num_positive_pics = rps_pics - i;
981  poc = hpic->pic_order_cnt;
982  for (j = i; j < rps_pics; j++) {
983  rps->delta_poc_s1_minus1[j - i] = rps_poc[j] - poc - 1;
984  rps->used_by_curr_pic_s1_flag[j - i] = rps_used[j];
985  poc = rps_poc[j];
986  }
987 
988  sh->num_long_term_sps = 0;
989  sh->num_long_term_pics = 0;
990 
995  sh->collocated_ref_idx = 0;
996  }
997 
1001  }
1002 
1005 
1006  if (pic->type == PICTURE_TYPE_B)
1007  sh->slice_qp_delta = priv->fixed_qp_b - (pps->init_qp_minus26 + 26);
1008  else if (pic->type == PICTURE_TYPE_P)
1009  sh->slice_qp_delta = priv->fixed_qp_p - (pps->init_qp_minus26 + 26);
1010  else
1011  sh->slice_qp_delta = priv->fixed_qp_idr - (pps->init_qp_minus26 + 26);
1012 
1013 
1014  *vslice = (VAEncSliceParameterBufferHEVC) {
1015  .slice_segment_address = sh->slice_segment_address,
1016  .num_ctu_in_slice = slice->block_size,
1017 
1018  .slice_type = sh->slice_type,
1019  .slice_pic_parameter_set_id = sh->slice_pic_parameter_set_id,
1020 
1021  .num_ref_idx_l0_active_minus1 = sh->num_ref_idx_l0_active_minus1,
1022  .num_ref_idx_l1_active_minus1 = sh->num_ref_idx_l1_active_minus1,
1023 
1024  .luma_log2_weight_denom = sh->luma_log2_weight_denom,
1025  .delta_chroma_log2_weight_denom = sh->delta_chroma_log2_weight_denom,
1026 
1027  .max_num_merge_cand = 5 - sh->five_minus_max_num_merge_cand,
1028 
1029  .slice_qp_delta = sh->slice_qp_delta,
1030  .slice_cb_qp_offset = sh->slice_cb_qp_offset,
1031  .slice_cr_qp_offset = sh->slice_cr_qp_offset,
1032 
1033  .slice_beta_offset_div2 = sh->slice_beta_offset_div2,
1034  .slice_tc_offset_div2 = sh->slice_tc_offset_div2,
1035 
1036  .slice_fields.bits = {
1037  .last_slice_of_pic_flag = slice->index == pic->nb_slices - 1,
1038  .dependent_slice_segment_flag = sh->dependent_slice_segment_flag,
1039  .colour_plane_id = sh->colour_plane_id,
1040  .slice_temporal_mvp_enabled_flag =
1042  .slice_sao_luma_flag = sh->slice_sao_luma_flag,
1043  .slice_sao_chroma_flag = sh->slice_sao_chroma_flag,
1044  .num_ref_idx_active_override_flag =
1046  .mvd_l1_zero_flag = sh->mvd_l1_zero_flag,
1047  .cabac_init_flag = sh->cabac_init_flag,
1048  .slice_deblocking_filter_disabled_flag =
1050  .slice_loop_filter_across_slices_enabled_flag =
1052  .collocated_from_l0_flag = sh->collocated_from_l0_flag,
1053  },
1054  };
1055 
1056  for (i = 0; i < FF_ARRAY_ELEMS(vslice->ref_pic_list0); i++) {
1057  vslice->ref_pic_list0[i].picture_id = VA_INVALID_ID;
1058  vslice->ref_pic_list0[i].flags = VA_PICTURE_HEVC_INVALID;
1059  vslice->ref_pic_list1[i].picture_id = VA_INVALID_ID;
1060  vslice->ref_pic_list1[i].flags = VA_PICTURE_HEVC_INVALID;
1061  }
1062 
1063  av_assert0(pic->nb_refs <= 2);
1064  if (pic->nb_refs >= 1) {
1065  // Backward reference for P- or B-frame.
1066  av_assert0(pic->type == PICTURE_TYPE_P ||
1067  pic->type == PICTURE_TYPE_B);
1068  vslice->ref_pic_list0[0] = vpic->reference_frames[0];
1069  }
1070  if (pic->nb_refs >= 2) {
1071  // Forward reference for B-frame.
1072  av_assert0(pic->type == PICTURE_TYPE_B);
1073  vslice->ref_pic_list1[0] = vpic->reference_frames[1];
1074  }
1075 
1076  return 0;
1077 }
1078 
1080 {
1081  VAAPIEncodeContext *ctx = avctx->priv_data;
1082  VAAPIEncodeH265Context *priv = avctx->priv_data;
1083  int err;
1084 
1085  err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_HEVC, avctx);
1086  if (err < 0)
1087  return err;
1088 
1089  if (ctx->va_rc_mode == VA_RC_CQP) {
1090  // Note that VAAPI only supports positive QP values - the range is
1091  // therefore always bounded below by 1, even in 10-bit mode where
1092  // it should go down to -12.
1093 
1094  priv->fixed_qp_p = av_clip(ctx->rc_quality, 1, 51);
1095  if (avctx->i_quant_factor > 0.0)
1096  priv->fixed_qp_idr =
1097  av_clip((avctx->i_quant_factor * priv->fixed_qp_p +
1098  avctx->i_quant_offset) + 0.5, 1, 51);
1099  else
1100  priv->fixed_qp_idr = priv->fixed_qp_p;
1101  if (avctx->b_quant_factor > 0.0)
1102  priv->fixed_qp_b =
1103  av_clip((avctx->b_quant_factor * priv->fixed_qp_p +
1104  avctx->b_quant_offset) + 0.5, 1, 51);
1105  else
1106  priv->fixed_qp_b = priv->fixed_qp_p;
1107 
1108  av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
1109  "%d / %d / %d for IDR- / P- / B-frames.\n",
1110  priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
1111 
1112  } else {
1113  // These still need to be set for init_qp/slice_qp_delta.
1114  priv->fixed_qp_idr = 30;
1115  priv->fixed_qp_p = 30;
1116  priv->fixed_qp_b = 30;
1117  }
1118 
1119  ctx->roi_quant_range = 51 + 6 * (ctx->profile->depth - 8);
1120 
1121  return 0;
1122 }
1123 
1125  { FF_PROFILE_HEVC_MAIN, 8, 3, 1, 1, VAProfileHEVCMain },
1126  { FF_PROFILE_HEVC_REXT, 8, 3, 1, 1, VAProfileHEVCMain },
1127 #if VA_CHECK_VERSION(0, 37, 0)
1128  { FF_PROFILE_HEVC_MAIN_10, 10, 3, 1, 1, VAProfileHEVCMain10 },
1129  { FF_PROFILE_HEVC_REXT, 10, 3, 1, 1, VAProfileHEVCMain10 },
1130 #endif
1131 #if VA_CHECK_VERSION(1, 2, 0)
1132  { FF_PROFILE_HEVC_REXT, 8, 3, 1, 0, VAProfileHEVCMain422_10 },
1133  { FF_PROFILE_HEVC_REXT, 10, 3, 1, 0, VAProfileHEVCMain422_10 },
1134 #endif
1135  { FF_PROFILE_UNKNOWN }
1136 };
1137 
1140 
1141  .flags = FLAG_SLICE_CONTROL |
1142  FLAG_B_PICTURES |
1145 
1146  .default_quality = 25,
1147 
1148  .configure = &vaapi_encode_h265_configure,
1149 
1150  .picture_priv_data_size = sizeof(VAAPIEncodeH265Picture),
1151 
1152  .sequence_params_size = sizeof(VAEncSequenceParameterBufferHEVC),
1153  .init_sequence_params = &vaapi_encode_h265_init_sequence_params,
1154 
1155  .picture_params_size = sizeof(VAEncPictureParameterBufferHEVC),
1156  .init_picture_params = &vaapi_encode_h265_init_picture_params,
1157 
1158  .slice_params_size = sizeof(VAEncSliceParameterBufferHEVC),
1159  .init_slice_params = &vaapi_encode_h265_init_slice_params,
1160 
1161  .sequence_header_type = VAEncPackedHeaderSequence,
1162  .write_sequence_header = &vaapi_encode_h265_write_sequence_header,
1163 
1164  .slice_header_type = VAEncPackedHeaderHEVC_Slice,
1165  .write_slice_header = &vaapi_encode_h265_write_slice_header,
1166 
1167  .write_extra_header = &vaapi_encode_h265_write_extra_header,
1168 };
1169 
1171 {
1172  VAAPIEncodeContext *ctx = avctx->priv_data;
1173  VAAPIEncodeH265Context *priv = avctx->priv_data;
1174 
1175  ctx->codec = &vaapi_encode_type_h265;
1176 
1177  if (avctx->profile == FF_PROFILE_UNKNOWN)
1178  avctx->profile = priv->profile;
1179  if (avctx->level == FF_LEVEL_UNKNOWN)
1180  avctx->level = priv->level;
1181 
1182  if (avctx->level != FF_LEVEL_UNKNOWN && avctx->level & ~0xff) {
1183  av_log(avctx, AV_LOG_ERROR, "Invalid level %d: must fit "
1184  "in 8-bit unsigned integer.\n", avctx->level);
1185  return AVERROR(EINVAL);
1186  }
1187 
1188  ctx->desired_packed_headers =
1189  VA_ENC_PACKED_HEADER_SEQUENCE | // VPS, SPS and PPS.
1190  VA_ENC_PACKED_HEADER_SLICE | // Slice headers.
1191  VA_ENC_PACKED_HEADER_MISC; // SEI
1192 
1193  ctx->surface_width = FFALIGN(avctx->width, 16);
1194  ctx->surface_height = FFALIGN(avctx->height, 16);
1195 
1196  // CTU size is currently hard-coded to 32.
1197  ctx->slice_block_width = ctx->slice_block_height = 32;
1198 
1199  if (priv->qp > 0)
1200  ctx->explicit_qp = priv->qp;
1201 
1202  return ff_vaapi_encode_init(avctx);
1203 }
1204 
1206 {
1207  VAAPIEncodeH265Context *priv = avctx->priv_data;
1208 
1210  ff_cbs_close(&priv->cbc);
1211 
1212  return ff_vaapi_encode_close(avctx);
1213 }
1214 
1215 #define OFFSET(x) offsetof(VAAPIEncodeH265Context, x)
1216 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
1220 
1221  { "qp", "Constant QP (for P-frames; scaled by qfactor/qoffset for I/B)",
1222  OFFSET(qp), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 52, FLAGS },
1223 
1224  { "aud", "Include AUD",
1225  OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
1226 
1227  { "profile", "Set profile (general_profile_idc)",
1229  { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 0xff, FLAGS, "profile" },
1230 
1231 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1232  { .i64 = value }, 0, 0, FLAGS, "profile"
1233  { PROFILE("main", FF_PROFILE_HEVC_MAIN) },
1234  { PROFILE("main10", FF_PROFILE_HEVC_MAIN_10) },
1235  { PROFILE("rext", FF_PROFILE_HEVC_REXT) },
1236 #undef PROFILE
1237 
1238  { "tier", "Set tier (general_tier_flag)",
1239  OFFSET(tier), AV_OPT_TYPE_INT,
1240  { .i64 = 0 }, 0, 1, FLAGS, "tier" },
1241  { "main", NULL, 0, AV_OPT_TYPE_CONST,
1242  { .i64 = 0 }, 0, 0, FLAGS, "tier" },
1243  { "high", NULL, 0, AV_OPT_TYPE_CONST,
1244  { .i64 = 1 }, 0, 0, FLAGS, "tier" },
1245 
1246  { "level", "Set level (general_level_idc)",
1248  { .i64 = FF_LEVEL_UNKNOWN }, FF_LEVEL_UNKNOWN, 0xff, FLAGS, "level" },
1249 
1250 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1251  { .i64 = value }, 0, 0, FLAGS, "level"
1252  { LEVEL("1", 30) },
1253  { LEVEL("2", 60) },
1254  { LEVEL("2.1", 63) },
1255  { LEVEL("3", 90) },
1256  { LEVEL("3.1", 93) },
1257  { LEVEL("4", 120) },
1258  { LEVEL("4.1", 123) },
1259  { LEVEL("5", 150) },
1260  { LEVEL("5.1", 153) },
1261  { LEVEL("5.2", 156) },
1262  { LEVEL("6", 180) },
1263  { LEVEL("6.1", 183) },
1264  { LEVEL("6.2", 186) },
1265 #undef LEVEL
1266 
1267  { "sei", "Set SEI to include",
1270  0, INT_MAX, FLAGS, "sei" },
1271  { "hdr",
1272  "Include HDR metadata for mastering display colour volume "
1273  "and content light level information",
1274  0, AV_OPT_TYPE_CONST,
1276  INT_MIN, INT_MAX, FLAGS, "sei" },
1277 
1278  { "tiles", "Tile columns x rows",
1279  OFFSET(common.tile_cols), AV_OPT_TYPE_IMAGE_SIZE,
1280  { .str = NULL }, 0, 0, FLAGS },
1281 
1282  { NULL },
1283 };
1284 
1286  { "b", "0" },
1287  { "bf", "2" },
1288  { "g", "120" },
1289  { "i_qfactor", "1" },
1290  { "i_qoffset", "0" },
1291  { "b_qfactor", "6/5" },
1292  { "b_qoffset", "0" },
1293  { "qmin", "-1" },
1294  { "qmax", "-1" },
1295  { NULL },
1296 };
1297 
1299  .class_name = "h265_vaapi",
1300  .item_name = av_default_item_name,
1301  .option = vaapi_encode_h265_options,
1302  .version = LIBAVUTIL_VERSION_INT,
1303 };
1304 
1306  .name = "hevc_vaapi",
1307  .long_name = NULL_IF_CONFIG_SMALL("H.265/HEVC (VAAPI)"),
1308  .type = AVMEDIA_TYPE_VIDEO,
1309  .id = AV_CODEC_ID_HEVC,
1310  .priv_data_size = sizeof(VAAPIEncodeH265Context),
1312  .receive_packet = &ff_vaapi_encode_receive_packet,
1313  .close = &vaapi_encode_h265_close,
1314  .priv_class = &vaapi_encode_h265_class,
1315  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE |
1317  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1318  .defaults = vaapi_encode_h265_defaults,
1319  .pix_fmts = (const enum AVPixelFormat[]) {
1322  },
1323  .hw_configs = ff_vaapi_encode_hw_configs,
1324  .wrapper_name = "vaapi",
1325 };
#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:49
uint8_t sps_video_parameter_set_id
Definition: cbs_h265.h:247
uint8_t loop_filter_across_tiles_enabled_flag
Definition: cbs_h265.h:384
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:2071
uint8_t transfer_characteristics
Definition: cbs_h265.h:141
uint8_t pps_pic_parameter_set_id
Definition: cbs_h265.h:349
uint8_t vps_poc_proportional_to_timing_flag
Definition: cbs_h265.h:208
uint8_t num_long_term_pics
Definition: cbs_h265.h:466
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
unsigned MaxCLL
Max content light level (cd/m^2).
uint8_t num_ref_idx_l0_default_active_minus1
Definition: cbs_h265.h:358
uint8_t log2_max_mv_length_horizontal
Definition: cbs_h265.h:173
AVOption.
Definition: opt.h:248
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
uint8_t motion_vectors_over_pic_boundaries_flag
Definition: cbs_h265.h:168
uint8_t sps_sub_layer_ordering_info_present_flag
Definition: cbs_h265.h:273
uint8_t slice_temporal_mvp_enabled_flag
Definition: cbs_h265.h:473
const char * desc
Definition: libsvtav1.c:79
uint8_t general_max_8bit_constraint_flag
Definition: cbs_h265.h:49
static int vaapi_encode_h265_add_nal(AVCodecContext *avctx, CodedBitstreamFragment *au, void *nal_unit)
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
uint8_t bitstream_restriction_flag
Definition: cbs_h265.h:166
uint8_t bit_depth_luma_minus8
Definition: cbs_h265.h:268
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:157
uint8_t vui_timing_info_present_flag
Definition: cbs_h265.h:158
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:75
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1171
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:249
uint16_t slice_pic_order_cnt_lsb
Definition: cbs_h265.h:459
int num
Numerator.
Definition: rational.h:59
uint8_t sps_max_num_reorder_pics[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:275
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:376
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:915
int8_t slice_qp_delta
Definition: cbs_h265.h:510
uint8_t restricted_ref_pic_lists_flag
Definition: cbs_h265.h:169
GLint GLenum type
Definition: opengl_enc.c:104
Mastering display metadata associated with a video frame.
Definition: frame.h:119
H265RawProfileTierLevel profile_tier_level
Definition: cbs_h265.h:252
int8_t slice_beta_offset_div2
Definition: cbs_h265.h:520
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
static av_cold int vaapi_encode_h265_close(AVCodecContext *avctx)
#define FF_ARRAY_ELEMS(a)
uint8_t collocated_from_l0_flag
Definition: cbs_h265.h:489
CodedBitstreamContext * cbc
void * codec_sequence_params
Definition: vaapi_encode.h:274
uint8_t sample_adaptive_offset_enabled_flag
Definition: cbs_h265.h:290
uint8_t vui_parameters_present_flag
Definition: cbs_h265.h:310
uint8_t pcm_sample_bit_depth_luma_minus1
Definition: cbs_h265.h:293
static const AVCodecDefault vaapi_encode_h265_defaults[]
uint8_t bit_depth_chroma_minus8
Definition: cbs_h265.h:269
fg index
int profile
profile
Definition: avcodec.h:1858
AVCodec.
Definition: codec.h:197
int8_t delta_chroma_log2_weight_denom
Definition: cbs_h265.h:493
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:848
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:38
int ff_cbs_sei_add_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, int prefix, uint32_t payload_type, void *payload_data, AVBufferRef *payload_buf)
Add an SEI message to an access unit.
Definition: cbs_sei.c:247
uint8_t used_by_curr_pic_s0_flag[HEVC_MAX_REFS]
Definition: cbs_h265.h:232
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:659
uint16_t slice_segment_address
Definition: cbs_h265.h:451
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:206
uint8_t sign_data_hiding_enabled_flag
Definition: cbs_h265.h:355
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1985
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:264
#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:77
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t slice_deblocking_filter_disabled_flag
Definition: cbs_h265.h:519
uint16_t pic_height_in_luma_samples
Definition: cbs_h265.h:260
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:521
AVOptions.
int8_t slice_cb_qp_offset
Definition: cbs_h265.h:511
uint8_t colour_primaries
Definition: cbs_h265.h:140
uint8_t vps_sub_layer_ordering_info_present_flag
Definition: cbs_h265.h:196
uint8_t general_max_12bit_constraint_flag
Definition: cbs_h265.h:47
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:805
uint8_t five_minus_max_num_merge_cand
Definition: cbs_h265.h:507
#define FF_PROFILE_HEVC_MAIN
Definition: avcodec.h:1946
uint8_t video_format
Definition: cbs_h265.h:137
H265RawSTRefPicSet short_term_ref_pic_set
Definition: cbs_h265.h:462
uint8_t vps_timing_info_present_flag
Definition: cbs_h265.h:205
uint8_t log2_max_pic_order_cnt_lsb_minus4
Definition: cbs_h265.h:271
uint8_t constrained_intra_pred_flag
Definition: cbs_h265.h:363
uint32_t sps_max_latency_increase_plus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:276
Structure to hold side data for an AVFrame.
Definition: frame.h:220
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
#define av_clip
Definition: common.h:122
uint8_t matrix_coefficients
Definition: cbs_h265.h:142
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:128
uint8_t vps_max_sub_layers_minus1
Definition: cbs_h265.h:191
struct VAAPIEncodePicture * prev
Definition: vaapi_encode.h:119
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
uint8_t general_max_monochrome_constraint_flag
Definition: cbs_h265.h:52
VASurfaceID recon_surface
Definition: vaapi_encode.h:94
uint8_t log2_min_luma_transform_block_size_minus2
Definition: cbs_h265.h:280
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:286
uint8_t log2_min_pcm_luma_coding_block_size_minus3
Definition: cbs_h265.h:295
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:1947
uint8_t video_full_range_flag
Definition: cbs_h265.h:138
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1178
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
void ff_cbs_fragment_reset(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:156
uint8_t chroma_sample_loc_type_bottom_field
Definition: cbs_h265.h:146
uint16_t vps_num_layer_sets_minus1
Definition: cbs_h265.h:202
uint8_t video_signal_type_present_flag
Definition: cbs_h265.h:136
const char * name
Definition: pixdesc.h:82
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:131
H265RawVUI vui
Definition: cbs_h265.h:311
uint8_t uniform_spacing_flag
Definition: cbs_h265.h:381
unsigned int va_rc_mode
Definition: vaapi_encode.h:230
uint32_t vui_num_ticks_poc_diff_one_minus1
Definition: cbs_h265.h:162
uint8_t vps_max_dec_pic_buffering_minus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:197
uint8_t log2_max_mv_length_vertical
Definition: cbs_h265.h:174
AVHWFramesContext * input_frames
Definition: vaapi_encode.h:249
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
uint8_t vps_video_parameter_set_id
Definition: cbs_h265.h:186
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
int row_height[MAX_TILE_ROWS]
Definition: vaapi_encode.h:314
uint8_t conformance_window_flag
Definition: cbs_h265.h:262
uint8_t max_bits_per_min_cu_denom
Definition: cbs_h265.h:172
static av_cold int vaapi_encode_h265_init(AVCodecContext *avctx)
uint8_t dependent_slice_segment_flag
Definition: cbs_h265.h:450
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
uint8_t chroma_loc_info_present_flag
Definition: cbs_h265.h:144
#define PROFILE(name, value)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
static int vaapi_encode_h265_init_sequence_params(AVCodecContext *avctx)
uint8_t num_negative_pics
Definition: cbs_h265.h:229
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: codec.h:204
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:841
static const AVOption vaapi_encode_h265_options[]
uint8_t general_interlaced_source_flag
Definition: cbs_h265.h:43
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
unsigned int va_bit_rate
Definition: vaapi_encode.h:232
uint8_t general_tier_flag
Definition: cbs_h265.h:37
uint8_t transform_skip_enabled_flag
Definition: cbs_h265.h:364
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:184
uint8_t pcm_sample_bit_depth_chroma_minus1
Definition: cbs_h265.h:294
uint16_t sar_height
Definition: cbs_h265.h:131
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
void * codec_picture_params
Definition: vaapi_encode.h:103
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:135
#define fail()
Definition: checkasm.h:133
uint8_t chroma_sample_loc_type_top_field
Definition: cbs_h265.h:145
uint8_t vps_max_layers_minus1
Definition: cbs_h265.h:190
uint32_t vui_time_scale
Definition: cbs_h265.h:160
static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice)
uint16_t conf_win_bottom_offset
Definition: cbs_h265.h:266
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:438
static const VAAPIEncodeType vaapi_encode_type_h265
uint8_t slice_type
Definition: cbs_h265.h:454
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:285
H265RawProfileTierLevel profile_tier_level
Definition: cbs_h265.h:194
#define FFMIN(a, b)
Definition: common.h:105
uint8_t general_max_422chroma_constraint_flag
Definition: cbs_h265.h:50
uint16_t sar_width
Definition: cbs_h265.h:130
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
uint8_t transquant_bypass_enabled_flag
Definition: cbs_h265.h:375
int width
picture width / height.
Definition: avcodec.h:709
uint8_t general_intra_constraint_flag
Definition: cbs_h265.h:53
uint32_t vps_max_latency_increase_plus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:199
uint8_t vui_hrd_parameters_present_flag
Definition: cbs_h265.h:163
#define FLAGS
uint16_t delta_poc_s1_minus1[HEVC_MAX_REFS]
Definition: cbs_h265.h:233
const VAAPIEncodeProfile * profile
Definition: vaapi_encode.h:217
uint8_t diff_cu_qp_delta_depth
Definition: cbs_h265.h:366
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1859
const VAAPIEncodeProfile * profiles
Definition: vaapi_encode.h:369
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:44
AVFormatContext * ctx
Definition: movenc.c:48
uint8_t colour_plane_id
Definition: cbs_h265.h:457
uint8_t sps_seq_parameter_set_id
Definition: cbs_h265.h:254
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1150
SEIRawContentLightLevelInfo sei_content_light_level
int level
level
Definition: avcodec.h:1984
AVFrame * input_image
Definition: vaapi_encode.h:90
uint16_t pic_width_in_luma_samples
Definition: cbs_h265.h:259
void * codec_picture_params
Definition: vaapi_encode.h:278
static int vaapi_encode_h265_init_picture_params(AVCodecContext *avctx, VAAPIEncodePicture *pic)
uint8_t vps_base_layer_available_flag
Definition: cbs_h265.h:189
int ff_vaapi_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
uint8_t log2_min_luma_coding_block_size_minus3
Definition: cbs_h265.h:278
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:124
uint8_t pps_seq_parameter_set_id
Definition: cbs_h265.h:350
Full range content.
Definition: pixfmt.h:586
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:358
if(ret)
uint16_t vps_num_hrd_parameters
Definition: cbs_h265.h:210
uint8_t num_ref_idx_l1_active_minus1
Definition: cbs_h265.h:480
uint8_t general_max_420chroma_constraint_flag
Definition: cbs_h265.h:51
struct VAAPIEncodePicture * refs[MAX_PICTURE_REFERENCES]
Definition: vaapi_encode.h:116
uint8_t used_by_curr_pic_s1_flag[HEVC_MAX_REFS]
Definition: cbs_h265.h:234
#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.
int col_width[MAX_TILE_COLS]
Definition: vaapi_encode.h:312
uint8_t max_bytes_per_pic_denom
Definition: cbs_h265.h:171
uint8_t num_ref_idx_l0_active_minus1
Definition: cbs_h265.h:479
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:245
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:179
uint8_t log2_diff_max_min_pcm_luma_coding_block_size
Definition: cbs_h265.h:296
Libavcodec external API header.
#define VAAPI_ENCODE_RC_OPTIONS
Definition: vaapi_encode.h:463
uint8_t entropy_coding_sync_enabled_flag
Definition: cbs_h265.h:377
uint16_t row_height_minus1[HEVC_MAX_TILE_ROWS]
Definition: cbs_h265.h:383
uint8_t weighted_bipred_flag
Definition: cbs_h265.h:373
uint16_t conf_win_top_offset
Definition: cbs_h265.h:265
uint8_t sps_temporal_mvp_enabled_flag
Definition: cbs_h265.h:307
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:118
uint8_t general_level_idc
Definition: cbs_h265.h:60
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:536
int8_t slice_cr_qp_offset
Definition: cbs_h265.h:512
uint32_t vui_num_units_in_tick
Definition: cbs_h265.h:159
uint8_t short_term_ref_pic_set_sps_flag
Definition: cbs_h265.h:461
uint8_t slice_loop_filter_across_slices_enabled_flag
Definition: cbs_h265.h:522
uint8_t luma_log2_weight_denom
Definition: cbs_h265.h:492
uint8_t max_transform_hierarchy_depth_intra
Definition: cbs_h265.h:283
uint8_t mvd_l1_zero_flag
Definition: cbs_h265.h:487
uint8_t * data
Definition: frame.h:222
uint8_t pps_loop_filter_across_slices_enabled_flag
Definition: cbs_h265.h:386
uint8_t weighted_pred_flag
Definition: cbs_h265.h:372
uint8_t sps_temporal_id_nesting_flag
Definition: cbs_h265.h:250
int8_t pps_cb_qp_offset
Definition: cbs_h265.h:368
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
uint8_t vps_max_layer_id
Definition: cbs_h265.h:201
uint16_t conf_win_left_offset
Definition: cbs_h265.h:263
Describe the class of an AVClass context structure.
Definition: log.h:67
uint8_t collocated_ref_idx
Definition: cbs_h265.h:490
uint8_t amp_enabled_flag
Definition: cbs_h265.h:289
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Context structure for coded bitstream operations.
Definition: cbs.h:170
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1164
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1157
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:48
static int vaapi_encode_h265_write_extra_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, int index, int *type, char *data, size_t *data_len)
int ff_cbs_insert_unit_content(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:737
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
uint8_t chroma_format_idc
Definition: cbs_h265.h:256
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:126
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:818
uint8_t general_lower_bit_rate_constraint_flag
Definition: cbs_h265.h:55
offset must point to two consecutive integers
Definition: opt.h:235
uint8_t general_profile_compatibility_flag[32]
Definition: cbs_h265.h:40
uint8_t vps_base_layer_internal_flag
Definition: cbs_h265.h:188
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:303
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:297
uint16_t max_content_light_level
Definition: cbs_sei.h:60
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:347
#define VAAPI_ENCODE_COMMON_OPTIONS
Definition: vaapi_encode.h:445
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:230
uint8_t general_frame_only_constraint_flag
Definition: cbs_h265.h:45
uint8_t level
Definition: svq3.c:204
int8_t pps_cr_qp_offset
Definition: cbs_h265.h:369
static const VAAPIEncodeProfile vaapi_encode_h265_profiles[]
uint8_t slice_pic_parameter_set_id
Definition: cbs_h265.h:448
uint8_t vui_poc_proportional_to_timing_flag
Definition: cbs_h265.h:161
uint8_t general_progressive_source_flag
Definition: cbs_h265.h:42
SEIRawMasteringDisplayColourVolume sei_mastering_display
uint8_t max_transform_hierarchy_depth_inter
Definition: cbs_h265.h:282
static av_cold int vaapi_encode_h265_configure(AVCodecContext *avctx)
VAAPIEncodeContext common
common internal api header.
common internal and external API header
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
uint8_t pps_scaling_list_data_present_flag
Definition: cbs_h265.h:393
uint8_t cabac_init_flag
Definition: cbs_h265.h:488
uint8_t num_tile_rows_minus1
Definition: cbs_h265.h:380
uint8_t pcm_enabled_flag
Definition: cbs_h265.h:292
uint8_t slice_sao_luma_flag
Definition: cbs_h265.h:475
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
uint8_t num_tile_columns_minus1
Definition: cbs_h265.h:379
int den
Denominator.
Definition: rational.h:60
uint16_t delta_poc_s0_minus1[HEVC_MAX_REFS]
Definition: cbs_h265.h:231
uint8_t log2_diff_max_min_luma_coding_block_size
Definition: cbs_h265.h:279
CodedBitstreamFragment current_access_unit
uint8_t slice_sao_chroma_flag
Definition: cbs_h265.h:476
#define FF_PROFILE_HEVC_REXT
Definition: avcodec.h:1949
void * priv_data
Definition: avcodec.h:563
uint8_t vps_max_num_reorder_pics[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:198
H265RawSliceHeader header
Definition: cbs_h265.h:534
uint32_t vps_time_scale
Definition: cbs_h265.h:207
uint8_t num_short_term_ref_pic_sets
Definition: cbs_h265.h:299
void * codec_slice_params
Definition: vaapi_encode.h:67
uint16_t column_width_minus1[HEVC_MAX_TILE_COLUMNS]
Definition: cbs_h265.h:382
uint8_t log2_parallel_merge_level_minus2
Definition: cbs_h265.h:397
uint8_t vps_temporal_id_nesting_flag
Definition: cbs_h265.h:192
#define lrint
Definition: tablegen.h:53
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:170
uint8_t aspect_ratio_idc
Definition: cbs_h265.h:129
unsigned int desired_packed_headers
Definition: vaapi_encode.h:201
#define LEVEL(name, value)
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:444
uint8_t num_long_term_sps
Definition: cbs_h265.h:465
uint8_t general_profile_space
Definition: cbs_h265.h:36
uint8_t sps_max_dec_pic_buffering_minus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:274
#define FFSWAP(type, a, b)
Definition: common.h:108
int8_t init_qp_minus26
Definition: cbs_h265.h:361
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
uint32_t vps_num_ticks_poc_diff_one_minus1
Definition: cbs_h265.h:209
int depth
Number of bits in the component.
Definition: pixdesc.h:58
uint8_t separate_colour_plane_flag
Definition: cbs_h265.h:257
VABufferID output_buffer
Definition: vaapi_encode.h:100
uint8_t strong_intra_smoothing_enabled_flag
Definition: cbs_h265.h:308
uint8_t colour_description_present_flag
Definition: cbs_h265.h:139
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:112
uint8_t log2_diff_max_min_luma_transform_block_size
Definition: cbs_h265.h:281
uint8_t long_term_ref_pics_present_flag
Definition: cbs_h265.h:302
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators...
Definition: codec.h:52
uint8_t num_ref_idx_active_override_flag
Definition: cbs_h265.h:478
uint8_t layer_id_included_flag[HEVC_MAX_LAYER_SETS][HEVC_MAX_LAYERS]
Definition: cbs_h265.h:203
for(j=16;j >0;--j)
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
int i
Definition: input.c:407
uint8_t nal_unit_type
Definition: cbs_h265.h:30
const AVCodecHWConfigInternal *const ff_vaapi_encode_hw_configs[]
Definition: vaapi_encode.c:32
uint8_t num_ref_idx_l1_default_active_minus1
Definition: cbs_h265.h:359
uint8_t first_slice_segment_in_pic_flag
Definition: cbs_h265.h:446
uint8_t cu_qp_delta_enabled_flag
Definition: cbs_h265.h:365
bitstream writer API