FFmpeg
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/mem.h"
27 #include "libavutil/pixdesc.h"
28 #include "libavutil/opt.h"
29 
30 #include "atsc_a53.h"
31 #include "avcodec.h"
32 #include "cbs.h"
33 #include "cbs_h264.h"
34 #include "codec_internal.h"
35 #include "h264.h"
36 #include "h264_levels.h"
37 #include "h2645data.h"
38 #include "vaapi_encode.h"
39 #include "version.h"
40 
41 enum {
42  SEI_TIMING = 0x01,
45  SEI_A53_CC = 0x08,
46 };
47 
48 // Random (version 4) ISO 11578 UUID.
49 static const uint8_t vaapi_encode_h264_sei_identifier_uuid[16] = {
50  0x59, 0x94, 0x8b, 0x28, 0x11, 0xec, 0x45, 0xaf,
51  0x96, 0x75, 0x19, 0xd4, 0x1f, 0xea, 0xa9, 0x4d,
52 };
53 
54 typedef struct VAAPIEncodeH264Picture {
55  int frame_num;
57 
58  int64_t last_idr_frame;
59  uint16_t idr_pic_id;
60 
63 
64  int cpb_delay;
65  int dpb_delay;
67 
68 typedef struct VAAPIEncodeH264Context {
70 
71  // User options.
72  int qp;
73  int quality;
74  int coder;
75  int aud;
76  int sei;
77  int profile;
78  int level;
79 
80  // Derived settings.
81  int mb_width;
82  int mb_height;
83 
87 
89 
90  // Writer structures.
93 
98 
106 
111 
112 
114  char *data, size_t *data_len,
116 {
117  VAAPIEncodeH264Context *priv = avctx->priv_data;
118  int err;
119 
120  err = ff_cbs_write_fragment_data(priv->cbc, au);
121  if (err < 0) {
122  av_log(avctx, AV_LOG_ERROR, "Failed to write packed header.\n");
123  return err;
124  }
125 
126  if (*data_len < 8 * au->data_size - au->data_bit_padding) {
127  av_log(avctx, AV_LOG_ERROR, "Access unit too large: "
128  "%zu < %zu.\n", *data_len,
129  8 * au->data_size - au->data_bit_padding);
130  return AVERROR(ENOSPC);
131  }
132 
133  memcpy(data, au->data, au->data_size);
134  *data_len = 8 * au->data_size - au->data_bit_padding;
135 
136  return 0;
137 }
138 
141  void *nal_unit)
142 {
143  H264RawNALUnitHeader *header = nal_unit;
144  int err;
145 
146  err = ff_cbs_insert_unit_content(au, -1,
147  header->nal_unit_type, nal_unit, NULL);
148  if (err < 0) {
149  av_log(avctx, AV_LOG_ERROR, "Failed to add NAL unit: "
150  "type = %d.\n", header->nal_unit_type);
151  return err;
152  }
153 
154  return 0;
155 }
156 
158  char *data, size_t *data_len)
159 {
160  VAAPIEncodeH264Context *priv = avctx->priv_data;
162  int err;
163 
164  if (priv->aud_needed) {
165  err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_aud);
166  if (err < 0)
167  goto fail;
168  priv->aud_needed = 0;
169  }
170 
171  err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_sps);
172  if (err < 0)
173  goto fail;
174 
175  err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_pps);
176  if (err < 0)
177  goto fail;
178 
179  err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au);
180 fail:
182  return err;
183 }
184 
186  VAAPIEncodePicture *pic,
187  VAAPIEncodeSlice *slice,
188  char *data, size_t *data_len)
189 {
190  VAAPIEncodeH264Context *priv = avctx->priv_data;
192  int err;
193 
194  if (priv->aud_needed) {
195  err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_aud);
196  if (err < 0)
197  goto fail;
198  priv->aud_needed = 0;
199  }
200 
201  err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_slice);
202  if (err < 0)
203  goto fail;
204 
205  err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au);
206 fail:
208  return err;
209 }
210 
212  VAAPIEncodePicture *pic,
213  int index, int *type,
214  char *data, size_t *data_len)
215 {
216  VAAPIEncodeH264Context *priv = avctx->priv_data;
218  int err;
219 
220  if (priv->sei_needed) {
221  if (priv->aud_needed) {
222  err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_aud);
223  if (err < 0)
224  goto fail;
225  priv->aud_needed = 0;
226  }
227 
228  if (priv->sei_needed & SEI_IDENTIFIER) {
229  err = ff_cbs_sei_add_message(priv->cbc, au, 1,
231  &priv->sei_identifier, NULL);
232  if (err < 0)
233  goto fail;
234  }
235  if (priv->sei_needed & SEI_TIMING) {
236  if (pic->type == PICTURE_TYPE_IDR) {
237  err = ff_cbs_sei_add_message(priv->cbc, au, 1,
239  &priv->sei_buffering_period, NULL);
240  if (err < 0)
241  goto fail;
242  }
243  err = ff_cbs_sei_add_message(priv->cbc, au, 1,
245  &priv->sei_pic_timing, NULL);
246  if (err < 0)
247  goto fail;
248  }
249  if (priv->sei_needed & SEI_RECOVERY_POINT) {
250  err = ff_cbs_sei_add_message(priv->cbc, au, 1,
252  &priv->sei_recovery_point, NULL);
253  if (err < 0)
254  goto fail;
255  }
256  if (priv->sei_needed & SEI_A53_CC) {
257  err = ff_cbs_sei_add_message(priv->cbc, au, 1,
259  &priv->sei_a53cc, NULL);
260  if (err < 0)
261  goto fail;
262  }
263 
264  priv->sei_needed = 0;
265 
266  err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au);
267  if (err < 0)
268  goto fail;
269 
271 
272  *type = VAEncPackedHeaderRawData;
273  return 0;
274 
275 #if !CONFIG_VAAPI_1
276  } else if (priv->sei_cbr_workaround_needed) {
277  // Insert a zero-length header using the old SEI type. This is
278  // required to avoid triggering broken behaviour on Intel platforms
279  // in CBR mode where an invalid SEI message is generated by the
280  // driver and inserted into the stream.
281  *data_len = 0;
282  *type = VAEncPackedHeaderH264_SEI;
283  priv->sei_cbr_workaround_needed = 0;
284  return 0;
285 #endif
286 
287  } else {
288  return AVERROR_EOF;
289  }
290 
291 fail:
293  return err;
294 }
295 
297 {
298  VAAPIEncodeContext *ctx = avctx->priv_data;
299  VAAPIEncodeH264Context *priv = avctx->priv_data;
300  H264RawSPS *sps = &priv->raw_sps;
301  H264RawPPS *pps = &priv->raw_pps;
302  VAEncSequenceParameterBufferH264 *vseq = ctx->codec_sequence_params;
303  VAEncPictureParameterBufferH264 *vpic = ctx->codec_picture_params;
304  const AVPixFmtDescriptor *desc;
305  int bit_depth;
306 
307  memset(sps, 0, sizeof(*sps));
308  memset(pps, 0, sizeof(*pps));
309 
311  av_assert0(desc);
312  if (desc->nb_components == 1 || desc->log2_chroma_w != 1 || desc->log2_chroma_h != 1) {
313  av_log(avctx, AV_LOG_ERROR, "Chroma format of input pixel format "
314  "%s is not supported.\n", desc->name);
315  return AVERROR(EINVAL);
316  }
317  bit_depth = desc->comp[0].depth;
318 
319  sps->nal_unit_header.nal_ref_idc = 3;
320  sps->nal_unit_header.nal_unit_type = H264_NAL_SPS;
321 
322  sps->profile_idc = avctx->profile & 0xff;
323 
325  avctx->profile == AV_PROFILE_H264_MAIN)
326  sps->constraint_set1_flag = 1;
327 
328  if (avctx->profile == AV_PROFILE_H264_HIGH || avctx->profile == AV_PROFILE_H264_HIGH_10)
329  sps->constraint_set3_flag = ctx->gop_size == 1;
330 
331  if (avctx->profile == AV_PROFILE_H264_MAIN ||
333  sps->constraint_set4_flag = 1;
334  sps->constraint_set5_flag = ctx->b_per_p == 0;
335  }
336 
337  if (ctx->gop_size == 1)
338  priv->dpb_frames = 0;
339  else
340  priv->dpb_frames = 1 + ctx->max_b_depth;
341 
342  if (avctx->level != AV_LEVEL_UNKNOWN) {
343  sps->level_idc = avctx->level;
344  } else {
345  const H264LevelDescriptor *level;
346  int framerate;
347 
348  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
349  framerate = avctx->framerate.num / avctx->framerate.den;
350  else
351  framerate = 0;
352 
353  level = ff_h264_guess_level(sps->profile_idc,
354  avctx->bit_rate,
355  framerate,
356  priv->mb_width * 16,
357  priv->mb_height * 16,
358  priv->dpb_frames);
359  if (level) {
360  av_log(avctx, AV_LOG_VERBOSE, "Using level %s.\n", level->name);
361  if (level->constraint_set3_flag)
362  sps->constraint_set3_flag = 1;
363  sps->level_idc = level->level_idc;
364  } else {
365  av_log(avctx, AV_LOG_WARNING, "Stream will not conform "
366  "to any level: using level 6.2.\n");
367  sps->level_idc = 62;
368  }
369  }
370 
371  sps->seq_parameter_set_id = 0;
372  sps->chroma_format_idc = 1;
373  sps->bit_depth_luma_minus8 = bit_depth - 8;
374  sps->bit_depth_chroma_minus8 = bit_depth - 8;
375 
376  sps->log2_max_frame_num_minus4 = 4;
377  sps->pic_order_cnt_type = ctx->max_b_depth ? 0 : 2;
378  if (sps->pic_order_cnt_type == 0) {
379  sps->log2_max_pic_order_cnt_lsb_minus4 = 4;
380  }
381 
382  sps->max_num_ref_frames = priv->dpb_frames;
383 
384  sps->pic_width_in_mbs_minus1 = priv->mb_width - 1;
385  sps->pic_height_in_map_units_minus1 = priv->mb_height - 1;
386 
387  sps->frame_mbs_only_flag = 1;
388  sps->direct_8x8_inference_flag = 1;
389 
390  if (avctx->width != 16 * priv->mb_width ||
391  avctx->height != 16 * priv->mb_height) {
392  sps->frame_cropping_flag = 1;
393 
394  sps->frame_crop_left_offset = 0;
395  sps->frame_crop_right_offset =
396  (16 * priv->mb_width - avctx->width) / 2;
397  sps->frame_crop_top_offset = 0;
398  sps->frame_crop_bottom_offset =
399  (16 * priv->mb_height - avctx->height) / 2;
400  } else {
401  sps->frame_cropping_flag = 0;
402  }
403 
404  sps->vui_parameters_present_flag = 1;
405 
406  if (avctx->sample_aspect_ratio.num != 0 &&
407  avctx->sample_aspect_ratio.den != 0) {
408  int num, den, i;
409  av_reduce(&num, &den, avctx->sample_aspect_ratio.num,
410  avctx->sample_aspect_ratio.den, 65535);
411  for (i = 0; i < FF_ARRAY_ELEMS(ff_h2645_pixel_aspect); i++) {
412  if (num == ff_h2645_pixel_aspect[i].num &&
413  den == ff_h2645_pixel_aspect[i].den) {
414  sps->vui.aspect_ratio_idc = i;
415  break;
416  }
417  }
419  sps->vui.aspect_ratio_idc = 255;
420  sps->vui.sar_width = num;
421  sps->vui.sar_height = den;
422  }
423  sps->vui.aspect_ratio_info_present_flag = 1;
424  }
425 
426  // Unspecified video format, from table E-2.
427  sps->vui.video_format = 5;
428  sps->vui.video_full_range_flag =
429  avctx->color_range == AVCOL_RANGE_JPEG;
430  sps->vui.colour_primaries = avctx->color_primaries;
431  sps->vui.transfer_characteristics = avctx->color_trc;
432  sps->vui.matrix_coefficients = avctx->colorspace;
433  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
434  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
436  sps->vui.colour_description_present_flag = 1;
437  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED ||
438  sps->vui.colour_description_present_flag)
439  sps->vui.video_signal_type_present_flag = 1;
440 
442  sps->vui.chroma_loc_info_present_flag = 1;
443  sps->vui.chroma_sample_loc_type_top_field =
444  sps->vui.chroma_sample_loc_type_bottom_field =
445  avctx->chroma_sample_location - 1;
446  }
447 
448  sps->vui.timing_info_present_flag = 1;
449  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
450  sps->vui.num_units_in_tick = avctx->framerate.den;
451  sps->vui.time_scale = 2 * avctx->framerate.num;
452  sps->vui.fixed_frame_rate_flag = 1;
453  } else {
454  sps->vui.num_units_in_tick = avctx->time_base.num;
455  sps->vui.time_scale = 2 * avctx->time_base.den;
456  sps->vui.fixed_frame_rate_flag = 0;
457  }
458 
459  if (priv->sei & SEI_TIMING) {
460  H264RawHRD *hrd = &sps->vui.nal_hrd_parameters;
462 
463  sps->vui.nal_hrd_parameters_present_flag = 1;
464 
465  hrd->cpb_cnt_minus1 = 0;
466 
467  // Try to scale these to a sensible range so that the
468  // golomb encode of the value is not overlong.
469  hrd->bit_rate_scale =
470  av_clip_uintp2(av_log2(ctx->va_bit_rate) - 15 - 6, 4);
471  hrd->bit_rate_value_minus1[0] =
472  (ctx->va_bit_rate >> hrd->bit_rate_scale + 6) - 1;
473 
474  hrd->cpb_size_scale =
475  av_clip_uintp2(av_log2(ctx->hrd_params.buffer_size) - 15 - 4, 4);
476  hrd->cpb_size_value_minus1[0] =
477  (ctx->hrd_params.buffer_size >> hrd->cpb_size_scale + 4) - 1;
478 
479  // CBR mode as defined for the HRD cannot be achieved without filler
480  // data, so this flag cannot be set even with VAAPI CBR modes.
481  hrd->cbr_flag[0] = 0;
482 
486  hrd->time_offset_length = 0;
487 
488  bp->seq_parameter_set_id = sps->seq_parameter_set_id;
489 
490  // This calculation can easily overflow 32 bits.
491  bp->nal.initial_cpb_removal_delay[0] = 90000 *
492  (uint64_t)ctx->hrd_params.initial_buffer_fullness /
493  ctx->hrd_params.buffer_size;
495  } else {
496  sps->vui.nal_hrd_parameters_present_flag = 0;
497  sps->vui.low_delay_hrd_flag = 1 - sps->vui.fixed_frame_rate_flag;
498  }
499 
500  sps->vui.bitstream_restriction_flag = 1;
501  sps->vui.motion_vectors_over_pic_boundaries_flag = 1;
502  sps->vui.log2_max_mv_length_horizontal = 15;
503  sps->vui.log2_max_mv_length_vertical = 15;
504  sps->vui.max_num_reorder_frames = ctx->max_b_depth;
505  sps->vui.max_dec_frame_buffering = ctx->max_b_depth + 1;
506 
507  pps->nal_unit_header.nal_ref_idc = 3;
508  pps->nal_unit_header.nal_unit_type = H264_NAL_PPS;
509 
510  pps->pic_parameter_set_id = 0;
511  pps->seq_parameter_set_id = 0;
512 
513  pps->entropy_coding_mode_flag =
514  !(sps->profile_idc == AV_PROFILE_H264_BASELINE ||
515  sps->profile_idc == AV_PROFILE_H264_EXTENDED ||
516  sps->profile_idc == AV_PROFILE_H264_CAVLC_444);
517  if (!priv->coder && pps->entropy_coding_mode_flag)
518  pps->entropy_coding_mode_flag = 0;
519 
520  pps->num_ref_idx_l0_default_active_minus1 = 0;
521  pps->num_ref_idx_l1_default_active_minus1 = 0;
522 
523  pps->pic_init_qp_minus26 = priv->fixed_qp_idr - 26;
524 
525  if (sps->profile_idc == AV_PROFILE_H264_BASELINE ||
526  sps->profile_idc == AV_PROFILE_H264_EXTENDED ||
527  sps->profile_idc == AV_PROFILE_H264_MAIN) {
528  pps->more_rbsp_data = 0;
529  } else {
530  pps->more_rbsp_data = 1;
531 
532  pps->transform_8x8_mode_flag = 1;
533  }
534 
535  *vseq = (VAEncSequenceParameterBufferH264) {
536  .seq_parameter_set_id = sps->seq_parameter_set_id,
537  .level_idc = sps->level_idc,
538  .intra_period = ctx->gop_size,
539  .intra_idr_period = ctx->gop_size,
540  .ip_period = ctx->b_per_p + 1,
541 
542  .bits_per_second = ctx->va_bit_rate,
543  .max_num_ref_frames = sps->max_num_ref_frames,
544  .picture_width_in_mbs = sps->pic_width_in_mbs_minus1 + 1,
545  .picture_height_in_mbs = sps->pic_height_in_map_units_minus1 + 1,
546 
547  .seq_fields.bits = {
548  .chroma_format_idc = sps->chroma_format_idc,
549  .frame_mbs_only_flag = sps->frame_mbs_only_flag,
550  .mb_adaptive_frame_field_flag = sps->mb_adaptive_frame_field_flag,
551  .seq_scaling_matrix_present_flag = sps->seq_scaling_matrix_present_flag,
552  .direct_8x8_inference_flag = sps->direct_8x8_inference_flag,
553  .log2_max_frame_num_minus4 = sps->log2_max_frame_num_minus4,
554  .pic_order_cnt_type = sps->pic_order_cnt_type,
555  .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_pic_order_cnt_lsb_minus4,
556  .delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag,
557  },
558 
559  .bit_depth_luma_minus8 = sps->bit_depth_luma_minus8,
560  .bit_depth_chroma_minus8 = sps->bit_depth_chroma_minus8,
561 
562  .frame_cropping_flag = sps->frame_cropping_flag,
563  .frame_crop_left_offset = sps->frame_crop_left_offset,
564  .frame_crop_right_offset = sps->frame_crop_right_offset,
565  .frame_crop_top_offset = sps->frame_crop_top_offset,
566  .frame_crop_bottom_offset = sps->frame_crop_bottom_offset,
567 
568  .vui_parameters_present_flag = sps->vui_parameters_present_flag,
569 
570  .vui_fields.bits = {
571  .aspect_ratio_info_present_flag = sps->vui.aspect_ratio_info_present_flag,
572  .timing_info_present_flag = sps->vui.timing_info_present_flag,
573  .bitstream_restriction_flag = sps->vui.bitstream_restriction_flag,
574  .log2_max_mv_length_horizontal = sps->vui.log2_max_mv_length_horizontal,
575  .log2_max_mv_length_vertical = sps->vui.log2_max_mv_length_vertical,
576  },
577 
578  .aspect_ratio_idc = sps->vui.aspect_ratio_idc,
579  .sar_width = sps->vui.sar_width,
580  .sar_height = sps->vui.sar_height,
581  .num_units_in_tick = sps->vui.num_units_in_tick,
582  .time_scale = sps->vui.time_scale,
583  };
584 
585  *vpic = (VAEncPictureParameterBufferH264) {
586  .CurrPic = {
587  .picture_id = VA_INVALID_ID,
588  .flags = VA_PICTURE_H264_INVALID,
589  },
590 
591  .coded_buf = VA_INVALID_ID,
592 
593  .pic_parameter_set_id = pps->pic_parameter_set_id,
594  .seq_parameter_set_id = pps->seq_parameter_set_id,
595 
596  .pic_init_qp = pps->pic_init_qp_minus26 + 26,
597  .num_ref_idx_l0_active_minus1 = pps->num_ref_idx_l0_default_active_minus1,
598  .num_ref_idx_l1_active_minus1 = pps->num_ref_idx_l1_default_active_minus1,
599 
600  .chroma_qp_index_offset = pps->chroma_qp_index_offset,
601  .second_chroma_qp_index_offset = pps->second_chroma_qp_index_offset,
602 
603  .pic_fields.bits = {
604  .entropy_coding_mode_flag = pps->entropy_coding_mode_flag,
605  .weighted_pred_flag = pps->weighted_pred_flag,
606  .weighted_bipred_idc = pps->weighted_bipred_idc,
607  .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
608  .transform_8x8_mode_flag = pps->transform_8x8_mode_flag,
609  .deblocking_filter_control_present_flag =
610  pps->deblocking_filter_control_present_flag,
611  .redundant_pic_cnt_present_flag = pps->redundant_pic_cnt_present_flag,
612  .pic_order_present_flag =
613  pps->bottom_field_pic_order_in_frame_present_flag,
614  .pic_scaling_matrix_present_flag = pps->pic_scaling_matrix_present_flag,
615  },
616  };
617 
618  return 0;
619 }
620 
622  VAAPIEncodePicture *pic)
623 {
624  VAAPIEncodeContext *ctx = avctx->priv_data;
625  VAAPIEncodeH264Context *priv = avctx->priv_data;
626  VAAPIEncodeH264Picture *hpic = pic->priv_data;
627  VAAPIEncodePicture *prev = pic->prev;
628  VAAPIEncodeH264Picture *hprev = prev ? prev->priv_data : NULL;
629  VAEncPictureParameterBufferH264 *vpic = pic->codec_picture_params;
630  int i, j = 0;
631 
632  if (pic->type == PICTURE_TYPE_IDR) {
633  av_assert0(pic->display_order == pic->encode_order);
634 
635  hpic->frame_num = 0;
636  hpic->last_idr_frame = pic->display_order;
637  hpic->idr_pic_id = hprev ? hprev->idr_pic_id + 1 : 0;
638 
639  hpic->primary_pic_type = 0;
640  hpic->slice_type = 7;
641  } else {
642  av_assert0(prev);
643 
644  hpic->frame_num = hprev->frame_num + prev->is_reference;
645 
646  hpic->last_idr_frame = hprev->last_idr_frame;
647  hpic->idr_pic_id = hprev->idr_pic_id;
648 
649  if (pic->type == PICTURE_TYPE_I) {
650  hpic->slice_type = 7;
651  hpic->primary_pic_type = 0;
652  } else if (pic->type == PICTURE_TYPE_P) {
653  hpic->slice_type = 5;
654  hpic->primary_pic_type = 1;
655  } else {
656  hpic->slice_type = 6;
657  hpic->primary_pic_type = 2;
658  }
659  }
660  hpic->pic_order_cnt = pic->display_order - hpic->last_idr_frame;
661  if (priv->raw_sps.pic_order_cnt_type == 2) {
662  hpic->pic_order_cnt *= 2;
663  }
664 
665  hpic->dpb_delay = pic->display_order - pic->encode_order + ctx->max_b_depth;
666  hpic->cpb_delay = pic->encode_order - hpic->last_idr_frame;
667 
668  if (priv->aud) {
669  priv->aud_needed = 1;
670  priv->raw_aud = (H264RawAUD) {
671  .nal_unit_header = {
673  },
674  .primary_pic_type = hpic->primary_pic_type,
675  };
676  } else {
677  priv->aud_needed = 0;
678  }
679 
680  priv->sei_needed = 0;
681 
682  if (priv->sei & SEI_IDENTIFIER && pic->encode_order == 0)
683  priv->sei_needed |= SEI_IDENTIFIER;
684 #if !CONFIG_VAAPI_1
685  if (ctx->va_rc_mode == VA_RC_CBR)
686  priv->sei_cbr_workaround_needed = 1;
687 #endif
688 
689  if (priv->sei & SEI_TIMING) {
691  .cpb_removal_delay = 2 * hpic->cpb_delay,
692  .dpb_output_delay = 2 * hpic->dpb_delay,
693  };
694 
695  priv->sei_needed |= SEI_TIMING;
696  }
697 
698  if (priv->sei & SEI_RECOVERY_POINT && pic->type == PICTURE_TYPE_I) {
700  .recovery_frame_cnt = 0,
701  .exact_match_flag = 1,
702  .broken_link_flag = ctx->b_per_p > 0,
703  };
704 
706  }
707 
708  if (priv->sei & SEI_A53_CC) {
709  int err;
710  size_t sei_a53cc_len;
711  av_freep(&priv->sei_a53cc_data);
712  err = ff_alloc_a53_sei(pic->input_image, 0, &priv->sei_a53cc_data, &sei_a53cc_len);
713  if (err < 0)
714  return err;
715  if (priv->sei_a53cc_data != NULL) {
716  priv->sei_a53cc.itu_t_t35_country_code = 181;
717  priv->sei_a53cc.data = (uint8_t *)priv->sei_a53cc_data + 1;
718  priv->sei_a53cc.data_length = sei_a53cc_len - 1;
719 
720  priv->sei_needed |= SEI_A53_CC;
721  }
722  }
723 
724  vpic->CurrPic = (VAPictureH264) {
725  .picture_id = pic->recon_surface,
726  .frame_idx = hpic->frame_num,
727  .flags = 0,
728  .TopFieldOrderCnt = hpic->pic_order_cnt,
729  .BottomFieldOrderCnt = hpic->pic_order_cnt,
730  };
731  for (int k = 0; k < MAX_REFERENCE_LIST_NUM; k++) {
732  for (i = 0; i < pic->nb_refs[k]; i++) {
733  VAAPIEncodePicture *ref = pic->refs[k][i];
735 
736  av_assert0(ref && ref->encode_order < pic->encode_order);
737  href = ref->priv_data;
738 
739  vpic->ReferenceFrames[j++] = (VAPictureH264) {
740  .picture_id = ref->recon_surface,
741  .frame_idx = href->frame_num,
742  .flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE,
743  .TopFieldOrderCnt = href->pic_order_cnt,
744  .BottomFieldOrderCnt = href->pic_order_cnt,
745  };
746  }
747  }
748 
749  for (; j < FF_ARRAY_ELEMS(vpic->ReferenceFrames); j++) {
750  vpic->ReferenceFrames[j] = (VAPictureH264) {
751  .picture_id = VA_INVALID_ID,
752  .flags = VA_PICTURE_H264_INVALID,
753  };
754  }
755 
756  vpic->coded_buf = pic->output_buffer;
757 
758  vpic->frame_num = hpic->frame_num;
759 
760  vpic->pic_fields.bits.idr_pic_flag = (pic->type == PICTURE_TYPE_IDR);
761  vpic->pic_fields.bits.reference_pic_flag = pic->is_reference;
762 
763  return 0;
764 }
765 
767  VAAPIEncodePicture *pic,
768  VAAPIEncodePicture **rpl0,
769  VAAPIEncodePicture **rpl1,
770  int *rpl_size)
771 {
772  VAAPIEncodePicture *prev;
773  VAAPIEncodeH264Picture *hp, *hn, *hc;
774  int i, j, n = 0;
775 
776  prev = pic->prev;
777  av_assert0(prev);
778  hp = pic->priv_data;
779 
780  for (i = 0; i < pic->prev->nb_dpb_pics; i++) {
781  hn = prev->dpb[i]->priv_data;
782  av_assert0(hn->frame_num < hp->frame_num);
783 
784  if (pic->type == PICTURE_TYPE_P) {
785  for (j = n; j > 0; j--) {
786  hc = rpl0[j - 1]->priv_data;
787  av_assert0(hc->frame_num != hn->frame_num);
788  if (hc->frame_num > hn->frame_num)
789  break;
790  rpl0[j] = rpl0[j - 1];
791  }
792  rpl0[j] = prev->dpb[i];
793 
794  } else if (pic->type == PICTURE_TYPE_B) {
795  for (j = n; j > 0; j--) {
796  hc = rpl0[j - 1]->priv_data;
798  if (hc->pic_order_cnt < hp->pic_order_cnt) {
799  if (hn->pic_order_cnt > hp->pic_order_cnt ||
800  hn->pic_order_cnt < hc->pic_order_cnt)
801  break;
802  } else {
803  if (hn->pic_order_cnt > hc->pic_order_cnt)
804  break;
805  }
806  rpl0[j] = rpl0[j - 1];
807  }
808  rpl0[j] = prev->dpb[i];
809 
810  for (j = n; j > 0; j--) {
811  hc = rpl1[j - 1]->priv_data;
813  if (hc->pic_order_cnt > hp->pic_order_cnt) {
814  if (hn->pic_order_cnt < hp->pic_order_cnt ||
815  hn->pic_order_cnt > hc->pic_order_cnt)
816  break;
817  } else {
818  if (hn->pic_order_cnt < hc->pic_order_cnt)
819  break;
820  }
821  rpl1[j] = rpl1[j - 1];
822  }
823  rpl1[j] = prev->dpb[i];
824  }
825 
826  ++n;
827  }
828 
829  if (pic->type == PICTURE_TYPE_B) {
830  for (i = 0; i < n; i++) {
831  if (rpl0[i] != rpl1[i])
832  break;
833  }
834  if (i == n)
835  FFSWAP(VAAPIEncodePicture*, rpl1[0], rpl1[1]);
836  }
837 
838  if (pic->type == PICTURE_TYPE_P ||
839  pic->type == PICTURE_TYPE_B) {
840  av_log(avctx, AV_LOG_DEBUG, "Default RefPicList0 for fn=%d/poc=%d:",
841  hp->frame_num, hp->pic_order_cnt);
842  for (i = 0; i < n; i++) {
843  hn = rpl0[i]->priv_data;
844  av_log(avctx, AV_LOG_DEBUG, " fn=%d/poc=%d",
845  hn->frame_num, hn->pic_order_cnt);
846  }
847  av_log(avctx, AV_LOG_DEBUG, "\n");
848  }
849  if (pic->type == PICTURE_TYPE_B) {
850  av_log(avctx, AV_LOG_DEBUG, "Default RefPicList1 for fn=%d/poc=%d:",
851  hp->frame_num, hp->pic_order_cnt);
852  for (i = 0; i < n; i++) {
853  hn = rpl1[i]->priv_data;
854  av_log(avctx, AV_LOG_DEBUG, " fn=%d/poc=%d",
855  hn->frame_num, hn->pic_order_cnt);
856  }
857  av_log(avctx, AV_LOG_DEBUG, "\n");
858  }
859 
860  *rpl_size = n;
861 }
862 
864  VAAPIEncodePicture *pic,
865  VAAPIEncodeSlice *slice)
866 {
867  VAAPIEncodeH264Context *priv = avctx->priv_data;
868  VAAPIEncodeH264Picture *hpic = pic->priv_data;
869  VAAPIEncodePicture *prev = pic->prev;
870  H264RawSPS *sps = &priv->raw_sps;
871  H264RawPPS *pps = &priv->raw_pps;
872  H264RawSliceHeader *sh = &priv->raw_slice.header;
873  VAEncPictureParameterBufferH264 *vpic = pic->codec_picture_params;
874  VAEncSliceParameterBufferH264 *vslice = slice->codec_slice_params;
875  int i, j;
876 
877  if (pic->type == PICTURE_TYPE_IDR) {
880  } else {
883  }
884 
885  sh->first_mb_in_slice = slice->block_start;
886  sh->slice_type = hpic->slice_type;
887 
888  sh->pic_parameter_set_id = pps->pic_parameter_set_id;
889 
890  sh->frame_num = hpic->frame_num &
891  ((1 << (4 + sps->log2_max_frame_num_minus4)) - 1);
892  sh->idr_pic_id = hpic->idr_pic_id;
893  sh->pic_order_cnt_lsb = hpic->pic_order_cnt &
894  ((1 << (4 + sps->log2_max_pic_order_cnt_lsb_minus4)) - 1);
895 
897 
898  if (pic->type == PICTURE_TYPE_B)
899  sh->slice_qp_delta = priv->fixed_qp_b - (pps->pic_init_qp_minus26 + 26);
900  else if (pic->type == PICTURE_TYPE_P)
901  sh->slice_qp_delta = priv->fixed_qp_p - (pps->pic_init_qp_minus26 + 26);
902  else
903  sh->slice_qp_delta = priv->fixed_qp_idr - (pps->pic_init_qp_minus26 + 26);
904 
905  if (pic->is_reference && pic->type != PICTURE_TYPE_IDR) {
906  VAAPIEncodePicture *discard_list[MAX_DPB_SIZE];
907  int discard = 0, keep = 0;
908 
909  // Discard everything which is in the DPB of the previous frame but
910  // not in the DPB of this one.
911  for (i = 0; i < prev->nb_dpb_pics; i++) {
912  for (j = 0; j < pic->nb_dpb_pics; j++) {
913  if (prev->dpb[i] == pic->dpb[j])
914  break;
915  }
916  if (j == pic->nb_dpb_pics) {
917  discard_list[discard] = prev->dpb[i];
918  ++discard;
919  } else {
920  ++keep;
921  }
922  }
923  av_assert0(keep <= priv->dpb_frames);
924 
925  if (discard == 0) {
927  } else {
929  for (i = 0; i < discard; i++) {
930  VAAPIEncodeH264Picture *old = discard_list[i]->priv_data;
931  av_assert0(old->frame_num < hpic->frame_num);
934  hpic->frame_num - old->frame_num - 1;
935  }
937  }
938  }
939 
940  // If the intended references are not the first entries of RefPicListN
941  // by default, use ref-pic-list-modification to move them there.
942  if (pic->type == PICTURE_TYPE_P || pic->type == PICTURE_TYPE_B) {
943  VAAPIEncodePicture *def_l0[MAX_DPB_SIZE], *def_l1[MAX_DPB_SIZE];
945  int n;
946 
948  def_l0, def_l1, &n);
949 
950  if (pic->type == PICTURE_TYPE_P) {
951  int need_rplm = 0;
952  for (i = 0; i < pic->nb_refs[0]; i++) {
953  av_assert0(pic->refs[0][i]);
954  if (pic->refs[0][i] != def_l0[i])
955  need_rplm = 1;
956  }
957 
958  sh->ref_pic_list_modification_flag_l0 = need_rplm;
959  if (need_rplm) {
960  int pic_num = hpic->frame_num;
961  for (i = 0; i < pic->nb_refs[0]; i++) {
962  href = pic->refs[0][i]->priv_data;
963  av_assert0(href->frame_num != pic_num);
964  if (href->frame_num < pic_num) {
967  pic_num - href->frame_num - 1;
968  } else {
971  href->frame_num - pic_num - 1;
972  }
973  pic_num = href->frame_num;
974  }
976  }
977 
978  } else {
979  int need_rplm_l0 = 0, need_rplm_l1 = 0;
980  int n0 = 0, n1 = 0;
981  for (i = 0; i < pic->nb_refs[0]; i++) {
982  av_assert0(pic->refs[0][i]);
983  href = pic->refs[0][i]->priv_data;
984  av_assert0(href->pic_order_cnt < hpic->pic_order_cnt);
985  if (pic->refs[0][i] != def_l0[n0])
986  need_rplm_l0 = 1;
987  ++n0;
988  }
989 
990  for (i = 0; i < pic->nb_refs[1]; i++) {
991  av_assert0(pic->refs[1][i]);
992  href = pic->refs[1][i]->priv_data;
993  av_assert0(href->pic_order_cnt > hpic->pic_order_cnt);
994  if (pic->refs[1][i] != def_l1[n1])
995  need_rplm_l1 = 1;
996  ++n1;
997  }
998 
999  sh->ref_pic_list_modification_flag_l0 = need_rplm_l0;
1000  if (need_rplm_l0) {
1001  int pic_num = hpic->frame_num;
1002  for (i = j = 0; i < pic->nb_refs[0]; i++) {
1003  href = pic->refs[0][i]->priv_data;
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 == n0);
1019  }
1020 
1021  sh->ref_pic_list_modification_flag_l1 = need_rplm_l1;
1022  if (need_rplm_l1) {
1023  int pic_num = hpic->frame_num;
1024  for (i = j = 0; i < pic->nb_refs[1]; i++) {
1025  href = pic->refs[1][i]->priv_data;
1026  av_assert0(href->frame_num != pic_num);
1027  if (href->frame_num < pic_num) {
1030  pic_num - href->frame_num - 1;
1031  } else {
1034  href->frame_num - pic_num - 1;
1035  }
1036  pic_num = href->frame_num;
1037  ++j;
1038  }
1039  av_assert0(j == n1);
1041  }
1042  }
1043  }
1044 
1045  vslice->macroblock_address = slice->block_start;
1046  vslice->num_macroblocks = slice->block_size;
1047 
1048  vslice->macroblock_info = VA_INVALID_ID;
1049 
1050  vslice->slice_type = sh->slice_type % 5;
1051  vslice->pic_parameter_set_id = sh->pic_parameter_set_id;
1052  vslice->idr_pic_id = sh->idr_pic_id;
1053 
1054  vslice->pic_order_cnt_lsb = sh->pic_order_cnt_lsb;
1055 
1056  vslice->direct_spatial_mv_pred_flag = sh->direct_spatial_mv_pred_flag;
1057 
1058  for (i = 0; i < FF_ARRAY_ELEMS(vslice->RefPicList0); i++) {
1059  vslice->RefPicList0[i].picture_id = VA_INVALID_ID;
1060  vslice->RefPicList0[i].flags = VA_PICTURE_H264_INVALID;
1061  vslice->RefPicList1[i].picture_id = VA_INVALID_ID;
1062  vslice->RefPicList1[i].flags = VA_PICTURE_H264_INVALID;
1063  }
1064 
1065  if (pic->nb_refs[0]) {
1066  // Backward reference for P- or B-frame.
1067  av_assert0(pic->type == PICTURE_TYPE_P ||
1068  pic->type == PICTURE_TYPE_B);
1069  vslice->RefPicList0[0] = vpic->ReferenceFrames[0];
1070  }
1071  if (pic->nb_refs[1]) {
1072  // Forward reference for B-frame.
1073  av_assert0(pic->type == PICTURE_TYPE_B);
1074  vslice->RefPicList1[0] = vpic->ReferenceFrames[1];
1075  }
1076 
1077  vslice->slice_qp_delta = sh->slice_qp_delta;
1078 
1079  return 0;
1080 }
1081 
1083 {
1084  VAAPIEncodeContext *ctx = avctx->priv_data;
1085  VAAPIEncodeH264Context *priv = avctx->priv_data;
1086  int err;
1087 
1088  err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_H264, avctx);
1089  if (err < 0)
1090  return err;
1091 
1092  priv->mb_width = FFALIGN(avctx->width, 16) / 16;
1093  priv->mb_height = FFALIGN(avctx->height, 16) / 16;
1094 
1095  if (ctx->va_rc_mode == VA_RC_CQP) {
1096  priv->fixed_qp_p = av_clip(ctx->rc_quality, 1, 51);
1097  if (avctx->i_quant_factor > 0.0)
1098  priv->fixed_qp_idr =
1099  av_clip((avctx->i_quant_factor * priv->fixed_qp_p +
1100  avctx->i_quant_offset) + 0.5, 1, 51);
1101  else
1102  priv->fixed_qp_idr = priv->fixed_qp_p;
1103  if (avctx->b_quant_factor > 0.0)
1104  priv->fixed_qp_b =
1105  av_clip((avctx->b_quant_factor * priv->fixed_qp_p +
1106  avctx->b_quant_offset) + 0.5, 1, 51);
1107  else
1108  priv->fixed_qp_b = priv->fixed_qp_p;
1109 
1110  av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
1111  "%d / %d / %d for IDR- / P- / B-frames.\n",
1112  priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
1113 
1114  } else {
1115  // These still need to be set for pic_init_qp/slice_qp_delta.
1116  priv->fixed_qp_idr = 26;
1117  priv->fixed_qp_p = 26;
1118  priv->fixed_qp_b = 26;
1119  }
1120 
1121  if (!ctx->rc_mode->hrd) {
1122  // Timing SEI requires a mode respecting HRD parameters.
1123  priv->sei &= ~SEI_TIMING;
1124  }
1125 
1126  if (priv->sei & SEI_IDENTIFIER) {
1127  const char *lavc = LIBAVCODEC_IDENT;
1128  const char *vaapi = VA_VERSION_S;
1129  const char *driver;
1130  int len;
1131 
1132  memcpy(priv->sei_identifier.uuid_iso_iec_11578,
1134  sizeof(priv->sei_identifier.uuid_iso_iec_11578));
1135 
1136  driver = vaQueryVendorString(ctx->hwctx->display);
1137  if (!driver)
1138  driver = "unknown driver";
1139 
1140  len = snprintf(NULL, 0, "%s / VAAPI %s / %s", lavc, vaapi, driver);
1141  if (len >= 0) {
1142  priv->sei_identifier_string = av_malloc(len + 1);
1143  if (!priv->sei_identifier_string)
1144  return AVERROR(ENOMEM);
1145 
1146  snprintf(priv->sei_identifier_string, len + 1,
1147  "%s / VAAPI %s / %s", lavc, vaapi, driver);
1148 
1150  priv->sei_identifier.data_length = len + 1;
1151  }
1152  }
1153 
1154  ctx->roi_quant_range = 51 + 6 * (ctx->profile->depth - 8);
1155 
1156  return 0;
1157 }
1158 
1160 #if VA_CHECK_VERSION(1, 18, 0)
1161  { AV_PROFILE_H264_HIGH_10, 10, 3, 1, 1, VAProfileH264High10 },
1162 #endif
1163  { AV_PROFILE_H264_HIGH, 8, 3, 1, 1, VAProfileH264High },
1164  { AV_PROFILE_H264_MAIN, 8, 3, 1, 1, VAProfileH264Main },
1166  8, 3, 1, 1, VAProfileH264ConstrainedBaseline },
1167  { AV_PROFILE_UNKNOWN }
1168 };
1169 
1172 
1173  .flags = FLAG_SLICE_CONTROL |
1174  FLAG_B_PICTURES |
1177 
1178  .default_quality = 20,
1179 
1180  .configure = &vaapi_encode_h264_configure,
1181 
1182  .picture_priv_data_size = sizeof(VAAPIEncodeH264Picture),
1183 
1184  .sequence_params_size = sizeof(VAEncSequenceParameterBufferH264),
1185  .init_sequence_params = &vaapi_encode_h264_init_sequence_params,
1186 
1187  .picture_params_size = sizeof(VAEncPictureParameterBufferH264),
1188  .init_picture_params = &vaapi_encode_h264_init_picture_params,
1189 
1190  .slice_params_size = sizeof(VAEncSliceParameterBufferH264),
1191  .init_slice_params = &vaapi_encode_h264_init_slice_params,
1192 
1193  .sequence_header_type = VAEncPackedHeaderSequence,
1194  .write_sequence_header = &vaapi_encode_h264_write_sequence_header,
1195 
1196  .slice_header_type = VAEncPackedHeaderH264_Slice,
1197  .write_slice_header = &vaapi_encode_h264_write_slice_header,
1198 
1199  .write_extra_header = &vaapi_encode_h264_write_extra_header,
1200 };
1201 
1203 {
1204  VAAPIEncodeContext *ctx = avctx->priv_data;
1205  VAAPIEncodeH264Context *priv = avctx->priv_data;
1206 
1207  ctx->codec = &vaapi_encode_type_h264;
1208 
1209  if (avctx->profile == AV_PROFILE_UNKNOWN)
1210  avctx->profile = priv->profile;
1211  if (avctx->level == AV_LEVEL_UNKNOWN)
1212  avctx->level = priv->level;
1214  avctx->compression_level = priv->quality;
1215 
1216  // Reject unsupported profiles.
1217  switch (avctx->profile) {
1219  av_log(avctx, AV_LOG_WARNING, "H.264 baseline profile is not "
1220  "supported, using constrained baseline profile instead.\n");
1222  break;
1224  av_log(avctx, AV_LOG_ERROR, "H.264 extended profile "
1225  "is not supported.\n");
1226  return AVERROR_PATCHWELCOME;
1228  av_log(avctx, AV_LOG_ERROR, "H.264 high 10 intra profile "
1229  "is not supported.\n");
1230  return AVERROR_PATCHWELCOME;
1237  av_log(avctx, AV_LOG_ERROR, "H.264 non-4:2:0 profiles "
1238  "are not supported.\n");
1239  return AVERROR_PATCHWELCOME;
1240  }
1241 
1242  if (avctx->level != AV_LEVEL_UNKNOWN && avctx->level & ~0xff) {
1243  av_log(avctx, AV_LOG_ERROR, "Invalid level %d: must fit "
1244  "in 8-bit unsigned integer.\n", avctx->level);
1245  return AVERROR(EINVAL);
1246  }
1247 
1248  ctx->desired_packed_headers =
1249  VA_ENC_PACKED_HEADER_SEQUENCE | // SPS and PPS.
1250  VA_ENC_PACKED_HEADER_SLICE | // Slice headers.
1251  VA_ENC_PACKED_HEADER_MISC; // SEI.
1252 
1253  ctx->surface_width = FFALIGN(avctx->width, 16);
1254  ctx->surface_height = FFALIGN(avctx->height, 16);
1255 
1256  ctx->slice_block_height = ctx->slice_block_width = 16;
1257 
1258  if (priv->qp > 0)
1259  ctx->explicit_qp = priv->qp;
1260 
1261  return ff_vaapi_encode_init(avctx);
1262 }
1263 
1265 {
1266  VAAPIEncodeH264Context *priv = avctx->priv_data;
1267 
1269  ff_cbs_close(&priv->cbc);
1271  av_freep(&priv->sei_a53cc_data);
1272 
1273  return ff_vaapi_encode_close(avctx);
1274 }
1275 
1276 #define OFFSET(x) offsetof(VAAPIEncodeH264Context, x)
1277 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
1281 
1282  { "qp", "Constant QP (for P-frames; scaled by qfactor/qoffset for I/B)",
1283  OFFSET(qp), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 52, FLAGS },
1284  { "quality", "Set encode quality (trades off against speed, higher is faster)",
1285  OFFSET(quality), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
1286  { "coder", "Entropy coder type",
1287  OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, FLAGS, .unit = "coder" },
1288  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, FLAGS, .unit = "coder" },
1289  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, FLAGS, .unit = "coder" },
1290  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, FLAGS, .unit = "coder" },
1291  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, FLAGS, .unit = "coder" },
1292 
1293  { "aud", "Include AUD",
1294  OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
1295 
1296  { "sei", "Set SEI to include",
1299  0, INT_MAX, FLAGS, .unit = "sei" },
1300  { "identifier", "Include encoder version identifier",
1301  0, AV_OPT_TYPE_CONST, { .i64 = SEI_IDENTIFIER },
1302  INT_MIN, INT_MAX, FLAGS, .unit = "sei" },
1303  { "timing", "Include timing parameters (buffering_period and pic_timing)",
1304  0, AV_OPT_TYPE_CONST, { .i64 = SEI_TIMING },
1305  INT_MIN, INT_MAX, FLAGS, .unit = "sei" },
1306  { "recovery_point", "Include recovery points where appropriate",
1307  0, AV_OPT_TYPE_CONST, { .i64 = SEI_RECOVERY_POINT },
1308  INT_MIN, INT_MAX, FLAGS, .unit = "sei" },
1309  { "a53_cc", "Include A/53 caption data",
1310  0, AV_OPT_TYPE_CONST, { .i64 = SEI_A53_CC },
1311  INT_MIN, INT_MAX, FLAGS, .unit = "sei" },
1312 
1313  { "profile", "Set profile (profile_idc and constraint_set*_flag)",
1315  { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, 0xffff, FLAGS, .unit = "profile" },
1316 
1317 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1318  { .i64 = value }, 0, 0, FLAGS, .unit = "profile"
1319  { PROFILE("constrained_baseline", AV_PROFILE_H264_CONSTRAINED_BASELINE) },
1320  { PROFILE("main", AV_PROFILE_H264_MAIN) },
1321  { PROFILE("high", AV_PROFILE_H264_HIGH) },
1322  { PROFILE("high10", AV_PROFILE_H264_HIGH_10) },
1323 #undef PROFILE
1324 
1325  { "level", "Set level (level_idc)",
1327  { .i64 = AV_LEVEL_UNKNOWN }, AV_LEVEL_UNKNOWN, 0xff, FLAGS, .unit = "level" },
1328 
1329 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1330  { .i64 = value }, 0, 0, FLAGS, .unit = "level"
1331  { LEVEL("1", 10) },
1332  { LEVEL("1.1", 11) },
1333  { LEVEL("1.2", 12) },
1334  { LEVEL("1.3", 13) },
1335  { LEVEL("2", 20) },
1336  { LEVEL("2.1", 21) },
1337  { LEVEL("2.2", 22) },
1338  { LEVEL("3", 30) },
1339  { LEVEL("3.1", 31) },
1340  { LEVEL("3.2", 32) },
1341  { LEVEL("4", 40) },
1342  { LEVEL("4.1", 41) },
1343  { LEVEL("4.2", 42) },
1344  { LEVEL("5", 50) },
1345  { LEVEL("5.1", 51) },
1346  { LEVEL("5.2", 52) },
1347  { LEVEL("6", 60) },
1348  { LEVEL("6.1", 61) },
1349  { LEVEL("6.2", 62) },
1350 #undef LEVEL
1351 
1352  { NULL },
1353 };
1354 
1356  { "b", "0" },
1357  { "bf", "2" },
1358  { "g", "120" },
1359  { "i_qfactor", "1" },
1360  { "i_qoffset", "0" },
1361  { "b_qfactor", "6/5" },
1362  { "b_qoffset", "0" },
1363  { "qmin", "-1" },
1364  { "qmax", "-1" },
1365  { NULL },
1366 };
1367 
1369  .class_name = "h264_vaapi",
1370  .item_name = av_default_item_name,
1371  .option = vaapi_encode_h264_options,
1372  .version = LIBAVUTIL_VERSION_INT,
1373 };
1374 
1376  .p.name = "h264_vaapi",
1377  CODEC_LONG_NAME("H.264/AVC (VAAPI)"),
1378  .p.type = AVMEDIA_TYPE_VIDEO,
1379  .p.id = AV_CODEC_ID_H264,
1380  .priv_data_size = sizeof(VAAPIEncodeH264Context),
1383  .close = &vaapi_encode_h264_close,
1384  .p.priv_class = &vaapi_encode_h264_class,
1385  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE |
1387  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
1389  .defaults = vaapi_encode_h264_defaults,
1390  .p.pix_fmts = (const enum AVPixelFormat[]) {
1393  },
1394  .hw_configs = ff_vaapi_encode_hw_configs,
1395  .p.wrapper_name = "vaapi",
1396 };
FLAGS
#define FLAGS
Definition: vaapi_encode_h264.c:1277
VAAPIEncodeH264Context::sei_identifier_string
char * sei_identifier_string
Definition: vaapi_encode_h264.c:103
ff_alloc_a53_sei
int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len, void **data, size_t *sei_size)
Check AVFrame for A53 side data and allocate and fill SEI message with A53 info.
Definition: atsc_a53.c:26
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
VAAPIEncodeSlice::codec_slice_params
void * codec_slice_params
Definition: vaapi_encode.h:70
OFFSET
#define OFFSET(x)
Definition: vaapi_encode_h264.c:1276
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
FLAG_B_PICTURE_REFERENCES
@ FLAG_B_PICTURE_REFERENCES
Definition: vaapi_encode.h:410
level
uint8_t level
Definition: svq3.c:205
AV_PROFILE_H264_HIGH_10_INTRA
#define AV_PROFILE_H264_HIGH_10_INTRA
Definition: defs.h:116
av_clip
#define av_clip
Definition: common.h:100
H264RawSliceHeader::mmco
struct H264RawSliceHeader::@69 mmco[H264_MAX_MMCO_COUNT]
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
LIBAVCODEC_IDENT
#define LIBAVCODEC_IDENT
Definition: version.h:43
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
SEIRawUserDataRegistered
Definition: cbs_sei.h:33
VAAPIEncodeH264Picture
Definition: vaapi_encode_h264.c:54
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
h264_levels.h
ff_cbs_fragment_free
av_cold void ff_cbs_fragment_free(CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:186
PICTURE_TYPE_IDR
@ PICTURE_TYPE_IDR
Definition: vaapi_encode.h:58
PICTURE_TYPE_P
@ PICTURE_TYPE_P
Definition: vaapi_encode.h:60
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_CODEC_CAP_HARDWARE
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:145
PICTURE_TYPE_I
@ PICTURE_TYPE_I
Definition: vaapi_encode.h:59
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:124
AV_PROFILE_H264_MAIN
#define AV_PROFILE_H264_MAIN
Definition: defs.h:112
ff_cbs_sei_add_message
int ff_cbs_sei_add_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, int prefix, uint32_t payload_type, void *payload_data, void *payload_ref)
Add an SEI message to an access unit.
Definition: cbs_sei.c:269
cbs_h264.h
dpb_frames
int dpb_frames
Definition: h264_levels.c:163
ff_cbs_insert_unit_content
int ff_cbs_insert_unit_content(CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, void *content_ref)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:783
vaapi_encode_h264_sei_identifier_uuid
static const uint8_t vaapi_encode_h264_sei_identifier_uuid[16]
Definition: vaapi_encode_h264.c:49
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:686
ff_cbs_fragment_reset
void ff_cbs_fragment_reset(CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment's own data buffer, but not the units a...
Definition: cbs.c:172
vaapi_encode_h264_class
static const AVClass vaapi_encode_h264_class
Definition: vaapi_encode_h264.c:1368
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:219
VAAPIEncodeSlice
Definition: vaapi_encode.h:64
H264RawHRD::dpb_output_delay_length_minus1
uint8_t dpb_output_delay_length_minus1
Definition: cbs_h264.h:54
VAAPIEncodeH264Context::aud
int aud
Definition: vaapi_encode_h264.c:75
AVOption
AVOption.
Definition: opt.h:357
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
data
const char data[16]
Definition: mxf.c:148
H264RawHRD
Definition: cbs_h264.h:43
SEI_IDENTIFIER
@ SEI_IDENTIFIER
Definition: vaapi_encode_h264.c:43
AVCodecContext::b_quant_offset
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:811
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
VAAPIEncodeSlice::block_start
int block_start
Definition: vaapi_encode.h:68
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:34
VAAPIEncodeH264Context::sei_a53cc
SEIRawUserDataRegistered sei_a53cc
Definition: vaapi_encode_h264.c:104
FFCodec
Definition: codec_internal.h:126
vaapi_encode_h264_init_picture_params
static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, VAAPIEncodePicture *pic)
Definition: vaapi_encode_h264.c:621
version.h
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
VAAPIEncodeH264Context::sei_recovery_point
H264RawSEIRecoveryPoint sei_recovery_point
Definition: vaapi_encode_h264.c:101
ff_vaapi_encode_close
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
Definition: vaapi_encode.c:2983
cbs.h
H264LevelDescriptor
Definition: h264_levels.h:25
VAAPIEncodeH264Context::mb_height
int mb_height
Definition: vaapi_encode_h264.c:82
FF_COMPRESSION_DEFAULT
#define FF_COMPRESSION_DEFAULT
Definition: avcodec.h:1246
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:246
H264RawHRD::cpb_size_scale
uint8_t cpb_size_scale
Definition: cbs_h264.h:46
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
H264RawSliceHeader::nal_unit_header
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:311
ff_cbs_close
av_cold void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:142
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
H264RawSliceHeader::direct_spatial_mv_pred_flag
uint8_t direct_spatial_mv_pred_flag
Definition: cbs_h264.h:331
VAAPIEncodePicture::refs
struct VAAPIEncodePicture * refs[MAX_REFERENCE_LIST_NUM][MAX_PICTURE_REFERENCES]
Definition: vaapi_encode.h:125
AV_PROFILE_H264_EXTENDED
#define AV_PROFILE_H264_EXTENDED
Definition: defs.h:113
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
H264RawSEIRecoveryPoint::recovery_frame_cnt
uint16_t recovery_frame_cnt
Definition: cbs_h264.h:269
VAAPIEncodePicture::nb_refs
int nb_refs[MAX_REFERENCE_LIST_NUM]
Definition: vaapi_encode.h:124
VAAPIEncodeH264Context::level
int level
Definition: vaapi_encode_h264.c:78
H264RawHRD::bit_rate_scale
uint8_t bit_rate_scale
Definition: cbs_h264.h:45
H264RawSEIPicTiming
Definition: cbs_h264.h:249
AVCodecContext::i_quant_factor
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
Definition: avcodec.h:820
FFCodecDefault
Definition: codec_internal.h:96
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
VAAPIEncodeH264Picture::pic_order_cnt
int pic_order_cnt
Definition: vaapi_encode_h264.c:56
ff_h264_guess_level
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:79
vaapi_encode.h
SEIRawUserDataUnregistered::data
uint8_t * data
RefStruct reference.
Definition: cbs_sei.h:42
fail
#define fail()
Definition: checkasm.h:184
H264RawHRD::cpb_size_value_minus1
uint32_t cpb_size_value_minus1[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:49
VAAPIEncodePicture
Definition: vaapi_encode.h:73
VAAPIEncodeH264Context
Definition: vaapi_encode_h264.c:68
SEIRawUserDataUnregistered
Definition: cbs_sei.h:40
SEI_A53_CC
@ SEI_A53_CC
Definition: vaapi_encode_h264.c:45
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
H264RawSliceHeader::pic_order_cnt_lsb
uint16_t pic_order_cnt_lsb
Definition: cbs_h264.h:326
H264RawSEIBufferingPeriod::nal
struct H264RawSEIBufferingPeriod::@67 nal
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
AVRational::num
int num
Numerator.
Definition: rational.h:59
avassert.h
H264RawSliceHeader::first_mb_in_slice
uint32_t first_mb_in_slice
Definition: cbs_h264.h:313
SEIRawUserDataRegistered::itu_t_t35_country_code
uint8_t itu_t_t35_country_code
Definition: cbs_sei.h:34
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
FLAG_NON_IDR_KEY_PICTURES
@ FLAG_NON_IDR_KEY_PICTURES
Definition: vaapi_encode.h:413
LEVEL
#define LEVEL(name, value)
VAAPIEncodePicture::codec_picture_params
void * codec_picture_params
Definition: vaapi_encode.h:111
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:122
H264RawSEIBufferingPeriod::initial_cpb_removal_delay
uint32_t initial_cpb_removal_delay[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:227
FLAG_SLICE_CONTROL
@ FLAG_SLICE_CONTROL
Definition: vaapi_encode.h:402
vaapi_encode_h264_init
static av_cold int vaapi_encode_h264_init(AVCodecContext *avctx)
Definition: vaapi_encode_h264.c:1202
VAAPIEncodeH264Context::fixed_qp_idr
int fixed_qp_idr
Definition: vaapi_encode_h264.c:84
H264RawSliceHeader::slice_qp_delta
int8_t slice_qp_delta
Definition: cbs_h264.h:376
CodedBitstreamFragment::data_size
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:135
VAAPIEncodeH264Context::quality
int quality
Definition: vaapi_encode_h264.c:73
H264RawNALUnitHeader::nal_unit_type
uint8_t nal_unit_type
Definition: cbs_h264.h:33
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
H264RawSliceHeader::rplm_l0
struct H264RawSliceHeader::@68 rplm_l0[H264_MAX_RPLM_COUNT]
AV_PROFILE_H264_HIGH_10
#define AV_PROFILE_H264_HIGH_10
Definition: defs.h:115
H264RawSliceHeader::frame_num
uint16_t frame_num
Definition: cbs_h264.h:320
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
H264RawAUD::nal_unit_header
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:219
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
SEIRawUserDataUnregistered::data_length
size_t data_length
Definition: cbs_sei.h:43
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
VAAPIEncodeH264Picture::cpb_delay
int cpb_delay
Definition: vaapi_encode_h264.c:64
ctx
AVFormatContext * ctx
Definition: movenc.c:49
vaapi_encode_h264_write_extra_header
static int vaapi_encode_h264_write_extra_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, int index, int *type, char *data, size_t *data_len)
Definition: vaapi_encode_h264.c:211
SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
@ SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
Definition: sei.h:34
vaapi_encode_h264_options
static const AVOption vaapi_encode_h264_options[]
Definition: vaapi_encode_h264.c:1278
AV_PROFILE_H264_HIGH_422_INTRA
#define AV_PROFILE_H264_HIGH_422_INTRA
Definition: defs.h:119
ff_vaapi_encode_receive_packet
int ff_vaapi_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: vaapi_encode.c:1397
VAAPIEncodeH264Context::fixed_qp_b
int fixed_qp_b
Definition: vaapi_encode_h264.c:86
VAAPIEncodeH264Context::sei_pic_timing
H264RawSEIPicTiming sei_pic_timing
Definition: vaapi_encode_h264.c:100
CodedBitstreamFragment::data_bit_padding
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:139
VAAPIEncodeH264Context::coder
int coder
Definition: vaapi_encode_h264.c:74
h2645data.h
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
VAAPIEncodeType
Definition: vaapi_encode.h:419
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
AV_PROFILE_H264_HIGH_422
#define AV_PROFILE_H264_HIGH_422
Definition: defs.h:118
H264RawSliceHeader::adaptive_ref_pic_marking_mode_flag
uint8_t adaptive_ref_pic_marking_mode_flag
Definition: cbs_h264.h:365
VAAPIEncodeContext
Definition: vaapi_encode.h:195
VAAPIEncodePicture::prev
struct VAAPIEncodePicture * prev
Definition: vaapi_encode.h:128
framerate
float framerate
Definition: av1_levels.c:29
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
VAAPIEncodeH264Context::cbc
CodedBitstreamContext * cbc
Definition: vaapi_encode_h264.c:91
VAAPIEncodeH264Picture::dpb_delay
int dpb_delay
Definition: vaapi_encode_h264.c:65
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:210
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
VAAPIEncodeH264Context::sei
int sei
Definition: vaapi_encode_h264.c:76
VAAPIEncodePicture::dpb
struct VAAPIEncodePicture * dpb[MAX_DPB_SIZE]
Definition: vaapi_encode.h:120
AV_LEVEL_UNKNOWN
#define AV_LEVEL_UNKNOWN
Definition: defs.h:197
VAAPIEncodeType::profiles
const VAAPIEncodeProfile * profiles
Definition: vaapi_encode.h:422
FF_CODEC_RECEIVE_PACKET_CB
#define FF_CODEC_RECEIVE_PACKET_CB(func)
Definition: codec_internal.h:301
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
H264RawNALUnitHeader
Definition: cbs_h264.h:31
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
VAAPIEncodeH264Context::raw_slice
H264RawSlice raw_slice
Definition: vaapi_encode_h264.c:97
VAAPIEncodeH264Context::fixed_qp_p
int fixed_qp_p
Definition: vaapi_encode_h264.c:85
SEI_TIMING
@ SEI_TIMING
Definition: vaapi_encode_h264.c:42
vaapi_encode_h264_profiles
static const VAAPIEncodeProfile vaapi_encode_h264_profiles[]
Definition: vaapi_encode_h264.c:1159
vaapi_encode_h264_add_nal
static int vaapi_encode_h264_add_nal(AVCodecContext *avctx, CodedBitstreamFragment *au, void *nal_unit)
Definition: vaapi_encode_h264.c:139
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:824
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1784
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:652
index
int index
Definition: gxfenc.c:90
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:544
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:841
VAAPIEncodeH264Context::raw_sps
H264RawSPS raw_sps
Definition: vaapi_encode_h264.c:95
vaapi_encode_h264_write_access_unit
static int vaapi_encode_h264_write_access_unit(AVCodecContext *avctx, char *data, size_t *data_len, CodedBitstreamFragment *au)
Definition: vaapi_encode_h264.c:113
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
H264RawSliceHeader::difference_of_pic_nums_minus1
int32_t difference_of_pic_nums_minus1
Definition: cbs_h264.h:368
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
VAAPIEncodePicture::type
int type
Definition: vaapi_encode.h:92
hn
static float hn(int n, EqParameter *param, float fs)
Definition: af_superequalizer.c:92
codec_internal.h
H264RawNALUnitHeader::nal_ref_idc
uint8_t nal_ref_idc
Definition: cbs_h264.h:32
VAAPI_ENCODE_RC_OPTIONS
#define VAAPI_ENCODE_RC_OPTIONS
Definition: vaapi_encode.h:532
H264RawSliceHeader::slice_type
uint8_t slice_type
Definition: cbs_h264.h:314
AV_PROFILE_H264_CAVLC_444
#define AV_PROFILE_H264_CAVLC_444
Definition: defs.h:124
SEIRawUserDataRegistered::data
uint8_t * data
RefStruct reference.
Definition: cbs_sei.h:36
vaapi_encode_h264_init_sequence_params
static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
Definition: vaapi_encode_h264.c:296
CodedBitstreamFragment::data
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:128
vaapi_encode_h264_write_slice_header
static int vaapi_encode_h264_write_slice_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice, char *data, size_t *data_len)
Definition: vaapi_encode_h264.c:185
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:706
VAAPIEncodeH264Context::mb_width
int mb_width
Definition: vaapi_encode_h264.c:81
VAAPIEncodeH264Context::common
VAAPIEncodeContext common
Definition: vaapi_encode_h264.c:69
header
static const uint8_t header[24]
Definition: sdr2.c:68
vaapi_encode_h264_init_slice_params
static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice)
Definition: vaapi_encode_h264.c:863
VAAPI_ENCODE_COMMON_OPTIONS
#define VAAPI_ENCODE_COMMON_OPTIONS
Definition: vaapi_encode.h:505
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
VAAPIEncodePicture::recon_surface
VASurfaceID recon_surface
Definition: vaapi_encode.h:101
MAX_REFERENCE_LIST_NUM
@ MAX_REFERENCE_LIST_NUM
Definition: vaapi_encode.h:52
VAAPIEncodePicture::output_buffer
VABufferID output_buffer
Definition: vaapi_encode.h:108
VAAPIEncodePicture::priv_data
void * priv_data
Definition: vaapi_encode.h:110
SEIRawUserDataRegistered::data_length
size_t data_length
Definition: cbs_sei.h:37
VAAPIEncodePicture::display_order
int64_t display_order
Definition: vaapi_encode.h:76
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
VAAPIEncodePicture::nb_dpb_pics
int nb_dpb_pics
Definition: vaapi_encode.h:119
vaapi_encode_h264_write_sequence_header
static int vaapi_encode_h264_write_sequence_header(AVCodecContext *avctx, char *data, size_t *data_len)
Definition: vaapi_encode_h264.c:157
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
AVCodecContext::b_quant_factor
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
Definition: avcodec.h:804
VAAPIEncodeH264Picture::slice_type
int slice_type
Definition: vaapi_encode_h264.c:62
H264RawSliceHeader
Definition: cbs_h264.h:310
H264RawSEIBufferingPeriod::initial_cpb_removal_delay_offset
uint32_t initial_cpb_removal_delay_offset[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:228
H264RawSlice::header
H264RawSliceHeader header
Definition: cbs_h264.h:389
H264RawSliceHeader::idr_pic_id
uint16_t idr_pic_id
Definition: cbs_h264.h:324
H264RawHRD::cpb_cnt_minus1
uint8_t cpb_cnt_minus1
Definition: cbs_h264.h:44
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
VAAPIEncodeH264Context::raw_aud
H264RawAUD raw_aud
Definition: vaapi_encode_h264.c:94
VAAPIEncodeH264Context::aud_needed
int aud_needed
Definition: vaapi_encode_h264.c:107
H264RawHRD::cbr_flag
uint8_t cbr_flag[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:50
VAAPIEncodeContext::input_frames
AVHWFramesContext * input_frames
Definition: vaapi_encode.h:275
common.h
VAAPIEncodeH264Context::sei_needed
int sei_needed
Definition: vaapi_encode_h264.c:108
SEI_TYPE_PIC_TIMING
@ SEI_TYPE_PIC_TIMING
Definition: sei.h:31
VAAPIEncodeH264Context::sei_a53cc_data
void * sei_a53cc_data
Definition: vaapi_encode_h264.c:105
VAAPIEncodeH264Context::sei_cbr_workaround_needed
int sei_cbr_workaround_needed
Definition: vaapi_encode_h264.c:109
vaapi_encode_h264_close
static av_cold int vaapi_encode_h264_close(AVCodecContext *avctx)
Definition: vaapi_encode_h264.c:1264
H264RawSPS::pic_order_cnt_type
uint8_t pic_order_cnt_type
Definition: cbs_h264.h:129
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
ff_h2645_pixel_aspect
const AVRational ff_h2645_pixel_aspect[]
Definition: h2645data.c:21
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:702
len
int len
Definition: vorbis_enc_data.h:426
profile
int profile
Definition: mxfenc.c:2227
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
H264RawSliceHeader::ref_pic_list_modification_flag_l0
uint8_t ref_pic_list_modification_flag_l0
Definition: cbs_h264.h:337
AVCodecContext::height
int height
Definition: avcodec.h:618
VAAPIEncodeH264Context::qp
int qp
Definition: vaapi_encode_h264.c:72
ff_cbs_write_fragment_data
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:409
VAAPIEncodeH264Picture::primary_pic_type
int primary_pic_type
Definition: vaapi_encode_h264.c:61
H264RawSliceHeader::rplm_l1
struct H264RawSliceHeader::@68 rplm_l1[H264_MAX_RPLM_COUNT]
MAX_DPB_SIZE
@ MAX_DPB_SIZE
Definition: vaapi_encode.h:43
avcodec.h
H264RawSliceHeader::memory_management_control_operation
uint8_t memory_management_control_operation
Definition: cbs_h264.h:367
ff_vaapi_encode_hw_configs
const AVCodecHWConfigInternal *const ff_vaapi_encode_hw_configs[]
Definition: vaapi_encode.c:36
AV_PROFILE_H264_HIGH_444_PREDICTIVE
#define AV_PROFILE_H264_HIGH_444_PREDICTIVE
Definition: defs.h:122
ff_vaapi_encode_init
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
Definition: vaapi_encode.c:2774
VAAPIEncodeH264Context::dpb_frames
int dpb_frames
Definition: vaapi_encode_h264.c:88
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
VAAPIEncodeH264Context::sei_identifier
SEIRawUserDataUnregistered sei_identifier
Definition: vaapi_encode_h264.c:102
VAAPIEncodeH264Picture::frame_num
int frame_num
Definition: vaapi_encode_h264.c:55
VAAPIEncodeH264Picture::idr_pic_id
uint16_t idr_pic_id
Definition: vaapi_encode_h264.c:59
atsc_a53.h
VAAPIEncodeH264Picture::last_idr_frame
int64_t last_idr_frame
Definition: vaapi_encode_h264.c:58
AV_PROFILE_H264_BASELINE
#define AV_PROFILE_H264_BASELINE
Definition: defs.h:110
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
H264RawSEIBufferingPeriod::seq_parameter_set_id
uint8_t seq_parameter_set_id
Definition: cbs_h264.h:225
H264RawHRD::bit_rate_value_minus1
uint32_t bit_rate_value_minus1[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:48
ff_h264_vaapi_encoder
const FFCodec ff_h264_vaapi_encoder
Definition: vaapi_encode_h264.c:1375
H264RawHRD::cpb_removal_delay_length_minus1
uint8_t cpb_removal_delay_length_minus1
Definition: cbs_h264.h:53
VAAPIEncodeH264Context::current_access_unit
CodedBitstreamFragment current_access_unit
Definition: vaapi_encode_h264.c:92
AVCodecContext
main external API structure.
Definition: avcodec.h:445
H264RawAUD
Definition: cbs_h264.h:218
AV_PROFILE_H264_HIGH
#define AV_PROFILE_H264_HIGH
Definition: defs.h:114
VAAPIEncodeH264Context::raw_pps
H264RawPPS raw_pps
Definition: vaapi_encode_h264.c:96
SEI_TYPE_BUFFERING_PERIOD
@ SEI_TYPE_BUFFERING_PERIOD
Definition: sei.h:30
SEI_TYPE_USER_DATA_UNREGISTERED
@ SEI_TYPE_USER_DATA_UNREGISTERED
Definition: sei.h:35
AVRational::den
int den
Denominator.
Definition: rational.h:60
VAAPIEncodePicture::is_reference
int is_reference
Definition: vaapi_encode.h:114
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1640
AVCodecContext::i_quant_offset
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:827
H264RawSliceHeader::ref_pic_list_modification_flag_l1
uint8_t ref_pic_list_modification_flag_l1
Definition: cbs_h264.h:338
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
AV_PROFILE_H264_CONSTRAINED_BASELINE
#define AV_PROFILE_H264_CONSTRAINED_BASELINE
Definition: defs.h:111
FLAG_B_PICTURES
@ FLAG_B_PICTURES
Definition: vaapi_encode.h:408
SEI_TYPE_RECOVERY_POINT
@ SEI_TYPE_RECOVERY_POINT
Definition: sei.h:36
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
VAAPIEncodeH264Context::sei_buffering_period
H264RawSEIBufferingPeriod sei_buffering_period
Definition: vaapi_encode_h264.c:99
AV_PROFILE_H264_HIGH_444
#define AV_PROFILE_H264_HIGH_444
Definition: defs.h:121
H264RawSEIRecoveryPoint
Definition: cbs_h264.h:268
mem.h
AV_PROFILE_H264_HIGH_444_INTRA
#define AV_PROFILE_H264_HIGH_444_INTRA
Definition: defs.h:123
H264RawSEIPicTiming::cpb_removal_delay
uint32_t cpb_removal_delay
Definition: cbs_h264.h:250
vaapi_encode_type_h264
static const VAAPIEncodeType vaapi_encode_type_h264
Definition: vaapi_encode_h264.c:1170
vaapi_encode_h264_configure
static av_cold int vaapi_encode_h264_configure(AVCodecContext *avctx)
Definition: vaapi_encode_h264.c:1082
VAAPIEncodePicture::input_image
AVFrame * input_image
Definition: vaapi_encode.h:97
VAAPIEncodeSlice::block_size
int block_size
Definition: vaapi_encode.h:69
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
ff_cbs_init
av_cold int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:90
H264RawSliceHeader::modification_of_pic_nums_idc
uint8_t modification_of_pic_nums_idc
Definition: cbs_h264.h:340
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
PICTURE_TYPE_B
@ PICTURE_TYPE_B
Definition: vaapi_encode.h:61
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
VAAPIEncodePicture::encode_order
int64_t encode_order
Definition: vaapi_encode.h:77
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
vaapi_encode_h264_defaults
static const FFCodecDefault vaapi_encode_h264_defaults[]
Definition: vaapi_encode_h264.c:1355
SEI_RECOVERY_POINT
@ SEI_RECOVERY_POINT
Definition: vaapi_encode_h264.c:44
PROFILE
#define PROFILE(name, value)
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:244
h264.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SEIRawUserDataUnregistered::uuid_iso_iec_11578
uint8_t uuid_iso_iec_11578[16]
Definition: cbs_sei.h:41
H264RawHRD::initial_cpb_removal_delay_length_minus1
uint8_t initial_cpb_removal_delay_length_minus1
Definition: cbs_h264.h:52
H264RawSEIBufferingPeriod
Definition: cbs_h264.h:224
VAAPIEncodeH264Context::profile
int profile
Definition: vaapi_encode_h264.c:77
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
snprintf
#define snprintf
Definition: snprintf.h:34
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
H264RawSliceHeader::pic_parameter_set_id
uint8_t pic_parameter_set_id
Definition: cbs_h264.h:316
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:642
VAAPIEncodeProfile
Definition: vaapi_encode.h:150
H264RawSliceHeader::abs_diff_pic_num_minus1
int32_t abs_diff_pic_num_minus1
Definition: cbs_h264.h:341
AVCodecContext::compression_level
int compression_level
Definition: avcodec.h:1245
H264RawSlice
Definition: cbs_h264.h:388
H264RawHRD::time_offset_length
uint8_t time_offset_length
Definition: cbs_h264.h:55
vaapi_encode_h264_default_ref_pic_list
static void vaapi_encode_h264_default_ref_pic_list(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodePicture **rpl0, VAAPIEncodePicture **rpl1, int *rpl_size)
Definition: vaapi_encode_h264.c:766
H264RawSPS
Definition: cbs_h264.h:102
H264RawPPS
Definition: cbs_h264.h:171