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 "atsc_a53.h"
30 #include "avcodec.h"
31 #include "cbs.h"
32 #include "cbs_h264.h"
33 #include "codec_internal.h"
34 #include "h264.h"
35 #include "h264_levels.h"
36 #include "h264_sei.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 
305  memset(sps, 0, sizeof(*sps));
306  memset(pps, 0, sizeof(*pps));
307 
308  sps->nal_unit_header.nal_ref_idc = 3;
309  sps->nal_unit_header.nal_unit_type = H264_NAL_SPS;
310 
311  sps->profile_idc = avctx->profile & 0xff;
312 
314  avctx->profile == FF_PROFILE_H264_MAIN)
315  sps->constraint_set1_flag = 1;
316 
317  if (avctx->profile == FF_PROFILE_H264_HIGH)
318  sps->constraint_set3_flag = ctx->gop_size == 1;
319 
320  if (avctx->profile == FF_PROFILE_H264_MAIN ||
321  avctx->profile == FF_PROFILE_H264_HIGH) {
322  sps->constraint_set4_flag = 1;
323  sps->constraint_set5_flag = ctx->b_per_p == 0;
324  }
325 
326  if (ctx->gop_size == 1)
327  priv->dpb_frames = 0;
328  else
329  priv->dpb_frames = 1 + ctx->max_b_depth;
330 
331  if (avctx->level != FF_LEVEL_UNKNOWN) {
332  sps->level_idc = avctx->level;
333  } else {
334  const H264LevelDescriptor *level;
335  int framerate;
336 
337  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
338  framerate = avctx->framerate.num / avctx->framerate.den;
339  else
340  framerate = 0;
341 
342  level = ff_h264_guess_level(sps->profile_idc,
343  avctx->bit_rate,
344  framerate,
345  priv->mb_width * 16,
346  priv->mb_height * 16,
347  priv->dpb_frames);
348  if (level) {
349  av_log(avctx, AV_LOG_VERBOSE, "Using level %s.\n", level->name);
350  if (level->constraint_set3_flag)
351  sps->constraint_set3_flag = 1;
352  sps->level_idc = level->level_idc;
353  } else {
354  av_log(avctx, AV_LOG_WARNING, "Stream will not conform "
355  "to any level: using level 6.2.\n");
356  sps->level_idc = 62;
357  }
358  }
359 
360  sps->seq_parameter_set_id = 0;
361  sps->chroma_format_idc = 1;
362 
363  sps->log2_max_frame_num_minus4 = 4;
364  sps->pic_order_cnt_type = ctx->max_b_depth ? 0 : 2;
365  if (sps->pic_order_cnt_type == 0) {
366  sps->log2_max_pic_order_cnt_lsb_minus4 = 4;
367  }
368 
369  sps->max_num_ref_frames = priv->dpb_frames;
370 
371  sps->pic_width_in_mbs_minus1 = priv->mb_width - 1;
372  sps->pic_height_in_map_units_minus1 = priv->mb_height - 1;
373 
374  sps->frame_mbs_only_flag = 1;
375  sps->direct_8x8_inference_flag = 1;
376 
377  if (avctx->width != 16 * priv->mb_width ||
378  avctx->height != 16 * priv->mb_height) {
379  sps->frame_cropping_flag = 1;
380 
381  sps->frame_crop_left_offset = 0;
382  sps->frame_crop_right_offset =
383  (16 * priv->mb_width - avctx->width) / 2;
384  sps->frame_crop_top_offset = 0;
385  sps->frame_crop_bottom_offset =
386  (16 * priv->mb_height - avctx->height) / 2;
387  } else {
388  sps->frame_cropping_flag = 0;
389  }
390 
391  sps->vui_parameters_present_flag = 1;
392 
393  if (avctx->sample_aspect_ratio.num != 0 &&
394  avctx->sample_aspect_ratio.den != 0) {
395  int num, den, i;
396  av_reduce(&num, &den, avctx->sample_aspect_ratio.num,
397  avctx->sample_aspect_ratio.den, 65535);
398  for (i = 0; i < FF_ARRAY_ELEMS(ff_h2645_pixel_aspect); i++) {
399  if (num == ff_h2645_pixel_aspect[i].num &&
400  den == ff_h2645_pixel_aspect[i].den) {
401  sps->vui.aspect_ratio_idc = i;
402  break;
403  }
404  }
406  sps->vui.aspect_ratio_idc = 255;
407  sps->vui.sar_width = num;
408  sps->vui.sar_height = den;
409  }
410  sps->vui.aspect_ratio_info_present_flag = 1;
411  }
412 
413  // Unspecified video format, from table E-2.
414  sps->vui.video_format = 5;
415  sps->vui.video_full_range_flag =
416  avctx->color_range == AVCOL_RANGE_JPEG;
417  sps->vui.colour_primaries = avctx->color_primaries;
418  sps->vui.transfer_characteristics = avctx->color_trc;
419  sps->vui.matrix_coefficients = avctx->colorspace;
420  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
421  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
423  sps->vui.colour_description_present_flag = 1;
424  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED ||
425  sps->vui.colour_description_present_flag)
426  sps->vui.video_signal_type_present_flag = 1;
427 
429  sps->vui.chroma_loc_info_present_flag = 1;
430  sps->vui.chroma_sample_loc_type_top_field =
431  sps->vui.chroma_sample_loc_type_bottom_field =
432  avctx->chroma_sample_location - 1;
433  }
434 
435  sps->vui.timing_info_present_flag = 1;
436  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
437  sps->vui.num_units_in_tick = avctx->framerate.den;
438  sps->vui.time_scale = 2 * avctx->framerate.num;
439  sps->vui.fixed_frame_rate_flag = 1;
440  } else {
441  sps->vui.num_units_in_tick = avctx->time_base.num;
442  sps->vui.time_scale = 2 * avctx->time_base.den;
443  sps->vui.fixed_frame_rate_flag = 0;
444  }
445 
446  if (priv->sei & SEI_TIMING) {
447  H264RawHRD *hrd = &sps->vui.nal_hrd_parameters;
449 
450  sps->vui.nal_hrd_parameters_present_flag = 1;
451 
452  hrd->cpb_cnt_minus1 = 0;
453 
454  // Try to scale these to a sensible range so that the
455  // golomb encode of the value is not overlong.
456  hrd->bit_rate_scale =
457  av_clip_uintp2(av_log2(ctx->va_bit_rate) - 15 - 6, 4);
458  hrd->bit_rate_value_minus1[0] =
459  (ctx->va_bit_rate >> hrd->bit_rate_scale + 6) - 1;
460 
461  hrd->cpb_size_scale =
462  av_clip_uintp2(av_log2(ctx->hrd_params.buffer_size) - 15 - 4, 4);
463  hrd->cpb_size_value_minus1[0] =
464  (ctx->hrd_params.buffer_size >> hrd->cpb_size_scale + 4) - 1;
465 
466  // CBR mode as defined for the HRD cannot be achieved without filler
467  // data, so this flag cannot be set even with VAAPI CBR modes.
468  hrd->cbr_flag[0] = 0;
469 
473  hrd->time_offset_length = 0;
474 
475  bp->seq_parameter_set_id = sps->seq_parameter_set_id;
476 
477  // This calculation can easily overflow 32 bits.
478  bp->nal.initial_cpb_removal_delay[0] = 90000 *
479  (uint64_t)ctx->hrd_params.initial_buffer_fullness /
480  ctx->hrd_params.buffer_size;
482  } else {
483  sps->vui.nal_hrd_parameters_present_flag = 0;
484  sps->vui.low_delay_hrd_flag = 1 - sps->vui.fixed_frame_rate_flag;
485  }
486 
487  sps->vui.bitstream_restriction_flag = 1;
488  sps->vui.motion_vectors_over_pic_boundaries_flag = 1;
489  sps->vui.log2_max_mv_length_horizontal = 15;
490  sps->vui.log2_max_mv_length_vertical = 15;
491  sps->vui.max_num_reorder_frames = ctx->max_b_depth;
492  sps->vui.max_dec_frame_buffering = ctx->max_b_depth + 1;
493 
494  pps->nal_unit_header.nal_ref_idc = 3;
495  pps->nal_unit_header.nal_unit_type = H264_NAL_PPS;
496 
497  pps->pic_parameter_set_id = 0;
498  pps->seq_parameter_set_id = 0;
499 
500  pps->entropy_coding_mode_flag =
501  !(sps->profile_idc == FF_PROFILE_H264_BASELINE ||
502  sps->profile_idc == FF_PROFILE_H264_EXTENDED ||
503  sps->profile_idc == FF_PROFILE_H264_CAVLC_444);
504  if (!priv->coder && pps->entropy_coding_mode_flag)
505  pps->entropy_coding_mode_flag = 0;
506 
507  pps->num_ref_idx_l0_default_active_minus1 = 0;
508  pps->num_ref_idx_l1_default_active_minus1 = 0;
509 
510  pps->pic_init_qp_minus26 = priv->fixed_qp_idr - 26;
511 
512  if (sps->profile_idc == FF_PROFILE_H264_BASELINE ||
513  sps->profile_idc == FF_PROFILE_H264_EXTENDED ||
514  sps->profile_idc == FF_PROFILE_H264_MAIN) {
515  pps->more_rbsp_data = 0;
516  } else {
517  pps->more_rbsp_data = 1;
518 
519  pps->transform_8x8_mode_flag = 1;
520  }
521 
522  *vseq = (VAEncSequenceParameterBufferH264) {
523  .seq_parameter_set_id = sps->seq_parameter_set_id,
524  .level_idc = sps->level_idc,
525  .intra_period = ctx->gop_size,
526  .intra_idr_period = ctx->gop_size,
527  .ip_period = ctx->b_per_p + 1,
528 
529  .bits_per_second = ctx->va_bit_rate,
530  .max_num_ref_frames = sps->max_num_ref_frames,
531  .picture_width_in_mbs = sps->pic_width_in_mbs_minus1 + 1,
532  .picture_height_in_mbs = sps->pic_height_in_map_units_minus1 + 1,
533 
534  .seq_fields.bits = {
535  .chroma_format_idc = sps->chroma_format_idc,
536  .frame_mbs_only_flag = sps->frame_mbs_only_flag,
537  .mb_adaptive_frame_field_flag = sps->mb_adaptive_frame_field_flag,
538  .seq_scaling_matrix_present_flag = sps->seq_scaling_matrix_present_flag,
539  .direct_8x8_inference_flag = sps->direct_8x8_inference_flag,
540  .log2_max_frame_num_minus4 = sps->log2_max_frame_num_minus4,
541  .pic_order_cnt_type = sps->pic_order_cnt_type,
542  .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_pic_order_cnt_lsb_minus4,
543  .delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag,
544  },
545 
546  .bit_depth_luma_minus8 = sps->bit_depth_luma_minus8,
547  .bit_depth_chroma_minus8 = sps->bit_depth_chroma_minus8,
548 
549  .frame_cropping_flag = sps->frame_cropping_flag,
550  .frame_crop_left_offset = sps->frame_crop_left_offset,
551  .frame_crop_right_offset = sps->frame_crop_right_offset,
552  .frame_crop_top_offset = sps->frame_crop_top_offset,
553  .frame_crop_bottom_offset = sps->frame_crop_bottom_offset,
554 
555  .vui_parameters_present_flag = sps->vui_parameters_present_flag,
556 
557  .vui_fields.bits = {
558  .aspect_ratio_info_present_flag = sps->vui.aspect_ratio_info_present_flag,
559  .timing_info_present_flag = sps->vui.timing_info_present_flag,
560  .bitstream_restriction_flag = sps->vui.bitstream_restriction_flag,
561  .log2_max_mv_length_horizontal = sps->vui.log2_max_mv_length_horizontal,
562  .log2_max_mv_length_vertical = sps->vui.log2_max_mv_length_vertical,
563  },
564 
565  .aspect_ratio_idc = sps->vui.aspect_ratio_idc,
566  .sar_width = sps->vui.sar_width,
567  .sar_height = sps->vui.sar_height,
568  .num_units_in_tick = sps->vui.num_units_in_tick,
569  .time_scale = sps->vui.time_scale,
570  };
571 
572  *vpic = (VAEncPictureParameterBufferH264) {
573  .CurrPic = {
574  .picture_id = VA_INVALID_ID,
575  .flags = VA_PICTURE_H264_INVALID,
576  },
577 
578  .coded_buf = VA_INVALID_ID,
579 
580  .pic_parameter_set_id = pps->pic_parameter_set_id,
581  .seq_parameter_set_id = pps->seq_parameter_set_id,
582 
583  .pic_init_qp = pps->pic_init_qp_minus26 + 26,
584  .num_ref_idx_l0_active_minus1 = pps->num_ref_idx_l0_default_active_minus1,
585  .num_ref_idx_l1_active_minus1 = pps->num_ref_idx_l1_default_active_minus1,
586 
587  .chroma_qp_index_offset = pps->chroma_qp_index_offset,
588  .second_chroma_qp_index_offset = pps->second_chroma_qp_index_offset,
589 
590  .pic_fields.bits = {
591  .entropy_coding_mode_flag = pps->entropy_coding_mode_flag,
592  .weighted_pred_flag = pps->weighted_pred_flag,
593  .weighted_bipred_idc = pps->weighted_bipred_idc,
594  .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
595  .transform_8x8_mode_flag = pps->transform_8x8_mode_flag,
596  .deblocking_filter_control_present_flag =
597  pps->deblocking_filter_control_present_flag,
598  .redundant_pic_cnt_present_flag = pps->redundant_pic_cnt_present_flag,
599  .pic_order_present_flag =
600  pps->bottom_field_pic_order_in_frame_present_flag,
601  .pic_scaling_matrix_present_flag = pps->pic_scaling_matrix_present_flag,
602  },
603  };
604 
605  return 0;
606 }
607 
609  VAAPIEncodePicture *pic)
610 {
611  VAAPIEncodeContext *ctx = avctx->priv_data;
612  VAAPIEncodeH264Context *priv = avctx->priv_data;
613  VAAPIEncodeH264Picture *hpic = pic->priv_data;
614  VAAPIEncodePicture *prev = pic->prev;
615  VAAPIEncodeH264Picture *hprev = prev ? prev->priv_data : NULL;
616  VAEncPictureParameterBufferH264 *vpic = pic->codec_picture_params;
617  int i;
618 
619  if (pic->type == PICTURE_TYPE_IDR) {
620  av_assert0(pic->display_order == pic->encode_order);
621 
622  hpic->frame_num = 0;
623  hpic->last_idr_frame = pic->display_order;
624  hpic->idr_pic_id = hprev ? hprev->idr_pic_id + 1 : 0;
625 
626  hpic->primary_pic_type = 0;
627  hpic->slice_type = 7;
628  } else {
629  av_assert0(prev);
630 
631  hpic->frame_num = hprev->frame_num + prev->is_reference;
632 
633  hpic->last_idr_frame = hprev->last_idr_frame;
634  hpic->idr_pic_id = hprev->idr_pic_id;
635 
636  if (pic->type == PICTURE_TYPE_I) {
637  hpic->slice_type = 7;
638  hpic->primary_pic_type = 0;
639  } else if (pic->type == PICTURE_TYPE_P) {
640  hpic->slice_type = 5;
641  hpic->primary_pic_type = 1;
642  } else {
643  hpic->slice_type = 6;
644  hpic->primary_pic_type = 2;
645  }
646  }
647  hpic->pic_order_cnt = pic->display_order - hpic->last_idr_frame;
648  if (priv->raw_sps.pic_order_cnt_type == 2) {
649  hpic->pic_order_cnt *= 2;
650  }
651 
652  hpic->dpb_delay = pic->display_order - pic->encode_order + ctx->max_b_depth;
653  hpic->cpb_delay = pic->encode_order - hpic->last_idr_frame;
654 
655  if (priv->aud) {
656  priv->aud_needed = 1;
657  priv->raw_aud = (H264RawAUD) {
658  .nal_unit_header = {
660  },
661  .primary_pic_type = hpic->primary_pic_type,
662  };
663  } else {
664  priv->aud_needed = 0;
665  }
666 
667  priv->sei_needed = 0;
668 
669  if (priv->sei & SEI_IDENTIFIER && pic->encode_order == 0)
670  priv->sei_needed |= SEI_IDENTIFIER;
671 #if !CONFIG_VAAPI_1
672  if (ctx->va_rc_mode == VA_RC_CBR)
673  priv->sei_cbr_workaround_needed = 1;
674 #endif
675 
676  if (priv->sei & SEI_TIMING) {
678  .cpb_removal_delay = 2 * hpic->cpb_delay,
679  .dpb_output_delay = 2 * hpic->dpb_delay,
680  };
681 
682  priv->sei_needed |= SEI_TIMING;
683  }
684 
685  if (priv->sei & SEI_RECOVERY_POINT && pic->type == PICTURE_TYPE_I) {
687  .recovery_frame_cnt = 0,
688  .exact_match_flag = 1,
689  .broken_link_flag = ctx->b_per_p > 0,
690  };
691 
693  }
694 
695  if (priv->sei & SEI_A53_CC) {
696  int err;
697  size_t sei_a53cc_len;
698  av_freep(&priv->sei_a53cc_data);
699  err = ff_alloc_a53_sei(pic->input_image, 0, &priv->sei_a53cc_data, &sei_a53cc_len);
700  if (err < 0)
701  return err;
702  if (priv->sei_a53cc_data != NULL) {
703  priv->sei_a53cc.itu_t_t35_country_code = 181;
704  priv->sei_a53cc.data = (uint8_t *)priv->sei_a53cc_data + 1;
705  priv->sei_a53cc.data_length = sei_a53cc_len - 1;
706 
707  priv->sei_needed |= SEI_A53_CC;
708  }
709  }
710 
711  vpic->CurrPic = (VAPictureH264) {
712  .picture_id = pic->recon_surface,
713  .frame_idx = hpic->frame_num,
714  .flags = 0,
715  .TopFieldOrderCnt = hpic->pic_order_cnt,
716  .BottomFieldOrderCnt = hpic->pic_order_cnt,
717  };
718 
719  for (i = 0; i < pic->nb_refs; i++) {
720  VAAPIEncodePicture *ref = pic->refs[i];
722 
723  av_assert0(ref && ref->encode_order < pic->encode_order);
724  href = ref->priv_data;
725 
726  vpic->ReferenceFrames[i] = (VAPictureH264) {
727  .picture_id = ref->recon_surface,
728  .frame_idx = href->frame_num,
729  .flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE,
730  .TopFieldOrderCnt = href->pic_order_cnt,
731  .BottomFieldOrderCnt = href->pic_order_cnt,
732  };
733  }
734  for (; i < FF_ARRAY_ELEMS(vpic->ReferenceFrames); i++) {
735  vpic->ReferenceFrames[i] = (VAPictureH264) {
736  .picture_id = VA_INVALID_ID,
737  .flags = VA_PICTURE_H264_INVALID,
738  };
739  }
740 
741  vpic->coded_buf = pic->output_buffer;
742 
743  vpic->frame_num = hpic->frame_num;
744 
745  vpic->pic_fields.bits.idr_pic_flag = (pic->type == PICTURE_TYPE_IDR);
746  vpic->pic_fields.bits.reference_pic_flag = (pic->type != PICTURE_TYPE_B);
747 
748  return 0;
749 }
750 
752  VAAPIEncodePicture *pic,
753  VAAPIEncodePicture **rpl0,
754  VAAPIEncodePicture **rpl1,
755  int *rpl_size)
756 {
757  VAAPIEncodePicture *prev;
758  VAAPIEncodeH264Picture *hp, *hn, *hc;
759  int i, j, n = 0;
760 
761  prev = pic->prev;
762  av_assert0(prev);
763  hp = pic->priv_data;
764 
765  for (i = 0; i < pic->prev->nb_dpb_pics; i++) {
766  hn = prev->dpb[i]->priv_data;
767  av_assert0(hn->frame_num < hp->frame_num);
768 
769  if (pic->type == PICTURE_TYPE_P) {
770  for (j = n; j > 0; j--) {
771  hc = rpl0[j - 1]->priv_data;
772  av_assert0(hc->frame_num != hn->frame_num);
773  if (hc->frame_num > hn->frame_num)
774  break;
775  rpl0[j] = rpl0[j - 1];
776  }
777  rpl0[j] = prev->dpb[i];
778 
779  } else if (pic->type == PICTURE_TYPE_B) {
780  for (j = n; j > 0; j--) {
781  hc = rpl0[j - 1]->priv_data;
783  if (hc->pic_order_cnt < hp->pic_order_cnt) {
784  if (hn->pic_order_cnt > hp->pic_order_cnt ||
785  hn->pic_order_cnt < hc->pic_order_cnt)
786  break;
787  } else {
788  if (hn->pic_order_cnt > hc->pic_order_cnt)
789  break;
790  }
791  rpl0[j] = rpl0[j - 1];
792  }
793  rpl0[j] = prev->dpb[i];
794 
795  for (j = n; j > 0; j--) {
796  hc = rpl1[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  rpl1[j] = rpl1[j - 1];
807  }
808  rpl1[j] = prev->dpb[i];
809  }
810 
811  ++n;
812  }
813 
814  if (pic->type == PICTURE_TYPE_B) {
815  for (i = 0; i < n; i++) {
816  if (rpl0[i] != rpl1[i])
817  break;
818  }
819  if (i == n)
820  FFSWAP(VAAPIEncodePicture*, rpl1[0], rpl1[1]);
821  }
822 
823  if (pic->type == PICTURE_TYPE_P ||
824  pic->type == PICTURE_TYPE_B) {
825  av_log(avctx, AV_LOG_DEBUG, "Default RefPicList0 for fn=%d/poc=%d:",
826  hp->frame_num, hp->pic_order_cnt);
827  for (i = 0; i < n; i++) {
828  hn = rpl0[i]->priv_data;
829  av_log(avctx, AV_LOG_DEBUG, " fn=%d/poc=%d",
830  hn->frame_num, hn->pic_order_cnt);
831  }
832  av_log(avctx, AV_LOG_DEBUG, "\n");
833  }
834  if (pic->type == PICTURE_TYPE_B) {
835  av_log(avctx, AV_LOG_DEBUG, "Default RefPicList1 for fn=%d/poc=%d:",
836  hp->frame_num, hp->pic_order_cnt);
837  for (i = 0; i < n; i++) {
838  hn = rpl1[i]->priv_data;
839  av_log(avctx, AV_LOG_DEBUG, " fn=%d/poc=%d",
840  hn->frame_num, hn->pic_order_cnt);
841  }
842  av_log(avctx, AV_LOG_DEBUG, "\n");
843  }
844 
845  *rpl_size = n;
846 }
847 
849  VAAPIEncodePicture *pic,
850  VAAPIEncodeSlice *slice)
851 {
852  VAAPIEncodeH264Context *priv = avctx->priv_data;
853  VAAPIEncodeH264Picture *hpic = pic->priv_data;
854  VAAPIEncodePicture *prev = pic->prev;
855  H264RawSPS *sps = &priv->raw_sps;
856  H264RawPPS *pps = &priv->raw_pps;
857  H264RawSliceHeader *sh = &priv->raw_slice.header;
858  VAEncPictureParameterBufferH264 *vpic = pic->codec_picture_params;
859  VAEncSliceParameterBufferH264 *vslice = slice->codec_slice_params;
860  int i, j;
861 
862  if (pic->type == PICTURE_TYPE_IDR) {
865  } else {
868  }
869 
870  sh->first_mb_in_slice = slice->block_start;
871  sh->slice_type = hpic->slice_type;
872 
873  sh->pic_parameter_set_id = pps->pic_parameter_set_id;
874 
875  sh->frame_num = hpic->frame_num &
876  ((1 << (4 + sps->log2_max_frame_num_minus4)) - 1);
877  sh->idr_pic_id = hpic->idr_pic_id;
878  sh->pic_order_cnt_lsb = hpic->pic_order_cnt &
879  ((1 << (4 + sps->log2_max_pic_order_cnt_lsb_minus4)) - 1);
880 
882 
883  if (pic->type == PICTURE_TYPE_B)
884  sh->slice_qp_delta = priv->fixed_qp_b - (pps->pic_init_qp_minus26 + 26);
885  else if (pic->type == PICTURE_TYPE_P)
886  sh->slice_qp_delta = priv->fixed_qp_p - (pps->pic_init_qp_minus26 + 26);
887  else
888  sh->slice_qp_delta = priv->fixed_qp_idr - (pps->pic_init_qp_minus26 + 26);
889 
890  if (pic->is_reference && pic->type != PICTURE_TYPE_IDR) {
891  VAAPIEncodePicture *discard_list[MAX_DPB_SIZE];
892  int discard = 0, keep = 0;
893 
894  // Discard everything which is in the DPB of the previous frame but
895  // not in the DPB of this one.
896  for (i = 0; i < prev->nb_dpb_pics; i++) {
897  for (j = 0; j < pic->nb_dpb_pics; j++) {
898  if (prev->dpb[i] == pic->dpb[j])
899  break;
900  }
901  if (j == pic->nb_dpb_pics) {
902  discard_list[discard] = prev->dpb[i];
903  ++discard;
904  } else {
905  ++keep;
906  }
907  }
908  av_assert0(keep <= priv->dpb_frames);
909 
910  if (discard == 0) {
912  } else {
914  for (i = 0; i < discard; i++) {
915  VAAPIEncodeH264Picture *old = discard_list[i]->priv_data;
916  av_assert0(old->frame_num < hpic->frame_num);
919  hpic->frame_num - old->frame_num - 1;
920  }
922  }
923  }
924 
925  // If the intended references are not the first entries of RefPicListN
926  // by default, use ref-pic-list-modification to move them there.
927  if (pic->type == PICTURE_TYPE_P || pic->type == PICTURE_TYPE_B) {
928  VAAPIEncodePicture *def_l0[MAX_DPB_SIZE], *def_l1[MAX_DPB_SIZE];
930  int n;
931 
933  def_l0, def_l1, &n);
934 
935  if (pic->type == PICTURE_TYPE_P) {
936  int need_rplm = 0;
937  for (i = 0; i < pic->nb_refs; i++) {
938  av_assert0(pic->refs[i]);
939  if (pic->refs[i] != def_l0[i])
940  need_rplm = 1;
941  }
942 
943  sh->ref_pic_list_modification_flag_l0 = need_rplm;
944  if (need_rplm) {
945  int pic_num = hpic->frame_num;
946  for (i = 0; i < pic->nb_refs; i++) {
947  href = pic->refs[i]->priv_data;
948  av_assert0(href->frame_num != pic_num);
949  if (href->frame_num < pic_num) {
952  pic_num - href->frame_num - 1;
953  } else {
956  href->frame_num - pic_num - 1;
957  }
958  pic_num = href->frame_num;
959  }
961  }
962 
963  } else {
964  int need_rplm_l0 = 0, need_rplm_l1 = 0;
965  int n0 = 0, n1 = 0;
966  for (i = 0; i < pic->nb_refs; i++) {
967  av_assert0(pic->refs[i]);
968  href = pic->refs[i]->priv_data;
969  av_assert0(href->pic_order_cnt != hpic->pic_order_cnt);
970  if (href->pic_order_cnt < hpic->pic_order_cnt) {
971  if (pic->refs[i] != def_l0[n0])
972  need_rplm_l0 = 1;
973  ++n0;
974  } else {
975  if (pic->refs[i] != def_l1[n1])
976  need_rplm_l1 = 1;
977  ++n1;
978  }
979  }
980 
981  sh->ref_pic_list_modification_flag_l0 = need_rplm_l0;
982  if (need_rplm_l0) {
983  int pic_num = hpic->frame_num;
984  for (i = j = 0; i < pic->nb_refs; i++) {
985  href = pic->refs[i]->priv_data;
986  if (href->pic_order_cnt > hpic->pic_order_cnt)
987  continue;
988  av_assert0(href->frame_num != pic_num);
989  if (href->frame_num < pic_num) {
992  pic_num - href->frame_num - 1;
993  } else {
996  href->frame_num - pic_num - 1;
997  }
998  pic_num = href->frame_num;
999  ++j;
1000  }
1001  av_assert0(j == n0);
1003  }
1004 
1005  sh->ref_pic_list_modification_flag_l1 = need_rplm_l1;
1006  if (need_rplm_l1) {
1007  int pic_num = hpic->frame_num;
1008  for (i = j = 0; i < pic->nb_refs; i++) {
1009  href = pic->refs[i]->priv_data;
1010  if (href->pic_order_cnt < hpic->pic_order_cnt)
1011  continue;
1012  av_assert0(href->frame_num != pic_num);
1013  if (href->frame_num < pic_num) {
1016  pic_num - href->frame_num - 1;
1017  } else {
1020  href->frame_num - pic_num - 1;
1021  }
1022  pic_num = href->frame_num;
1023  ++j;
1024  }
1025  av_assert0(j == n1);
1027  }
1028  }
1029  }
1030 
1031  vslice->macroblock_address = slice->block_start;
1032  vslice->num_macroblocks = slice->block_size;
1033 
1034  vslice->macroblock_info = VA_INVALID_ID;
1035 
1036  vslice->slice_type = sh->slice_type % 5;
1037  vslice->pic_parameter_set_id = sh->pic_parameter_set_id;
1038  vslice->idr_pic_id = sh->idr_pic_id;
1039 
1040  vslice->pic_order_cnt_lsb = sh->pic_order_cnt_lsb;
1041 
1042  vslice->direct_spatial_mv_pred_flag = sh->direct_spatial_mv_pred_flag;
1043 
1044  for (i = 0; i < FF_ARRAY_ELEMS(vslice->RefPicList0); i++) {
1045  vslice->RefPicList0[i].picture_id = VA_INVALID_ID;
1046  vslice->RefPicList0[i].flags = VA_PICTURE_H264_INVALID;
1047  vslice->RefPicList1[i].picture_id = VA_INVALID_ID;
1048  vslice->RefPicList1[i].flags = VA_PICTURE_H264_INVALID;
1049  }
1050 
1051  av_assert0(pic->nb_refs <= 2);
1052  if (pic->nb_refs >= 1) {
1053  // Backward reference for P- or B-frame.
1054  av_assert0(pic->type == PICTURE_TYPE_P ||
1055  pic->type == PICTURE_TYPE_B);
1056  vslice->RefPicList0[0] = vpic->ReferenceFrames[0];
1057  }
1058  if (pic->nb_refs >= 2) {
1059  // Forward reference for B-frame.
1060  av_assert0(pic->type == PICTURE_TYPE_B);
1061  vslice->RefPicList1[0] = vpic->ReferenceFrames[1];
1062  }
1063 
1064  vslice->slice_qp_delta = sh->slice_qp_delta;
1065 
1066  return 0;
1067 }
1068 
1070 {
1071  VAAPIEncodeContext *ctx = avctx->priv_data;
1072  VAAPIEncodeH264Context *priv = avctx->priv_data;
1073  int err;
1074 
1075  err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_H264, avctx);
1076  if (err < 0)
1077  return err;
1078 
1079  priv->mb_width = FFALIGN(avctx->width, 16) / 16;
1080  priv->mb_height = FFALIGN(avctx->height, 16) / 16;
1081 
1082  if (ctx->va_rc_mode == VA_RC_CQP) {
1083  priv->fixed_qp_p = av_clip(ctx->rc_quality, 1, 51);
1084  if (avctx->i_quant_factor > 0.0)
1085  priv->fixed_qp_idr =
1086  av_clip((avctx->i_quant_factor * priv->fixed_qp_p +
1087  avctx->i_quant_offset) + 0.5, 1, 51);
1088  else
1089  priv->fixed_qp_idr = priv->fixed_qp_p;
1090  if (avctx->b_quant_factor > 0.0)
1091  priv->fixed_qp_b =
1092  av_clip((avctx->b_quant_factor * priv->fixed_qp_p +
1093  avctx->b_quant_offset) + 0.5, 1, 51);
1094  else
1095  priv->fixed_qp_b = priv->fixed_qp_p;
1096 
1097  av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
1098  "%d / %d / %d for IDR- / P- / B-frames.\n",
1099  priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
1100 
1101  } else {
1102  // These still need to be set for pic_init_qp/slice_qp_delta.
1103  priv->fixed_qp_idr = 26;
1104  priv->fixed_qp_p = 26;
1105  priv->fixed_qp_b = 26;
1106  }
1107 
1108  if (!ctx->rc_mode->hrd) {
1109  // Timing SEI requires a mode respecting HRD parameters.
1110  priv->sei &= ~SEI_TIMING;
1111  }
1112 
1113  if (priv->sei & SEI_IDENTIFIER) {
1114  const char *lavc = LIBAVCODEC_IDENT;
1115  const char *vaapi = VA_VERSION_S;
1116  const char *driver;
1117  int len;
1118 
1119  memcpy(priv->sei_identifier.uuid_iso_iec_11578,
1121  sizeof(priv->sei_identifier.uuid_iso_iec_11578));
1122 
1123  driver = vaQueryVendorString(ctx->hwctx->display);
1124  if (!driver)
1125  driver = "unknown driver";
1126 
1127  len = snprintf(NULL, 0, "%s / VAAPI %s / %s", lavc, vaapi, driver);
1128  if (len >= 0) {
1129  priv->sei_identifier_string = av_malloc(len + 1);
1130  if (!priv->sei_identifier_string)
1131  return AVERROR(ENOMEM);
1132 
1133  snprintf(priv->sei_identifier_string, len + 1,
1134  "%s / VAAPI %s / %s", lavc, vaapi, driver);
1135 
1137  priv->sei_identifier.data_length = len + 1;
1138  }
1139  }
1140 
1141  ctx->roi_quant_range = 51 + 6 * (ctx->profile->depth - 8);
1142 
1143  return 0;
1144 }
1145 
1147  { FF_PROFILE_H264_HIGH, 8, 3, 1, 1, VAProfileH264High },
1148  { FF_PROFILE_H264_MAIN, 8, 3, 1, 1, VAProfileH264Main },
1150  8, 3, 1, 1, VAProfileH264ConstrainedBaseline },
1151  { FF_PROFILE_UNKNOWN }
1152 };
1153 
1156 
1157  .flags = FLAG_SLICE_CONTROL |
1158  FLAG_B_PICTURES |
1161 
1162  .default_quality = 20,
1163 
1164  .configure = &vaapi_encode_h264_configure,
1165 
1166  .picture_priv_data_size = sizeof(VAAPIEncodeH264Picture),
1167 
1168  .sequence_params_size = sizeof(VAEncSequenceParameterBufferH264),
1169  .init_sequence_params = &vaapi_encode_h264_init_sequence_params,
1170 
1171  .picture_params_size = sizeof(VAEncPictureParameterBufferH264),
1172  .init_picture_params = &vaapi_encode_h264_init_picture_params,
1173 
1174  .slice_params_size = sizeof(VAEncSliceParameterBufferH264),
1175  .init_slice_params = &vaapi_encode_h264_init_slice_params,
1176 
1177  .sequence_header_type = VAEncPackedHeaderSequence,
1178  .write_sequence_header = &vaapi_encode_h264_write_sequence_header,
1179 
1180  .slice_header_type = VAEncPackedHeaderH264_Slice,
1181  .write_slice_header = &vaapi_encode_h264_write_slice_header,
1182 
1183  .write_extra_header = &vaapi_encode_h264_write_extra_header,
1184 };
1185 
1187 {
1188  VAAPIEncodeContext *ctx = avctx->priv_data;
1189  VAAPIEncodeH264Context *priv = avctx->priv_data;
1190 
1191  ctx->codec = &vaapi_encode_type_h264;
1192 
1193  if (avctx->profile == FF_PROFILE_UNKNOWN)
1194  avctx->profile = priv->profile;
1195  if (avctx->level == FF_LEVEL_UNKNOWN)
1196  avctx->level = priv->level;
1198  avctx->compression_level = priv->quality;
1199 
1200  // Reject unsupported profiles.
1201  switch (avctx->profile) {
1203  av_log(avctx, AV_LOG_WARNING, "H.264 baseline profile is not "
1204  "supported, using constrained baseline profile instead.\n");
1206  break;
1208  av_log(avctx, AV_LOG_ERROR, "H.264 extended profile "
1209  "is not supported.\n");
1210  return AVERROR_PATCHWELCOME;
1213  av_log(avctx, AV_LOG_ERROR, "H.264 10-bit profiles "
1214  "are not supported.\n");
1215  return AVERROR_PATCHWELCOME;
1222  av_log(avctx, AV_LOG_ERROR, "H.264 non-4:2:0 profiles "
1223  "are not supported.\n");
1224  return AVERROR_PATCHWELCOME;
1225  }
1226 
1227  if (avctx->level != FF_LEVEL_UNKNOWN && avctx->level & ~0xff) {
1228  av_log(avctx, AV_LOG_ERROR, "Invalid level %d: must fit "
1229  "in 8-bit unsigned integer.\n", avctx->level);
1230  return AVERROR(EINVAL);
1231  }
1232 
1233  ctx->desired_packed_headers =
1234  VA_ENC_PACKED_HEADER_SEQUENCE | // SPS and PPS.
1235  VA_ENC_PACKED_HEADER_SLICE | // Slice headers.
1236  VA_ENC_PACKED_HEADER_MISC; // SEI.
1237 
1238  ctx->surface_width = FFALIGN(avctx->width, 16);
1239  ctx->surface_height = FFALIGN(avctx->height, 16);
1240 
1241  ctx->slice_block_height = ctx->slice_block_width = 16;
1242 
1243  if (priv->qp > 0)
1244  ctx->explicit_qp = priv->qp;
1245 
1246  return ff_vaapi_encode_init(avctx);
1247 }
1248 
1250 {
1251  VAAPIEncodeH264Context *priv = avctx->priv_data;
1252 
1254  ff_cbs_close(&priv->cbc);
1256  av_freep(&priv->sei_a53cc_data);
1257 
1258  return ff_vaapi_encode_close(avctx);
1259 }
1260 
1261 #define OFFSET(x) offsetof(VAAPIEncodeH264Context, x)
1262 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
1266 
1267  { "qp", "Constant QP (for P-frames; scaled by qfactor/qoffset for I/B)",
1268  OFFSET(qp), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 52, FLAGS },
1269  { "quality", "Set encode quality (trades off against speed, higher is faster)",
1270  OFFSET(quality), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
1271  { "coder", "Entropy coder type",
1272  OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, FLAGS, "coder" },
1273  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, FLAGS, "coder" },
1274  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, FLAGS, "coder" },
1275  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, FLAGS, "coder" },
1276  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, FLAGS, "coder" },
1277 
1278  { "aud", "Include AUD",
1279  OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
1280 
1281  { "sei", "Set SEI to include",
1284  0, INT_MAX, FLAGS, "sei" },
1285  { "identifier", "Include encoder version identifier",
1286  0, AV_OPT_TYPE_CONST, { .i64 = SEI_IDENTIFIER },
1287  INT_MIN, INT_MAX, FLAGS, "sei" },
1288  { "timing", "Include timing parameters (buffering_period and pic_timing)",
1289  0, AV_OPT_TYPE_CONST, { .i64 = SEI_TIMING },
1290  INT_MIN, INT_MAX, FLAGS, "sei" },
1291  { "recovery_point", "Include recovery points where appropriate",
1292  0, AV_OPT_TYPE_CONST, { .i64 = SEI_RECOVERY_POINT },
1293  INT_MIN, INT_MAX, FLAGS, "sei" },
1294  { "a53_cc", "Include A/53 caption data",
1295  0, AV_OPT_TYPE_CONST, { .i64 = SEI_A53_CC },
1296  INT_MIN, INT_MAX, FLAGS, "sei" },
1297 
1298  { "profile", "Set profile (profile_idc and constraint_set*_flag)",
1300  { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 0xffff, FLAGS, "profile" },
1301 
1302 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1303  { .i64 = value }, 0, 0, FLAGS, "profile"
1304  { PROFILE("constrained_baseline", FF_PROFILE_H264_CONSTRAINED_BASELINE) },
1305  { PROFILE("main", FF_PROFILE_H264_MAIN) },
1306  { PROFILE("high", FF_PROFILE_H264_HIGH) },
1307 #undef PROFILE
1308 
1309  { "level", "Set level (level_idc)",
1311  { .i64 = FF_LEVEL_UNKNOWN }, FF_LEVEL_UNKNOWN, 0xff, FLAGS, "level" },
1312 
1313 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1314  { .i64 = value }, 0, 0, FLAGS, "level"
1315  { LEVEL("1", 10) },
1316  { LEVEL("1.1", 11) },
1317  { LEVEL("1.2", 12) },
1318  { LEVEL("1.3", 13) },
1319  { LEVEL("2", 20) },
1320  { LEVEL("2.1", 21) },
1321  { LEVEL("2.2", 22) },
1322  { LEVEL("3", 30) },
1323  { LEVEL("3.1", 31) },
1324  { LEVEL("3.2", 32) },
1325  { LEVEL("4", 40) },
1326  { LEVEL("4.1", 41) },
1327  { LEVEL("4.2", 42) },
1328  { LEVEL("5", 50) },
1329  { LEVEL("5.1", 51) },
1330  { LEVEL("5.2", 52) },
1331  { LEVEL("6", 60) },
1332  { LEVEL("6.1", 61) },
1333  { LEVEL("6.2", 62) },
1334 #undef LEVEL
1335 
1336  { NULL },
1337 };
1338 
1340  { "b", "0" },
1341  { "bf", "2" },
1342  { "g", "120" },
1343  { "i_qfactor", "1" },
1344  { "i_qoffset", "0" },
1345  { "b_qfactor", "6/5" },
1346  { "b_qoffset", "0" },
1347  { "qmin", "-1" },
1348  { "qmax", "-1" },
1349  { NULL },
1350 };
1351 
1353  .class_name = "h264_vaapi",
1354  .item_name = av_default_item_name,
1355  .option = vaapi_encode_h264_options,
1356  .version = LIBAVUTIL_VERSION_INT,
1357 };
1358 
1360  .p.name = "h264_vaapi",
1361  CODEC_LONG_NAME("H.264/AVC (VAAPI)"),
1362  .p.type = AVMEDIA_TYPE_VIDEO,
1363  .p.id = AV_CODEC_ID_H264,
1364  .priv_data_size = sizeof(VAAPIEncodeH264Context),
1367  .close = &vaapi_encode_h264_close,
1368  .p.priv_class = &vaapi_encode_h264_class,
1369  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE |
1371  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
1373  .defaults = vaapi_encode_h264_defaults,
1374  .p.pix_fmts = (const enum AVPixelFormat[]) {
1377  },
1378  .hw_configs = ff_vaapi_encode_hw_configs,
1379  .p.wrapper_name = "vaapi",
1380 };
FLAGS
#define FLAGS
Definition: vaapi_encode_h264.c:1262
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:25
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:69
OFFSET
#define OFFSET(x)
Definition: vaapi_encode_h264.c:1261
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:204
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: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:1008
SEIRawUserDataRegistered
Definition: cbs_sei.h:35
PICTURE_TYPE_IDR
@ PICTURE_TYPE_IDR
Definition: vaapi_encode.h:57
VAAPIEncodeH264Picture
Definition: vaapi_encode_h264.c:54
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:1622
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:119
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:1623
vaapi_encode_h264_sei_identifier_uuid
static const uint8_t vaapi_encode_h264_sei_identifier_uuid[16]
Definition: vaapi_encode_h264.c:49
H264RawSEIBufferingPeriod::nal
struct H264RawSEIBufferingPeriod::@29 nal
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1001
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:661
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
vaapi_encode_h264_class
static const AVClass vaapi_encode_h264_class
Definition: vaapi_encode_h264.c:1352
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:75
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:561
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:719
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:1634
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:127
vaapi_encode_h264_init_picture_params
static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, VAAPIEncodePicture *pic)
Definition: vaapi_encode_h264.c:608
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:2752
cbs.h
FF_LEVEL_UNKNOWN
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1710
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:1636
VAAPIEncodeH264Context::mb_height
int mb_height
Definition: vaapi_encode_h264.c:82
FF_COMPRESSION_DEFAULT
#define FF_COMPRESSION_DEFAULT
Definition: avcodec.h:504
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: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
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1768
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: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:736
FFCodecDefault
Definition: codec_internal.h:97
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
FLAG_NON_IDR_KEY_PICTURES
@ FLAG_NON_IDR_KEY_PICTURES
Definition: vaapi_encode.h:378
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
Definition: cbs_sei.h:45
fail
#define fail()
Definition: checkasm.h:134
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:68
SEIRawUserDataUnregistered
Definition: cbs_sei.h:43
FF_PROFILE_H264_HIGH
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:1626
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
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
FLAG_B_PICTURES
@ FLAG_B_PICTURES
Definition: vaapi_encode.h:373
PICTURE_TYPE_I
@ PICTURE_TYPE_I
Definition: vaapi_encode.h:58
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:36
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:994
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:1186
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:134
VAAPIEncodeH264Context::quality
int quality
Definition: vaapi_encode_h264.c:73
FF_PROFILE_H264_EXTENDED
#define FF_PROFILE_H264_EXTENDED
Definition: avcodec.h:1625
H264RawNALUnitHeader::nal_unit_type
uint8_t nal_unit_type
Definition: cbs_h264.h:33
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
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 codec takes the reordered_opaque field from input AVFrames and returns it in the corresponding f...
Definition: codec.h:176
H264RawAUD::nal_unit_header
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:219
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1584
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:64
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: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:1263
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:1193
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:138
VAAPIEncodeH264Context::coder
int coder
Definition: vaapi_encode_h264.c:74
h2645data.h
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:536
VAAPIEncodeType
Definition: vaapi_encode.h:381
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:272
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
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
SEI_IDENTIFIER
@ SEI_IDENTIFIER
Definition: vaapi_encode_h264.c:43
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
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:1015
VAAPIEncodeH264Context::sei
int sei
Definition: vaapi_encode_h264.c:76
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:740
VAAPIEncodeType::profiles
const VAAPIEncodeProfile * profiles
Definition: vaapi_encode.h:384
FF_CODEC_RECEIVE_PACKET_CB
#define FF_CODEC_RECEIVE_PACKET_CB(func)
Definition: codec_internal.h:321
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:481
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
PICTURE_TYPE_P
@ PICTURE_TYPE_P
Definition: vaapi_encode.h:59
SEI_RECOVERY_POINT
@ SEI_RECOVERY_POINT
Definition: vaapi_encode_h264.c:44
VAAPIEncodeH264Context::fixed_qp_p
int fixed_qp_p
Definition: vaapi_encode_h264.c:85
vaapi_encode_h264_profiles
static const VAAPIEncodeProfile vaapi_encode_h264_profiles[]
Definition: vaapi_encode_h264.c:1146
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:825
AVCodecContext::level
int level
level
Definition: avcodec.h:1709
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:627
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:554
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:842
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
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:87
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:1630
SEIRawUserDataRegistered::data
uint8_t * data
Definition: cbs_sei.h:38
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:127
SEI_TIMING
@ SEI_TIMING
Definition: vaapi_encode_h264.c: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:185
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:681
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: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:848
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
SEIRawUserDataRegistered::data_length
size_t data_length
Definition: cbs_sei.h:40
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:157
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:712
VAAPIEncodeH264Picture::slice_type
int slice_type
Definition: vaapi_encode_h264.c:62
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: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
internal.h
FLAG_SLICE_CONTROL
@ FLAG_SLICE_CONTROL
Definition: vaapi_encode.h:367
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
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
vaapi_encode_h264_close
static av_cold int vaapi_encode_h264_close(AVCodecContext *avctx)
Definition: vaapi_encode_h264.c:1249
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:211
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:1022
len
int len
Definition: vorbis_enc_data.h:426
profile
int profile
Definition: mxfenc.c:2006
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:590
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:604
VAAPIEncodeH264Context::qp
int qp
Definition: vaapi_encode_h264.c:72
FF_PROFILE_H264_HIGH_10_INTRA
#define FF_PROFILE_H264_HIGH_10_INTRA
Definition: avcodec.h:1628
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:61
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:1635
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:2550
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
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
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
SEI_A53_CC
@ SEI_A53_CC
Definition: vaapi_encode_h264.c:45
VAAPIEncodeH264Picture::last_idr_frame
int64_t last_idr_frame
Definition: vaapi_encode_h264.c:58
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:1633
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:1359
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
FF_PROFILE_H264_HIGH_422_INTRA
#define FF_PROFILE_H264_HIGH_422_INTRA
Definition: avcodec.h:1631
AVCodecContext
main external API structure.
Definition: avcodec.h:431
H264RawAUD
Definition: cbs_h264.h:218
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: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:1583
AVCodecContext::i_quant_offset
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:743
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
PICTURE_TYPE_B
@ PICTURE_TYPE_B
Definition: vaapi_encode.h:60
FF_PROFILE_H264_MAIN
#define FF_PROFILE_H264_MAIN
Definition: avcodec.h:1624
FLAG_B_PICTURE_REFERENCES
@ FLAG_B_PICTURE_REFERENCES
Definition: vaapi_encode.h:375
SEI_TYPE_RECOVERY_POINT
@ SEI_TYPE_RECOVERY_POINT
Definition: sei.h:36
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
VAAPIEncodeH264Context::sei_buffering_period
H264RawSEIBufferingPeriod sei_buffering_period
Definition: vaapi_encode_h264.c:99
H264RawSEIRecoveryPoint
Definition: cbs_h264.h:268
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:1154
vaapi_encode_h264_configure
static av_cold int vaapi_encode_h264_configure(AVCodecContext *avctx)
Definition: vaapi_encode_h264.c:1069
VAAPIEncodePicture::input_image
AVFrame * input_image
Definition: vaapi_encode.h:92
MAX_DPB_SIZE
@ MAX_DPB_SIZE
Definition: vaapi_encode.h:43
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:458
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:1339
PROFILE
#define PROFILE(name, value)
FF_PROFILE_H264_HIGH_10
#define FF_PROFILE_H264_HIGH_10
Definition: avcodec.h:1627
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:604
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
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
VAAPIEncodeH264Context::profile
int profile
Definition: vaapi_encode_h264.c:77
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
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
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:801
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:503
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:751
H264RawSPS
Definition: cbs_h264.h:102
H264RawPPS
Definition: cbs_h264.h:171