FFmpeg  4.3.7
vaapi_encode_h264.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_h264.h>
23 
24 #include "libavutil/avassert.h"
25 #include "libavutil/common.h"
26 #include "libavutil/internal.h"
27 #include "libavutil/opt.h"
28 
29 #include "avcodec.h"
30 #include "cbs.h"
31 #include "cbs_h264.h"
32 #include "h264.h"
33 #include "h264_levels.h"
34 #include "h264_sei.h"
35 #include "internal.h"
36 #include "vaapi_encode.h"
37 
38 enum {
39  SEI_TIMING = 0x01,
42 };
43 
44 // Random (version 4) ISO 11578 UUID.
46  0x59, 0x94, 0x8b, 0x28, 0x11, 0xec, 0x45, 0xaf,
47  0x96, 0x75, 0x19, 0xd4, 0x1f, 0xea, 0xa9, 0x4d,
48 };
49 
50 typedef struct VAAPIEncodeH264Picture {
51  int frame_num;
53 
54  int64_t last_idr_frame;
55  uint16_t idr_pic_id;
56 
59 
60  int cpb_delay;
61  int dpb_delay;
63 
64 typedef struct VAAPIEncodeH264Context {
66 
67  // User options.
68  int qp;
69  int quality;
70  int coder;
71  int aud;
72  int sei;
73  int profile;
74  int level;
75 
76  // Derived settings.
77  int mb_width;
78  int mb_height;
79 
83 
85 
86  // Writer structures.
89 
95 
101 
106 
107 
109  char *data, size_t *data_len,
111 {
112  VAAPIEncodeH264Context *priv = avctx->priv_data;
113  int err;
114 
115  err = ff_cbs_write_fragment_data(priv->cbc, au);
116  if (err < 0) {
117  av_log(avctx, AV_LOG_ERROR, "Failed to write packed header.\n");
118  return err;
119  }
120 
121  if (*data_len < 8 * au->data_size - au->data_bit_padding) {
122  av_log(avctx, AV_LOG_ERROR, "Access unit too large: "
123  "%zu < %zu.\n", *data_len,
124  8 * au->data_size - au->data_bit_padding);
125  return AVERROR(ENOSPC);
126  }
127 
128  memcpy(data, au->data, au->data_size);
129  *data_len = 8 * au->data_size - au->data_bit_padding;
130 
131  return 0;
132 }
133 
136  void *nal_unit)
137 {
138  VAAPIEncodeH264Context *priv = avctx->priv_data;
139  H264RawNALUnitHeader *header = nal_unit;
140  int err;
141 
142  err = ff_cbs_insert_unit_content(priv->cbc, au, -1,
143  header->nal_unit_type, nal_unit, NULL);
144  if (err < 0) {
145  av_log(avctx, AV_LOG_ERROR, "Failed to add NAL unit: "
146  "type = %d.\n", header->nal_unit_type);
147  return err;
148  }
149 
150  return 0;
151 }
152 
154  char *data, size_t *data_len)
155 {
156  VAAPIEncodeH264Context *priv = avctx->priv_data;
158  int err;
159 
160  if (priv->aud_needed) {
161  err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_aud);
162  if (err < 0)
163  goto fail;
164  priv->aud_needed = 0;
165  }
166 
167  err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_sps);
168  if (err < 0)
169  goto fail;
170 
171  err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_pps);
172  if (err < 0)
173  goto fail;
174 
175  err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au);
176 fail:
177  ff_cbs_fragment_reset(priv->cbc, au);
178  return err;
179 }
180 
182  VAAPIEncodePicture *pic,
183  VAAPIEncodeSlice *slice,
184  char *data, size_t *data_len)
185 {
186  VAAPIEncodeH264Context *priv = avctx->priv_data;
188  int err;
189 
190  if (priv->aud_needed) {
191  err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_aud);
192  if (err < 0)
193  goto fail;
194  priv->aud_needed = 0;
195  }
196 
197  err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_slice);
198  if (err < 0)
199  goto fail;
200 
201  err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au);
202 fail:
203  ff_cbs_fragment_reset(priv->cbc, au);
204  return err;
205 }
206 
208  VAAPIEncodePicture *pic,
209  int index, int *type,
210  char *data, size_t *data_len)
211 {
212  VAAPIEncodeH264Context *priv = avctx->priv_data;
214  int err, i;
215 
216  if (priv->sei_needed) {
217  H264RawSEI *sei = &priv->raw_sei;
218 
219  if (priv->aud_needed) {
220  err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_aud);
221  if (err < 0)
222  goto fail;
223  priv->aud_needed = 0;
224  }
225 
226  *sei = (H264RawSEI) {
227  .nal_unit_header = {
229  },
230  };
231 
232  i = 0;
233 
234  if (priv->sei_needed & SEI_IDENTIFIER) {
237  ++i;
238  }
239  if (priv->sei_needed & SEI_TIMING) {
240  if (pic->type == PICTURE_TYPE_IDR) {
243  ++i;
244  }
246  sei->payload[i].payload.pic_timing = priv->sei_pic_timing;
247  ++i;
248  }
249  if (priv->sei_needed & SEI_RECOVERY_POINT) {
252  ++i;
253  }
254 
255  sei->payload_count = i;
256  av_assert0(sei->payload_count > 0);
257 
258  err = vaapi_encode_h264_add_nal(avctx, au, sei);
259  if (err < 0)
260  goto fail;
261  priv->sei_needed = 0;
262 
263  err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au);
264  if (err < 0)
265  goto fail;
266 
267  ff_cbs_fragment_reset(priv->cbc, au);
268 
269  *type = VAEncPackedHeaderRawData;
270  return 0;
271 
272 #if !CONFIG_VAAPI_1
273  } else if (priv->sei_cbr_workaround_needed) {
274  // Insert a zero-length header using the old SEI type. This is
275  // required to avoid triggering broken behaviour on Intel platforms
276  // in CBR mode where an invalid SEI message is generated by the
277  // driver and inserted into the stream.
278  *data_len = 0;
279  *type = VAEncPackedHeaderH264_SEI;
280  priv->sei_cbr_workaround_needed = 0;
281  return 0;
282 #endif
283 
284  } else {
285  return AVERROR_EOF;
286  }
287 
288 fail:
289  ff_cbs_fragment_reset(priv->cbc, au);
290  return err;
291 }
292 
294 {
295  VAAPIEncodeContext *ctx = avctx->priv_data;
296  VAAPIEncodeH264Context *priv = avctx->priv_data;
297  H264RawSPS *sps = &priv->raw_sps;
298  H264RawPPS *pps = &priv->raw_pps;
299  VAEncSequenceParameterBufferH264 *vseq = ctx->codec_sequence_params;
300  VAEncPictureParameterBufferH264 *vpic = ctx->codec_picture_params;
301 
302  memset(sps, 0, sizeof(*sps));
303  memset(pps, 0, sizeof(*pps));
304 
305  sps->nal_unit_header.nal_ref_idc = 3;
307 
308  sps->profile_idc = avctx->profile & 0xff;
309 
311  avctx->profile == FF_PROFILE_H264_MAIN)
312  sps->constraint_set1_flag = 1;
313 
314  if (avctx->profile == FF_PROFILE_H264_HIGH)
315  sps->constraint_set3_flag = ctx->gop_size == 1;
316 
317  if (avctx->profile == FF_PROFILE_H264_MAIN ||
318  avctx->profile == FF_PROFILE_H264_HIGH) {
319  sps->constraint_set4_flag = 1;
320  sps->constraint_set5_flag = ctx->b_per_p == 0;
321  }
322 
323  if (ctx->gop_size == 1)
324  priv->dpb_frames = 0;
325  else
326  priv->dpb_frames = 1 + ctx->max_b_depth;
327 
328  if (avctx->level != FF_LEVEL_UNKNOWN) {
329  sps->level_idc = avctx->level;
330  } else {
331  const H264LevelDescriptor *level;
332  int framerate;
333 
334  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
335  framerate = avctx->framerate.num / avctx->framerate.den;
336  else
337  framerate = 0;
338 
339  level = ff_h264_guess_level(sps->profile_idc,
340  avctx->bit_rate,
341  framerate,
342  priv->mb_width * 16,
343  priv->mb_height * 16,
344  priv->dpb_frames);
345  if (level) {
346  av_log(avctx, AV_LOG_VERBOSE, "Using level %s.\n", level->name);
347  if (level->constraint_set3_flag)
348  sps->constraint_set3_flag = 1;
349  sps->level_idc = level->level_idc;
350  } else {
351  av_log(avctx, AV_LOG_WARNING, "Stream will not conform "
352  "to any level: using level 6.2.\n");
353  sps->level_idc = 62;
354  }
355  }
356 
357  sps->seq_parameter_set_id = 0;
358  sps->chroma_format_idc = 1;
359 
360  sps->log2_max_frame_num_minus4 = 4;
361  sps->pic_order_cnt_type = 0;
363 
364  sps->max_num_ref_frames = priv->dpb_frames;
365 
366  sps->pic_width_in_mbs_minus1 = priv->mb_width - 1;
367  sps->pic_height_in_map_units_minus1 = priv->mb_height - 1;
368 
369  sps->frame_mbs_only_flag = 1;
370  sps->direct_8x8_inference_flag = 1;
371 
372  if (avctx->width != 16 * priv->mb_width ||
373  avctx->height != 16 * priv->mb_height) {
374  sps->frame_cropping_flag = 1;
375 
376  sps->frame_crop_left_offset = 0;
378  (16 * priv->mb_width - avctx->width) / 2;
379  sps->frame_crop_top_offset = 0;
381  (16 * priv->mb_height - avctx->height) / 2;
382  } else {
383  sps->frame_cropping_flag = 0;
384  }
385 
387 
388  if (avctx->sample_aspect_ratio.num != 0 &&
389  avctx->sample_aspect_ratio.den != 0) {
390  static const AVRational sar_idc[] = {
391  { 0, 0 },
392  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
393  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
394  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
395  { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
396  };
397  int num, den, i;
398  av_reduce(&num, &den, avctx->sample_aspect_ratio.num,
399  avctx->sample_aspect_ratio.den, 65535);
400  for (i = 0; i < FF_ARRAY_ELEMS(sar_idc); i++) {
401  if (num == sar_idc[i].num &&
402  den == sar_idc[i].den) {
403  sps->vui.aspect_ratio_idc = i;
404  break;
405  }
406  }
407  if (i >= FF_ARRAY_ELEMS(sar_idc)) {
408  sps->vui.aspect_ratio_idc = 255;
409  sps->vui.sar_width = num;
410  sps->vui.sar_height = den;
411  }
413  }
414 
415  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED ||
417  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
418  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
420  sps->vui.video_format = 5; // Unspecified.
422  avctx->color_range == AVCOL_RANGE_JPEG;
423 
424  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
425  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
426  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
428  sps->vui.colour_primaries = avctx->color_primaries;
429  sps->vui.transfer_characteristics = avctx->color_trc;
430  sps->vui.matrix_coefficients = avctx->colorspace;
431  }
432  } else {
433  sps->vui.video_format = 5;
434  sps->vui.video_full_range_flag = 0;
435  sps->vui.colour_primaries = avctx->color_primaries;
436  sps->vui.transfer_characteristics = avctx->color_trc;
437  sps->vui.matrix_coefficients = avctx->colorspace;
438  }
439 
444  avctx->chroma_sample_location - 1;
445  }
446 
447  sps->vui.timing_info_present_flag = 1;
448  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
449  sps->vui.num_units_in_tick = avctx->framerate.den;
450  sps->vui.time_scale = 2 * avctx->framerate.num;
451  sps->vui.fixed_frame_rate_flag = 1;
452  } else {
453  sps->vui.num_units_in_tick = avctx->time_base.num;
454  sps->vui.time_scale = 2 * avctx->time_base.den;
455  sps->vui.fixed_frame_rate_flag = 0;
456  }
457 
458  if (priv->sei & SEI_TIMING) {
459  H264RawHRD *hrd = &sps->vui.nal_hrd_parameters;
461 
463 
464  hrd->cpb_cnt_minus1 = 0;
465 
466  // Try to scale these to a sensible range so that the
467  // golomb encode of the value is not overlong.
468  hrd->bit_rate_scale =
469  av_clip_uintp2(av_log2(ctx->va_bit_rate) - 15 - 6, 4);
470  hrd->bit_rate_value_minus1[0] =
471  (ctx->va_bit_rate >> hrd->bit_rate_scale + 6) - 1;
472 
473  hrd->cpb_size_scale =
474  av_clip_uintp2(av_log2(ctx->hrd_params.buffer_size) - 15 - 4, 4);
475  hrd->cpb_size_value_minus1[0] =
476  (ctx->hrd_params.buffer_size >> hrd->cpb_size_scale + 4) - 1;
477 
478  // CBR mode as defined for the HRD cannot be achieved without filler
479  // data, so this flag cannot be set even with VAAPI CBR modes.
480  hrd->cbr_flag[0] = 0;
481 
485  hrd->time_offset_length = 0;
486 
488 
489  // This calculation can easily overflow 32 bits.
490  bp->nal.initial_cpb_removal_delay[0] = 90000 *
491  (uint64_t)ctx->hrd_params.initial_buffer_fullness /
492  ctx->hrd_params.buffer_size;
494  } else {
497  }
498 
504  sps->vui.max_dec_frame_buffering = ctx->max_b_depth + 1;
505 
506  pps->nal_unit_header.nal_ref_idc = 3;
508 
509  pps->pic_parameter_set_id = 0;
510  pps->seq_parameter_set_id = 0;
511 
516  if (!priv->coder && pps->entropy_coding_mode_flag)
517  pps->entropy_coding_mode_flag = 0;
518 
521 
522  pps->pic_init_qp_minus26 = priv->fixed_qp_idr - 26;
523 
527  pps->more_rbsp_data = 0;
528  } else {
529  pps->more_rbsp_data = 1;
530 
531  pps->transform_8x8_mode_flag = 1;
532  }
533 
534  *vseq = (VAEncSequenceParameterBufferH264) {
535  .seq_parameter_set_id = sps->seq_parameter_set_id,
536  .level_idc = sps->level_idc,
537  .intra_period = ctx->gop_size,
538  .intra_idr_period = ctx->gop_size,
539  .ip_period = ctx->b_per_p + 1,
540 
541  .bits_per_second = ctx->va_bit_rate,
542  .max_num_ref_frames = sps->max_num_ref_frames,
543  .picture_width_in_mbs = sps->pic_width_in_mbs_minus1 + 1,
544  .picture_height_in_mbs = sps->pic_height_in_map_units_minus1 + 1,
545 
546  .seq_fields.bits = {
547  .chroma_format_idc = sps->chroma_format_idc,
548  .frame_mbs_only_flag = sps->frame_mbs_only_flag,
549  .mb_adaptive_frame_field_flag = sps->mb_adaptive_frame_field_flag,
550  .seq_scaling_matrix_present_flag = sps->seq_scaling_matrix_present_flag,
551  .direct_8x8_inference_flag = sps->direct_8x8_inference_flag,
552  .log2_max_frame_num_minus4 = sps->log2_max_frame_num_minus4,
553  .pic_order_cnt_type = sps->pic_order_cnt_type,
554  .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_pic_order_cnt_lsb_minus4,
555  .delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag,
556  },
557 
558  .bit_depth_luma_minus8 = sps->bit_depth_luma_minus8,
559  .bit_depth_chroma_minus8 = sps->bit_depth_chroma_minus8,
560 
561  .frame_cropping_flag = sps->frame_cropping_flag,
562  .frame_crop_left_offset = sps->frame_crop_left_offset,
563  .frame_crop_right_offset = sps->frame_crop_right_offset,
564  .frame_crop_top_offset = sps->frame_crop_top_offset,
565  .frame_crop_bottom_offset = sps->frame_crop_bottom_offset,
566 
567  .vui_parameters_present_flag = sps->vui_parameters_present_flag,
568 
569  .vui_fields.bits = {
570  .aspect_ratio_info_present_flag = sps->vui.aspect_ratio_info_present_flag,
571  .timing_info_present_flag = sps->vui.timing_info_present_flag,
572  .bitstream_restriction_flag = sps->vui.bitstream_restriction_flag,
573  .log2_max_mv_length_horizontal = sps->vui.log2_max_mv_length_horizontal,
574  .log2_max_mv_length_vertical = sps->vui.log2_max_mv_length_vertical,
575  },
576 
577  .aspect_ratio_idc = sps->vui.aspect_ratio_idc,
578  .sar_width = sps->vui.sar_width,
579  .sar_height = sps->vui.sar_height,
580  .num_units_in_tick = sps->vui.num_units_in_tick,
581  .time_scale = sps->vui.time_scale,
582  };
583 
584  *vpic = (VAEncPictureParameterBufferH264) {
585  .CurrPic = {
586  .picture_id = VA_INVALID_ID,
587  .flags = VA_PICTURE_H264_INVALID,
588  },
589 
590  .coded_buf = VA_INVALID_ID,
591 
592  .pic_parameter_set_id = pps->pic_parameter_set_id,
593  .seq_parameter_set_id = pps->seq_parameter_set_id,
594 
595  .pic_init_qp = pps->pic_init_qp_minus26 + 26,
596  .num_ref_idx_l0_active_minus1 = pps->num_ref_idx_l0_default_active_minus1,
597  .num_ref_idx_l1_active_minus1 = pps->num_ref_idx_l1_default_active_minus1,
598 
599  .chroma_qp_index_offset = pps->chroma_qp_index_offset,
600  .second_chroma_qp_index_offset = pps->second_chroma_qp_index_offset,
601 
602  .pic_fields.bits = {
603  .entropy_coding_mode_flag = pps->entropy_coding_mode_flag,
604  .weighted_pred_flag = pps->weighted_pred_flag,
605  .weighted_bipred_idc = pps->weighted_bipred_idc,
606  .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
607  .transform_8x8_mode_flag = pps->transform_8x8_mode_flag,
608  .deblocking_filter_control_present_flag =
610  .redundant_pic_cnt_present_flag = pps->redundant_pic_cnt_present_flag,
611  .pic_order_present_flag =
613  .pic_scaling_matrix_present_flag = pps->pic_scaling_matrix_present_flag,
614  },
615  };
616 
617  return 0;
618 }
619 
621  VAAPIEncodePicture *pic)
622 {
623  VAAPIEncodeContext *ctx = avctx->priv_data;
624  VAAPIEncodeH264Context *priv = avctx->priv_data;
625  VAAPIEncodeH264Picture *hpic = pic->priv_data;
626  VAAPIEncodePicture *prev = pic->prev;
627  VAAPIEncodeH264Picture *hprev = prev ? prev->priv_data : NULL;
628  VAEncPictureParameterBufferH264 *vpic = pic->codec_picture_params;
629  int i;
630 
631  if (pic->type == PICTURE_TYPE_IDR) {
632  av_assert0(pic->display_order == pic->encode_order);
633 
634  hpic->frame_num = 0;
635  hpic->last_idr_frame = pic->display_order;
636  hpic->idr_pic_id = hprev ? hprev->idr_pic_id + 1 : 0;
637 
638  hpic->primary_pic_type = 0;
639  hpic->slice_type = 7;
640  } else {
641  av_assert0(prev);
642 
643  hpic->frame_num = hprev->frame_num + prev->is_reference;
644 
645  hpic->last_idr_frame = hprev->last_idr_frame;
646  hpic->idr_pic_id = hprev->idr_pic_id;
647 
648  if (pic->type == PICTURE_TYPE_I) {
649  hpic->slice_type = 7;
650  hpic->primary_pic_type = 0;
651  } else if (pic->type == PICTURE_TYPE_P) {
652  hpic->slice_type = 5;
653  hpic->primary_pic_type = 1;
654  } else {
655  hpic->slice_type = 6;
656  hpic->primary_pic_type = 2;
657  }
658  }
659  hpic->pic_order_cnt = pic->display_order - hpic->last_idr_frame;
660  hpic->dpb_delay = pic->display_order - pic->encode_order + ctx->max_b_depth;
661  hpic->cpb_delay = pic->encode_order - hpic->last_idr_frame;
662 
663  if (priv->aud) {
664  priv->aud_needed = 1;
665  priv->raw_aud = (H264RawAUD) {
666  .nal_unit_header = {
668  },
669  .primary_pic_type = hpic->primary_pic_type,
670  };
671  } else {
672  priv->aud_needed = 0;
673  }
674 
675  priv->sei_needed = 0;
676 
677  if (priv->sei & SEI_IDENTIFIER && pic->encode_order == 0)
678  priv->sei_needed |= SEI_IDENTIFIER;
679 #if !CONFIG_VAAPI_1
680  if (ctx->va_rc_mode == VA_RC_CBR)
681  priv->sei_cbr_workaround_needed = 1;
682 #endif
683 
684  if (priv->sei & SEI_TIMING) {
686  .cpb_removal_delay = 2 * hpic->cpb_delay,
687  .dpb_output_delay = 2 * hpic->dpb_delay,
688  };
689 
690  priv->sei_needed |= SEI_TIMING;
691  }
692 
693  if (priv->sei & SEI_RECOVERY_POINT && pic->type == PICTURE_TYPE_I) {
695  .recovery_frame_cnt = 0,
696  .exact_match_flag = 1,
697  .broken_link_flag = ctx->b_per_p > 0,
698  };
699 
701  }
702 
703  vpic->CurrPic = (VAPictureH264) {
704  .picture_id = pic->recon_surface,
705  .frame_idx = hpic->frame_num,
706  .flags = 0,
707  .TopFieldOrderCnt = hpic->pic_order_cnt,
708  .BottomFieldOrderCnt = hpic->pic_order_cnt,
709  };
710 
711  for (i = 0; i < pic->nb_refs; i++) {
712  VAAPIEncodePicture *ref = pic->refs[i];
714 
715  av_assert0(ref && ref->encode_order < pic->encode_order);
716  href = ref->priv_data;
717 
718  vpic->ReferenceFrames[i] = (VAPictureH264) {
719  .picture_id = ref->recon_surface,
720  .frame_idx = href->frame_num,
721  .flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE,
722  .TopFieldOrderCnt = href->pic_order_cnt,
723  .BottomFieldOrderCnt = href->pic_order_cnt,
724  };
725  }
726  for (; i < FF_ARRAY_ELEMS(vpic->ReferenceFrames); i++) {
727  vpic->ReferenceFrames[i] = (VAPictureH264) {
728  .picture_id = VA_INVALID_ID,
729  .flags = VA_PICTURE_H264_INVALID,
730  };
731  }
732 
733  vpic->coded_buf = pic->output_buffer;
734 
735  vpic->frame_num = hpic->frame_num;
736 
737  vpic->pic_fields.bits.idr_pic_flag = (pic->type == PICTURE_TYPE_IDR);
738  vpic->pic_fields.bits.reference_pic_flag = (pic->type != PICTURE_TYPE_B);
739 
740  return 0;
741 }
742 
744  VAAPIEncodePicture *pic,
745  VAAPIEncodePicture **rpl0,
746  VAAPIEncodePicture **rpl1,
747  int *rpl_size)
748 {
749  VAAPIEncodePicture *prev;
750  VAAPIEncodeH264Picture *hp, *hn, *hc;
751  int i, j, n = 0;
752 
753  prev = pic->prev;
754  av_assert0(prev);
755  hp = pic->priv_data;
756 
757  for (i = 0; i < pic->prev->nb_dpb_pics; i++) {
758  hn = prev->dpb[i]->priv_data;
759  av_assert0(hn->frame_num < hp->frame_num);
760 
761  if (pic->type == PICTURE_TYPE_P) {
762  for (j = n; j > 0; j--) {
763  hc = rpl0[j - 1]->priv_data;
764  av_assert0(hc->frame_num != hn->frame_num);
765  if (hc->frame_num > hn->frame_num)
766  break;
767  rpl0[j] = rpl0[j - 1];
768  }
769  rpl0[j] = prev->dpb[i];
770 
771  } else if (pic->type == PICTURE_TYPE_B) {
772  for (j = n; j > 0; j--) {
773  hc = rpl0[j - 1]->priv_data;
775  if (hc->pic_order_cnt < hp->pic_order_cnt) {
776  if (hn->pic_order_cnt > hp->pic_order_cnt ||
777  hn->pic_order_cnt < hc->pic_order_cnt)
778  break;
779  } else {
780  if (hn->pic_order_cnt > hc->pic_order_cnt)
781  break;
782  }
783  rpl0[j] = rpl0[j - 1];
784  }
785  rpl0[j] = prev->dpb[i];
786 
787  for (j = n; j > 0; j--) {
788  hc = rpl1[j - 1]->priv_data;
790  if (hc->pic_order_cnt > hp->pic_order_cnt) {
791  if (hn->pic_order_cnt < hp->pic_order_cnt ||
792  hn->pic_order_cnt > hc->pic_order_cnt)
793  break;
794  } else {
795  if (hn->pic_order_cnt < hc->pic_order_cnt)
796  break;
797  }
798  rpl1[j] = rpl1[j - 1];
799  }
800  rpl1[j] = prev->dpb[i];
801  }
802 
803  ++n;
804  }
805 
806  if (pic->type == PICTURE_TYPE_B) {
807  for (i = 0; i < n; i++) {
808  if (rpl0[i] != rpl1[i])
809  break;
810  }
811  if (i == n)
812  FFSWAP(VAAPIEncodePicture*, rpl1[0], rpl1[1]);
813  }
814 
815  if (pic->type == PICTURE_TYPE_P ||
816  pic->type == PICTURE_TYPE_B) {
817  av_log(avctx, AV_LOG_DEBUG, "Default RefPicList0 for fn=%d/poc=%d:",
818  hp->frame_num, hp->pic_order_cnt);
819  for (i = 0; i < n; i++) {
820  hn = rpl0[i]->priv_data;
821  av_log(avctx, AV_LOG_DEBUG, " fn=%d/poc=%d",
822  hn->frame_num, hn->pic_order_cnt);
823  }
824  av_log(avctx, AV_LOG_DEBUG, "\n");
825  }
826  if (pic->type == PICTURE_TYPE_B) {
827  av_log(avctx, AV_LOG_DEBUG, "Default RefPicList1 for fn=%d/poc=%d:",
828  hp->frame_num, hp->pic_order_cnt);
829  for (i = 0; i < n; i++) {
830  hn = rpl1[i]->priv_data;
831  av_log(avctx, AV_LOG_DEBUG, " fn=%d/poc=%d",
832  hn->frame_num, hn->pic_order_cnt);
833  }
834  av_log(avctx, AV_LOG_DEBUG, "\n");
835  }
836 
837  *rpl_size = n;
838 }
839 
841  VAAPIEncodePicture *pic,
842  VAAPIEncodeSlice *slice)
843 {
844  VAAPIEncodeH264Context *priv = avctx->priv_data;
845  VAAPIEncodeH264Picture *hpic = pic->priv_data;
846  VAAPIEncodePicture *prev = pic->prev;
847  H264RawSPS *sps = &priv->raw_sps;
848  H264RawPPS *pps = &priv->raw_pps;
849  H264RawSliceHeader *sh = &priv->raw_slice.header;
850  VAEncPictureParameterBufferH264 *vpic = pic->codec_picture_params;
851  VAEncSliceParameterBufferH264 *vslice = slice->codec_slice_params;
852  int i, j;
853 
854  if (pic->type == PICTURE_TYPE_IDR) {
857  } else {
860  }
861 
862  sh->first_mb_in_slice = slice->block_start;
863  sh->slice_type = hpic->slice_type;
864 
866 
867  sh->frame_num = hpic->frame_num &
868  ((1 << (4 + sps->log2_max_frame_num_minus4)) - 1);
869  sh->idr_pic_id = hpic->idr_pic_id;
870  sh->pic_order_cnt_lsb = hpic->pic_order_cnt &
871  ((1 << (4 + sps->log2_max_pic_order_cnt_lsb_minus4)) - 1);
872 
874 
875  if (pic->type == PICTURE_TYPE_B)
876  sh->slice_qp_delta = priv->fixed_qp_b - (pps->pic_init_qp_minus26 + 26);
877  else if (pic->type == PICTURE_TYPE_P)
878  sh->slice_qp_delta = priv->fixed_qp_p - (pps->pic_init_qp_minus26 + 26);
879  else
880  sh->slice_qp_delta = priv->fixed_qp_idr - (pps->pic_init_qp_minus26 + 26);
881 
882  if (pic->is_reference && pic->type != PICTURE_TYPE_IDR) {
883  VAAPIEncodePicture *discard_list[MAX_DPB_SIZE];
884  int discard = 0, keep = 0;
885 
886  // Discard everything which is in the DPB of the previous frame but
887  // not in the DPB of this one.
888  for (i = 0; i < prev->nb_dpb_pics; i++) {
889  for (j = 0; j < pic->nb_dpb_pics; j++) {
890  if (prev->dpb[i] == pic->dpb[j])
891  break;
892  }
893  if (j == pic->nb_dpb_pics) {
894  discard_list[discard] = prev->dpb[i];
895  ++discard;
896  } else {
897  ++keep;
898  }
899  }
900  av_assert0(keep <= priv->dpb_frames);
901 
902  if (discard == 0) {
904  } else {
906  for (i = 0; i < discard; i++) {
907  VAAPIEncodeH264Picture *old = discard_list[i]->priv_data;
908  av_assert0(old->frame_num < hpic->frame_num);
911  hpic->frame_num - old->frame_num - 1;
912  }
914  }
915  }
916 
917  // If the intended references are not the first entries of RefPicListN
918  // by default, use ref-pic-list-modification to move them there.
919  if (pic->type == PICTURE_TYPE_P || pic->type == PICTURE_TYPE_B) {
920  VAAPIEncodePicture *def_l0[MAX_DPB_SIZE], *def_l1[MAX_DPB_SIZE];
922  int n;
923 
925  def_l0, def_l1, &n);
926 
927  if (pic->type == PICTURE_TYPE_P) {
928  int need_rplm = 0;
929  for (i = 0; i < pic->nb_refs; i++) {
930  av_assert0(pic->refs[i]);
931  if (pic->refs[i] != def_l0[i])
932  need_rplm = 1;
933  }
934 
935  sh->ref_pic_list_modification_flag_l0 = need_rplm;
936  if (need_rplm) {
937  int pic_num = hpic->frame_num;
938  for (i = 0; i < pic->nb_refs; i++) {
939  href = pic->refs[i]->priv_data;
940  av_assert0(href->frame_num != pic_num);
941  if (href->frame_num < pic_num) {
944  pic_num - href->frame_num - 1;
945  } else {
948  href->frame_num - pic_num - 1;
949  }
950  pic_num = href->frame_num;
951  }
953  }
954 
955  } else {
956  int need_rplm_l0 = 0, need_rplm_l1 = 0;
957  int n0 = 0, n1 = 0;
958  for (i = 0; i < pic->nb_refs; i++) {
959  av_assert0(pic->refs[i]);
960  href = pic->refs[i]->priv_data;
961  av_assert0(href->pic_order_cnt != hpic->pic_order_cnt);
962  if (href->pic_order_cnt < hpic->pic_order_cnt) {
963  if (pic->refs[i] != def_l0[n0])
964  need_rplm_l0 = 1;
965  ++n0;
966  } else {
967  if (pic->refs[i] != def_l1[n1])
968  need_rplm_l1 = 1;
969  ++n1;
970  }
971  }
972 
973  sh->ref_pic_list_modification_flag_l0 = need_rplm_l0;
974  if (need_rplm_l0) {
975  int pic_num = hpic->frame_num;
976  for (i = j = 0; i < pic->nb_refs; i++) {
977  href = pic->refs[i]->priv_data;
978  if (href->pic_order_cnt > hpic->pic_order_cnt)
979  continue;
980  av_assert0(href->frame_num != pic_num);
981  if (href->frame_num < pic_num) {
984  pic_num - href->frame_num - 1;
985  } else {
988  href->frame_num - pic_num - 1;
989  }
990  pic_num = href->frame_num;
991  ++j;
992  }
993  av_assert0(j == n0);
995  }
996 
997  sh->ref_pic_list_modification_flag_l1 = need_rplm_l1;
998  if (need_rplm_l1) {
999  int pic_num = hpic->frame_num;
1000  for (i = j = 0; i < pic->nb_refs; i++) {
1001  href = pic->refs[i]->priv_data;
1002  if (href->pic_order_cnt < hpic->pic_order_cnt)
1003  continue;
1004  av_assert0(href->frame_num != pic_num);
1005  if (href->frame_num < pic_num) {
1008  pic_num - href->frame_num - 1;
1009  } else {
1012  href->frame_num - pic_num - 1;
1013  }
1014  pic_num = href->frame_num;
1015  ++j;
1016  }
1017  av_assert0(j == n1);
1019  }
1020  }
1021  }
1022 
1023  vslice->macroblock_address = slice->block_start;
1024  vslice->num_macroblocks = slice->block_size;
1025 
1026  vslice->macroblock_info = VA_INVALID_ID;
1027 
1028  vslice->slice_type = sh->slice_type % 5;
1029  vslice->pic_parameter_set_id = sh->pic_parameter_set_id;
1030  vslice->idr_pic_id = sh->idr_pic_id;
1031 
1032  vslice->pic_order_cnt_lsb = sh->pic_order_cnt_lsb;
1033 
1034  vslice->direct_spatial_mv_pred_flag = sh->direct_spatial_mv_pred_flag;
1035 
1036  for (i = 0; i < FF_ARRAY_ELEMS(vslice->RefPicList0); i++) {
1037  vslice->RefPicList0[i].picture_id = VA_INVALID_ID;
1038  vslice->RefPicList0[i].flags = VA_PICTURE_H264_INVALID;
1039  vslice->RefPicList1[i].picture_id = VA_INVALID_ID;
1040  vslice->RefPicList1[i].flags = VA_PICTURE_H264_INVALID;
1041  }
1042 
1043  av_assert0(pic->nb_refs <= 2);
1044  if (pic->nb_refs >= 1) {
1045  // Backward reference for P- or B-frame.
1046  av_assert0(pic->type == PICTURE_TYPE_P ||
1047  pic->type == PICTURE_TYPE_B);
1048  vslice->RefPicList0[0] = vpic->ReferenceFrames[0];
1049  }
1050  if (pic->nb_refs >= 2) {
1051  // Forward reference for B-frame.
1052  av_assert0(pic->type == PICTURE_TYPE_B);
1053  vslice->RefPicList1[0] = vpic->ReferenceFrames[1];
1054  }
1055 
1056  vslice->slice_qp_delta = sh->slice_qp_delta;
1057 
1058  return 0;
1059 }
1060 
1062 {
1063  VAAPIEncodeContext *ctx = avctx->priv_data;
1064  VAAPIEncodeH264Context *priv = avctx->priv_data;
1065  int err;
1066 
1067  err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_H264, avctx);
1068  if (err < 0)
1069  return err;
1070 
1071  priv->mb_width = FFALIGN(avctx->width, 16) / 16;
1072  priv->mb_height = FFALIGN(avctx->height, 16) / 16;
1073 
1074  if (ctx->va_rc_mode == VA_RC_CQP) {
1075  priv->fixed_qp_p = av_clip(ctx->rc_quality, 1, 51);
1076  if (avctx->i_quant_factor > 0.0)
1077  priv->fixed_qp_idr =
1078  av_clip((avctx->i_quant_factor * priv->fixed_qp_p +
1079  avctx->i_quant_offset) + 0.5, 1, 51);
1080  else
1081  priv->fixed_qp_idr = priv->fixed_qp_p;
1082  if (avctx->b_quant_factor > 0.0)
1083  priv->fixed_qp_b =
1084  av_clip((avctx->b_quant_factor * priv->fixed_qp_p +
1085  avctx->b_quant_offset) + 0.5, 1, 51);
1086  else
1087  priv->fixed_qp_b = priv->fixed_qp_p;
1088 
1089  av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
1090  "%d / %d / %d for IDR- / P- / B-frames.\n",
1091  priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
1092 
1093  } else {
1094  // These still need to be set for pic_init_qp/slice_qp_delta.
1095  priv->fixed_qp_idr = 26;
1096  priv->fixed_qp_p = 26;
1097  priv->fixed_qp_b = 26;
1098  }
1099 
1100  if (!ctx->rc_mode->hrd) {
1101  // Timing SEI requires a mode respecting HRD parameters.
1102  priv->sei &= ~SEI_TIMING;
1103  }
1104 
1105  if (priv->sei & SEI_IDENTIFIER) {
1106  const char *lavc = LIBAVCODEC_IDENT;
1107  const char *vaapi = VA_VERSION_S;
1108  const char *driver;
1109  int len;
1110 
1111  memcpy(priv->sei_identifier.uuid_iso_iec_11578,
1113  sizeof(priv->sei_identifier.uuid_iso_iec_11578));
1114 
1115  driver = vaQueryVendorString(ctx->hwctx->display);
1116  if (!driver)
1117  driver = "unknown driver";
1118 
1119  len = snprintf(NULL, 0, "%s / VAAPI %s / %s", lavc, vaapi, driver);
1120  if (len >= 0) {
1121  priv->sei_identifier_string = av_malloc(len + 1);
1122  if (!priv->sei_identifier_string)
1123  return AVERROR(ENOMEM);
1124 
1125  snprintf(priv->sei_identifier_string, len + 1,
1126  "%s / VAAPI %s / %s", lavc, vaapi, driver);
1127 
1129  priv->sei_identifier.data_length = len + 1;
1130  }
1131  }
1132 
1133  ctx->roi_quant_range = 51 + 6 * (ctx->profile->depth - 8);
1134 
1135  return 0;
1136 }
1137 
1139  { FF_PROFILE_H264_HIGH, 8, 3, 1, 1, VAProfileH264High },
1140  { FF_PROFILE_H264_MAIN, 8, 3, 1, 1, VAProfileH264Main },
1142  8, 3, 1, 1, VAProfileH264ConstrainedBaseline },
1143  { FF_PROFILE_UNKNOWN }
1144 };
1145 
1148 
1149  .flags = FLAG_SLICE_CONTROL |
1150  FLAG_B_PICTURES |
1153 
1154  .default_quality = 20,
1155 
1156  .configure = &vaapi_encode_h264_configure,
1157 
1158  .picture_priv_data_size = sizeof(VAAPIEncodeH264Picture),
1159 
1160  .sequence_params_size = sizeof(VAEncSequenceParameterBufferH264),
1161  .init_sequence_params = &vaapi_encode_h264_init_sequence_params,
1162 
1163  .picture_params_size = sizeof(VAEncPictureParameterBufferH264),
1164  .init_picture_params = &vaapi_encode_h264_init_picture_params,
1165 
1166  .slice_params_size = sizeof(VAEncSliceParameterBufferH264),
1167  .init_slice_params = &vaapi_encode_h264_init_slice_params,
1168 
1169  .sequence_header_type = VAEncPackedHeaderSequence,
1170  .write_sequence_header = &vaapi_encode_h264_write_sequence_header,
1171 
1172  .slice_header_type = VAEncPackedHeaderH264_Slice,
1173  .write_slice_header = &vaapi_encode_h264_write_slice_header,
1174 
1175  .write_extra_header = &vaapi_encode_h264_write_extra_header,
1176 };
1177 
1179 {
1180  VAAPIEncodeContext *ctx = avctx->priv_data;
1181  VAAPIEncodeH264Context *priv = avctx->priv_data;
1182 
1183  ctx->codec = &vaapi_encode_type_h264;
1184 
1185  if (avctx->profile == FF_PROFILE_UNKNOWN)
1186  avctx->profile = priv->profile;
1187  if (avctx->level == FF_LEVEL_UNKNOWN)
1188  avctx->level = priv->level;
1190  avctx->compression_level = priv->quality;
1191 
1192  // Reject unsupported profiles.
1193  switch (avctx->profile) {
1195  av_log(avctx, AV_LOG_WARNING, "H.264 baseline profile is not "
1196  "supported, using constrained baseline profile instead.\n");
1198  break;
1200  av_log(avctx, AV_LOG_ERROR, "H.264 extended profile "
1201  "is not supported.\n");
1202  return AVERROR_PATCHWELCOME;
1205  av_log(avctx, AV_LOG_ERROR, "H.264 10-bit profiles "
1206  "are not supported.\n");
1207  return AVERROR_PATCHWELCOME;
1214  av_log(avctx, AV_LOG_ERROR, "H.264 non-4:2:0 profiles "
1215  "are not supported.\n");
1216  return AVERROR_PATCHWELCOME;
1217  }
1218 
1219  if (avctx->level != FF_LEVEL_UNKNOWN && avctx->level & ~0xff) {
1220  av_log(avctx, AV_LOG_ERROR, "Invalid level %d: must fit "
1221  "in 8-bit unsigned integer.\n", avctx->level);
1222  return AVERROR(EINVAL);
1223  }
1224 
1225  ctx->desired_packed_headers =
1226  VA_ENC_PACKED_HEADER_SEQUENCE | // SPS and PPS.
1227  VA_ENC_PACKED_HEADER_SLICE | // Slice headers.
1228  VA_ENC_PACKED_HEADER_MISC; // SEI.
1229 
1230  ctx->surface_width = FFALIGN(avctx->width, 16);
1231  ctx->surface_height = FFALIGN(avctx->height, 16);
1232 
1233  ctx->slice_block_height = ctx->slice_block_width = 16;
1234 
1235  if (priv->qp > 0)
1236  ctx->explicit_qp = priv->qp;
1237 
1238  return ff_vaapi_encode_init(avctx);
1239 }
1240 
1242 {
1243  VAAPIEncodeH264Context *priv = avctx->priv_data;
1244 
1246  ff_cbs_close(&priv->cbc);
1248 
1249  return ff_vaapi_encode_close(avctx);
1250 }
1251 
1252 #define OFFSET(x) offsetof(VAAPIEncodeH264Context, x)
1253 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
1257 
1258  { "qp", "Constant QP (for P-frames; scaled by qfactor/qoffset for I/B)",
1259  OFFSET(qp), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 52, FLAGS },
1260  { "quality", "Set encode quality (trades off against speed, higher is faster)",
1261  OFFSET(quality), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
1262  { "coder", "Entropy coder type",
1263  OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, FLAGS, "coder" },
1264  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, FLAGS, "coder" },
1265  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, FLAGS, "coder" },
1266  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, FLAGS, "coder" },
1267  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, FLAGS, "coder" },
1268 
1269  { "aud", "Include AUD",
1270  OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
1271 
1272  { "sei", "Set SEI to include",
1275  0, INT_MAX, FLAGS, "sei" },
1276  { "identifier", "Include encoder version identifier",
1277  0, AV_OPT_TYPE_CONST, { .i64 = SEI_IDENTIFIER },
1278  INT_MIN, INT_MAX, FLAGS, "sei" },
1279  { "timing", "Include timing parameters (buffering_period and pic_timing)",
1280  0, AV_OPT_TYPE_CONST, { .i64 = SEI_TIMING },
1281  INT_MIN, INT_MAX, FLAGS, "sei" },
1282  { "recovery_point", "Include recovery points where appropriate",
1283  0, AV_OPT_TYPE_CONST, { .i64 = SEI_RECOVERY_POINT },
1284  INT_MIN, INT_MAX, FLAGS, "sei" },
1285 
1286  { "profile", "Set profile (profile_idc and constraint_set*_flag)",
1288  { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 0xffff, FLAGS, "profile" },
1289 
1290 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1291  { .i64 = value }, 0, 0, FLAGS, "profile"
1292  { PROFILE("constrained_baseline", FF_PROFILE_H264_CONSTRAINED_BASELINE) },
1293  { PROFILE("main", FF_PROFILE_H264_MAIN) },
1294  { PROFILE("high", FF_PROFILE_H264_HIGH) },
1295 #undef PROFILE
1296 
1297  { "level", "Set level (level_idc)",
1299  { .i64 = FF_LEVEL_UNKNOWN }, FF_LEVEL_UNKNOWN, 0xff, FLAGS, "level" },
1300 
1301 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1302  { .i64 = value }, 0, 0, FLAGS, "level"
1303  { LEVEL("1", 10) },
1304  { LEVEL("1.1", 11) },
1305  { LEVEL("1.2", 12) },
1306  { LEVEL("1.3", 13) },
1307  { LEVEL("2", 20) },
1308  { LEVEL("2.1", 21) },
1309  { LEVEL("2.2", 22) },
1310  { LEVEL("3", 30) },
1311  { LEVEL("3.1", 31) },
1312  { LEVEL("3.2", 32) },
1313  { LEVEL("4", 40) },
1314  { LEVEL("4.1", 41) },
1315  { LEVEL("4.2", 42) },
1316  { LEVEL("5", 50) },
1317  { LEVEL("5.1", 51) },
1318  { LEVEL("5.2", 52) },
1319  { LEVEL("6", 60) },
1320  { LEVEL("6.1", 61) },
1321  { LEVEL("6.2", 62) },
1322 #undef LEVEL
1323 
1324  { NULL },
1325 };
1326 
1328  { "b", "0" },
1329  { "bf", "2" },
1330  { "g", "120" },
1331  { "i_qfactor", "1" },
1332  { "i_qoffset", "0" },
1333  { "b_qfactor", "6/5" },
1334  { "b_qoffset", "0" },
1335  { "qmin", "-1" },
1336  { "qmax", "-1" },
1337  { NULL },
1338 };
1339 
1341  .class_name = "h264_vaapi",
1342  .item_name = av_default_item_name,
1343  .option = vaapi_encode_h264_options,
1344  .version = LIBAVUTIL_VERSION_INT,
1345 };
1346 
1348  .name = "h264_vaapi",
1349  .long_name = NULL_IF_CONFIG_SMALL("H.264/AVC (VAAPI)"),
1350  .type = AVMEDIA_TYPE_VIDEO,
1351  .id = AV_CODEC_ID_H264,
1352  .priv_data_size = sizeof(VAAPIEncodeH264Context),
1354  .send_frame = &ff_vaapi_encode_send_frame,
1355  .receive_packet = &ff_vaapi_encode_receive_packet,
1356  .close = &vaapi_encode_h264_close,
1357  .priv_class = &vaapi_encode_h264_class,
1358  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE,
1359  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1360  .defaults = vaapi_encode_h264_defaults,
1361  .pix_fmts = (const enum AVPixelFormat[]) {
1364  },
1365  .hw_configs = ff_vaapi_encode_hw_configs,
1366  .wrapper_name = "vaapi",
1367 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
#define FF_PROFILE_H264_MAIN
Definition: avcodec.h:1900
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:181
uint8_t frame_cropping_flag
Definition: cbs_h264.h:156
uint8_t deblocking_filter_control_present_flag
Definition: cbs_h264.h:211
uint32_t payload_type
Definition: cbs_h264.h:322
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:2069
static const VAAPIEncodeType vaapi_encode_type_h264
#define FF_PROFILE_H264_CAVLC_444
Definition: avcodec.h:1912
uint8_t bit_depth_chroma_minus8
Definition: cbs_h264.h:129
#define FF_COMPRESSION_DEFAULT
Definition: avcodec.h:599
uint8_t aspect_ratio_idc
Definition: cbs_h264.h:69
static av_cold int vaapi_encode_h264_configure(AVCodecContext *avctx)
uint8_t video_format
Definition: cbs_h264.h:77
AVOption.
Definition: opt.h:246
union H264RawSEIPayload::@28 payload
static void vaapi_encode_h264_default_ref_pic_list(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodePicture **rpl0, VAAPIEncodePicture **rpl1, int *rpl_size)
uint8_t bit_rate_scale
Definition: cbs_h264.h:54
uint16_t recovery_frame_cnt
Definition: cbs_h264.h:293
uint8_t dpb_output_delay_length_minus1
Definition: cbs_h264.h:63
uint8_t initial_cpb_removal_delay_length_minus1
Definition: cbs_h264.h:61
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
uint8_t chroma_sample_loc_type_bottom_field
Definition: cbs_h264.h:86
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
uint8_t constraint_set3_flag
Definition: h264_levels.h:28
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:150
int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:74
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:345
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1161
H264RawSEIRecoveryPoint recovery_point
Definition: cbs_h264.h:331
int num
Numerator.
Definition: rational.h:59
uint8_t log2_max_frame_num_minus4
Definition: cbs_h264.h:137
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int ff_cbs_insert_unit_content(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, AVBufferRef *content_buf)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:722
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:905
uint16_t pic_order_cnt_lsb
Definition: cbs_h264.h:367
uint8_t time_offset_length
Definition: cbs_h264.h:64
uint8_t low_delay_hrd_flag
Definition: cbs_h264.h:97
void * codec_sequence_params
Definition: vaapi_encode.h:271
#define FLAGS
#define OFFSET(x)
uint8_t max_dec_frame_buffering
Definition: cbs_h264.h:108
int profile
profile
Definition: avcodec.h:1859
uint8_t fixed_frame_rate_flag
Definition: cbs_h264.h:91
H264RawVUI vui
Definition: cbs_h264.h:163
AVCodec.
Definition: codec.h:190
int framerate
Definition: h264_levels.c:65
struct H264RawSliceHeader::@30 rplm_l0[H264_MAX_RPLM_COUNT]
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:838
uint32_t first_mb_in_slice
Definition: cbs_h264.h:354
static const AVClass vaapi_encode_h264_class
#define FF_PROFILE_H264_HIGH_444_PREDICTIVE
Definition: avcodec.h:1910
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:649
struct H264RawSliceHeader::@30 rplm_l1[H264_MAX_RPLM_COUNT]
uint8_t weighted_pred_flag
Definition: cbs_h264.h:204
uint8_t constraint_set4_flag
Definition: cbs_h264.h:119
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1983
H264RawHRD nal_hrd_parameters
Definition: cbs_h264.h:94
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
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:75
static int vaapi_encode_h264_write_extra_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, int index, int *type, char *data, size_t *data_len)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int8_t slice_qp_delta
Definition: cbs_h264.h:417
struct H264RawSliceHeader::@31 mmco[H264_MAX_MMCO_COUNT]
static const AVOption vaapi_encode_h264_options[]
H264RawSEIRecoveryPoint sei_recovery_point
#define FF_PROFILE_H264_BASELINE
Definition: avcodec.h:1898
int ff_vaapi_encode_send_frame(AVCodecContext *avctx, const AVFrame *frame)
uint8_t
#define av_cold
Definition: attributes.h:88
#define av_malloc(s)
AVOptions.
uint16_t frame_crop_top_offset
Definition: cbs_h264.h:159
uint16_t pic_width_in_mbs_minus1
Definition: cbs_h264.h:149
int dpb_frames
Definition: h264_levels.c:159
static const AVCodecDefault vaapi_encode_h264_defaults[]
const VAAPIEncodeRCMode * rc_mode
Definition: vaapi_encode.h:217
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
Definition: avcodec.h:795
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:352
static const uint8_t vaapi_encode_h264_sei_identifier_uuid[16]
uint32_t num_units_in_tick
Definition: cbs_h264.h:89
unregistered user data
Definition: h264_sei.h:34
uint8_t mb_adaptive_frame_field_flag
Definition: cbs_h264.h:153
uint8_t transform_8x8_mode_flag
Definition: cbs_h264.h:217
uint8_t constrained_intra_pred_flag
Definition: cbs_h264.h:212
uint32_t cpb_size_value_minus1[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:58
uint16_t frame_crop_left_offset
Definition: cbs_h264.h:157
static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, VAAPIEncodePicture *pic)
const char data[16]
Definition: mxf.c:91
static float hn(int n, EqParameter *param, float fs)
static av_cold int vaapi_encode_h264_init(AVCodecContext *avctx)
struct VAAPIEncodePicture * prev
Definition: vaapi_encode.h:116
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define FF_PROFILE_H264_EXTENDED
Definition: avcodec.h:1901
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
VASurfaceID recon_surface
Definition: vaapi_encode.h:91
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
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:228
uint16_t idr_pic_id
Definition: cbs_h264.h:365
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1168
#define FFALIGN(x, a)
Definition: macros.h:48
uint8_t ref_pic_list_modification_flag_l0
Definition: cbs_h264.h:378
int8_t second_chroma_qp_index_offset
Definition: cbs_h264.h:224
#define av_log(a,...)
uint8_t cpb_size_scale
Definition: cbs_h264.h:55
uint8_t nal_hrd_parameters_present_flag
Definition: cbs_h264.h:93
uint8_t bit_depth_luma_minus8
Definition: cbs_h264.h:128
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:129
void ff_cbs_fragment_free(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:157
H.264 common definitions.
uint8_t pic_scaling_matrix_present_flag
Definition: cbs_h264.h:219
unsigned int va_rc_mode
Definition: vaapi_encode.h:227
uint8_t chroma_sample_loc_type_top_field
Definition: cbs_h264.h:85
uint8_t modification_of_pic_nums_idc
Definition: cbs_h264.h:381
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
buffering period (H.264, D.1.1)
Definition: h264_sei.h:29
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
uint8_t aspect_ratio_info_present_flag
Definition: cbs_h264.h:68
#define AVERROR(e)
Definition: error.h:43
uint8_t max_num_ref_frames
Definition: cbs_h264.h:146
uint8_t weighted_bipred_idc
Definition: cbs_h264.h:205
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:188
uint8_t transfer_characteristics
Definition: cbs_h264.h:81
static int vaapi_encode_h264_write_access_unit(AVCodecContext *avctx, char *data, size_t *data_len, CodedBitstreamFragment *au)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
CodedBitstreamContext * cbc
const AVCodecHWConfigInternal * ff_vaapi_encode_hw_configs[]
Definition: vaapi_encode.c:30
#define FF_PROFILE_H264_HIGH_422
Definition: avcodec.h:1906
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:1902
uint16_t sar_width
Definition: cbs_h264.h:70
uint32_t initial_cpb_removal_delay_offset[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:237
uint8_t slice_type
Definition: cbs_h264.h:355
uint8_t num_ref_idx_l1_default_active_minus1
Definition: cbs_h264.h:202
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: codec.h:197
uint8_t frame_mbs_only_flag
Definition: cbs_h264.h:152
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
Definition: avcodec.h:831
uint8_t ref_pic_list_modification_flag_l1
Definition: cbs_h264.h:379
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
unsigned int va_bit_rate
Definition: vaapi_encode.h:229
uint8_t seq_parameter_set_id
Definition: cbs_h264.h:124
uint8_t seq_scaling_matrix_present_flag
Definition: cbs_h264.h:132
static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
void * codec_picture_params
Definition: vaapi_encode.h:100
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:133
H264RawSEIPicTiming pic_timing
Definition: cbs_h264.h:326
#define fail()
Definition: checkasm.h:123
uint8_t timing_info_present_flag
Definition: cbs_h264.h:88
uint8_t more_rbsp_data
Definition: cbs_h264.h:214
H264RawSEIPicTiming sei_pic_timing
uint8_t video_full_range_flag
Definition: cbs_h264.h:78
uint8_t seq_parameter_set_id
Definition: cbs_h264.h:184
#define LEVEL(name, value)
H264RawSEIUserDataUnregistered user_data_unregistered
Definition: cbs_h264.h:330
common internal API header
uint8_t adaptive_ref_pic_marking_mode_flag
Definition: cbs_h264.h:406
AVCodec ff_h264_vaapi_encoder
uint8_t colour_primaries
Definition: cbs_h264.h:80
picture timing
Definition: h264_sei.h:30
static int vaapi_encode_h264_write_sequence_header(AVCodecContext *avctx, char *data, size_t *data_len)
uint16_t sar_height
Definition: cbs_h264.h:71
uint16_t frame_crop_bottom_offset
Definition: cbs_h264.h:160
int width
picture width / height.
Definition: avcodec.h:699
uint8_t vui_parameters_present_flag
Definition: cbs_h264.h:162
const VAAPIEncodeProfile * profile
Definition: vaapi_encode.h:214
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1860
const VAAPIEncodeProfile * profiles
Definition: vaapi_encode.h:352
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
uint32_t cpb_removal_delay
Definition: cbs_h264.h:259
AVFormatContext * ctx
Definition: movenc.c:48
uint8_t colour_description_present_flag
Definition: cbs_h264.h:79
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1140
static const VAAPIEncodeProfile vaapi_encode_h264_profiles[]
uint8_t video_signal_type_present_flag
Definition: cbs_h264.h:76
int level
level
Definition: avcodec.h:1982
void * codec_picture_params
Definition: vaapi_encode.h:275
static int vaapi_encode_h264_write_slice_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice, char *data, size_t *data_len)
static int vaapi_encode_h264_add_nal(AVCodecContext *avctx, CodedBitstreamFragment *au, void *nal_unit)
int8_t chroma_qp_index_offset
Definition: cbs_h264.h:209
int ff_vaapi_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
uint8_t constraint_set5_flag
Definition: cbs_h264.h:120
uint8_t pic_parameter_set_id
Definition: cbs_h264.h:357
uint8_t chroma_format_idc
Definition: cbs_h264.h:126
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:122
#define FF_ARRAY_ELEMS(a)
uint8_t profile_idc
Definition: cbs_h264.h:114
int32_t abs_diff_pic_num_minus1
Definition: cbs_h264.h:382
#define av_log2
Definition: intmath.h:83
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:535
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:340
VADisplay display
The VADisplay handle, to be filled by the user.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
struct VAAPIEncodePicture * refs[MAX_PICTURE_REFERENCES]
Definition: vaapi_encode.h:113
uint32_t bit_rate_value_minus1[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:57
uint8_t cpb_cnt_minus1
Definition: cbs_h264.h:53
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:112
uint8_t chroma_loc_info_present_flag
Definition: cbs_h264.h:84
uint8_t cbr_flag[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:59
const struct VAAPIEncodeType * codec
Definition: vaapi_encode.h:176
Libavcodec external API header.
#define VAAPI_ENCODE_RC_OPTIONS
Definition: vaapi_encode.h:447
#define FF_PROFILE_H264_HIGH_422_INTRA
Definition: avcodec.h:1907
int compression_level
Definition: avcodec.h:598
uint8_t bottom_field_pic_order_in_frame_present_flag
Definition: cbs_h264.h:187
uint8_t entropy_coding_mode_flag
Definition: cbs_h264.h:186
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
VAAPIEncodeContext common
main external API structure.
Definition: avcodec.h:526
#define FF_PROFILE_H264_HIGH_10_INTRA
Definition: avcodec.h:1904
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
uint8_t pic_order_cnt_type
Definition: cbs_h264.h:138
Describe the class of an AVClass context structure.
Definition: log.h:67
void ff_cbs_fragment_reset(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment&#39;s own data buffer, but not the units a...
Definition: cbs.c:142
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Context structure for coded bitstream operations.
Definition: cbs.h:168
uint8_t matrix_coefficients
Definition: cbs_h264.h:82
uint8_t num_ref_idx_l0_default_active_minus1
Definition: cbs_h264.h:201
int index
Definition: gxfenc.c:89
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
uint16_t frame_num
Definition: cbs_h264.h:361
cl_device_type type
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
recovery point (frame # to decoder sync)
Definition: h264_sei.h:35
#define FF_PROFILE_H264_HIGH_444
Definition: avcodec.h:1909
uint8_t log2_max_mv_length_horizontal
Definition: cbs_h264.h:105
uint8_t direct_spatial_mv_pred_flag
Definition: cbs_h264.h:372
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:115
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:808
#define snprintf
Definition: snprintf.h:34
H264RawSEIBufferingPeriod buffering_period
Definition: cbs_h264.h:325
H264RawSEIPayload payload[H264_MAX_SEI_PAYLOADS]
Definition: cbs_h264.h:347
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
mfxU16 profile
Definition: qsvenc.c:45
CodedBitstreamFragment current_access_unit
#define VAAPI_ENCODE_COMMON_OPTIONS
Definition: vaapi_encode.h:429
uint8_t level
Definition: svq3.c:210
uint8_t direct_8x8_inference_flag
Definition: cbs_h264.h:154
static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice)
uint32_t initial_cpb_removal_delay[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:236
VAEncMiscParameterHRD hrd_params
Definition: vaapi_encode.h:264
common internal api header.
common internal and external API header
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
uint8_t redundant_pic_cnt_present_flag
Definition: cbs_h264.h:216
uint8_t memory_management_control_operation
Definition: cbs_h264.h:408
uint8_t cpb_removal_delay_length_minus1
Definition: cbs_h264.h:62
uint8_t motion_vectors_over_pic_boundaries_flag
Definition: cbs_h264.h:102
uint32_t time_scale
Definition: cbs_h264.h:90
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
uint8_t bitstream_restriction_flag
Definition: cbs_h264.h:101
uint8_t level_idc
Definition: cbs_h264.h:122
uint16_t frame_crop_right_offset
Definition: cbs_h264.h:158
int den
Denominator.
Definition: rational.h:60
uint8_t pic_parameter_set_id
Definition: cbs_h264.h:183
uint8_t max_num_reorder_frames
Definition: cbs_h264.h:107
H264RawSEIUserDataUnregistered sei_identifier
void * priv_data
Definition: avcodec.h:553
#define PROFILE(name, value)
uint8_t log2_max_mv_length_vertical
Definition: cbs_h264.h:106
H264RawSliceHeader header
Definition: cbs_h264.h:430
uint8_t log2_max_pic_order_cnt_lsb_minus4
Definition: cbs_h264.h:139
int len
const char * name
Definition: h264_levels.h:26
struct H264RawSEIBufferingPeriod::@27 nal
static av_cold int vaapi_encode_h264_close(AVCodecContext *avctx)
void * codec_slice_params
Definition: vaapi_encode.h:64
uint8_t delta_pic_order_always_zero_flag
Definition: cbs_h264.h:140
H264RawSEIBufferingPeriod sei_buffering_period
#define FF_PROFILE_H264_HIGH_444_INTRA
Definition: avcodec.h:1911
int8_t pic_init_qp_minus26
Definition: cbs_h264.h:207
#define LIBAVCODEC_IDENT
Definition: version.h:42
unsigned int desired_packed_headers
Definition: vaapi_encode.h:198
uint8_t nal_ref_idc
Definition: cbs_h264.h:41
#define av_freep(p)
#define FFSWAP(type, a, b)
Definition: common.h:99
uint8_t constraint_set1_flag
Definition: cbs_h264.h:116
uint16_t pic_height_in_map_units_minus1
Definition: cbs_h264.h:150
#define FF_PROFILE_H264_CONSTRAINED_BASELINE
Definition: avcodec.h:1899
VABufferID output_buffer
Definition: vaapi_encode.h:97
#define FF_PROFILE_H264_HIGH_10
Definition: avcodec.h:1903
int32_t difference_of_pic_nums_minus1
Definition: cbs_h264.h:409
uint8_t nal_unit_type
Definition: cbs_h264.h:42
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
struct VAAPIEncodePicture * dpb[MAX_DPB_SIZE]
Definition: vaapi_encode.h:109
uint8_t payload_count
Definition: cbs_h264.h:348
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
const H264LevelDescriptor * ff_h264_guess_level(int profile_idc, int64_t bitrate, int framerate, int width, int height, int max_dec_frame_buffering)
Guess the level of a stream from some parameters.
Definition: h264_levels.c:90
AVVAAPIDeviceContext * hwctx
Definition: vaapi_encode.h:242
uint8_t constraint_set3_flag
Definition: cbs_h264.h:118