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