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