FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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_sei.h"
34 #include "internal.h"
35 #include "vaapi_encode.h"
36 
37 enum {
38  SEI_TIMING = 0x01,
41 };
42 
43 // Random (version 4) ISO 11578 UUID.
45  0x59, 0x94, 0x8b, 0x28, 0x11, 0xec, 0x45, 0xaf,
46  0x96, 0x75, 0x19, 0xd4, 0x1f, 0xea, 0xa9, 0x4d,
47 };
48 
49 typedef struct VAAPIEncodeH264Context {
50  int mb_width;
51  int mb_height;
52 
56 
62 
68 
69  int frame_num;
72  int64_t last_idr_frame;
73  int64_t idr_pic_count;
74 
77 
78  int cpb_delay;
79  int dpb_delay;
80 
87 
88 typedef struct VAAPIEncodeH264Options {
89  int qp;
90  int quality;
91  int low_power;
92  // Entropy encoder type.
93  int coder;
94  int aud;
95  int sei;
96  int profile;
97  int level;
99 
100 
102  char *data, size_t *data_len,
104 {
105  VAAPIEncodeContext *ctx = avctx->priv_data;
106  VAAPIEncodeH264Context *priv = ctx->priv_data;
107  int err;
108 
109  err = ff_cbs_write_fragment_data(priv->cbc, au);
110  if (err < 0) {
111  av_log(avctx, AV_LOG_ERROR, "Failed to write packed header.\n");
112  return err;
113  }
114 
115  if (*data_len < 8 * au->data_size - au->data_bit_padding) {
116  av_log(avctx, AV_LOG_ERROR, "Access unit too large: "
117  "%zu < %zu.\n", *data_len,
118  8 * au->data_size - au->data_bit_padding);
119  return AVERROR(ENOSPC);
120  }
121 
122  memcpy(data, au->data, au->data_size);
123  *data_len = 8 * au->data_size - au->data_bit_padding;
124 
125  return 0;
126 }
127 
130  void *nal_unit)
131 {
132  VAAPIEncodeContext *ctx = avctx->priv_data;
133  VAAPIEncodeH264Context *priv = ctx->priv_data;
134  H264RawNALUnitHeader *header = nal_unit;
135  int err;
136 
137  err = ff_cbs_insert_unit_content(priv->cbc, au, -1,
138  header->nal_unit_type, nal_unit, NULL);
139  if (err < 0) {
140  av_log(avctx, AV_LOG_ERROR, "Failed to add NAL unit: "
141  "type = %d.\n", header->nal_unit_type);
142  return err;
143  }
144 
145  return 0;
146 }
147 
149  char *data, size_t *data_len)
150 {
151  VAAPIEncodeContext *ctx = avctx->priv_data;
152  VAAPIEncodeH264Context *priv = ctx->priv_data;
154  int err;
155 
156  if (priv->aud_needed) {
157  err = vaapi_encode_h264_add_nal(avctx, au, &priv->aud);
158  if (err < 0)
159  goto fail;
160  priv->aud_needed = 0;
161  }
162 
163  err = vaapi_encode_h264_add_nal(avctx, au, &priv->sps);
164  if (err < 0)
165  goto fail;
166 
167  err = vaapi_encode_h264_add_nal(avctx, au, &priv->pps);
168  if (err < 0)
169  goto fail;
170 
171  err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au);
172 fail:
173  ff_cbs_fragment_uninit(priv->cbc, au);
174  return err;
175 }
176 
178  VAAPIEncodePicture *pic,
179  VAAPIEncodeSlice *slice,
180  char *data, size_t *data_len)
181 {
182  VAAPIEncodeContext *ctx = avctx->priv_data;
183  VAAPIEncodeH264Context *priv = ctx->priv_data;
185  int err;
186 
187  if (priv->aud_needed) {
188  err = vaapi_encode_h264_add_nal(avctx, au, &priv->aud);
189  if (err < 0)
190  goto fail;
191  priv->aud_needed = 0;
192  }
193 
194  err = vaapi_encode_h264_add_nal(avctx, au, &priv->slice);
195  if (err < 0)
196  goto fail;
197 
198  err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au);
199 fail:
200  ff_cbs_fragment_uninit(priv->cbc, au);
201  return err;
202 }
203 
205  VAAPIEncodePicture *pic,
206  int index, int *type,
207  char *data, size_t *data_len)
208 {
209  VAAPIEncodeContext *ctx = avctx->priv_data;
210  VAAPIEncodeH264Context *priv = ctx->priv_data;
212  int err, i;
213 
214  if (priv->sei_needed) {
215  if (priv->aud_needed) {
216  err = vaapi_encode_h264_add_nal(avctx, au, &priv->aud);
217  if (err < 0)
218  goto fail;
219  priv->aud_needed = 0;
220  }
221 
222  memset(&priv->sei, 0, sizeof(priv->sei));
224 
225  i = 0;
226  if (priv->sei_needed & SEI_IDENTIFIER) {
229  ++i;
230  }
231  if (priv->sei_needed & SEI_TIMING) {
232  if (pic->type == PICTURE_TYPE_IDR) {
235  ++i;
236  }
238  priv->sei.payload[i].payload.pic_timing = priv->pic_timing;
239  ++i;
240  }
241  if (priv->sei_needed & SEI_RECOVERY_POINT) {
244  ++i;
245  }
246 
247  priv->sei.payload_count = i;
248  av_assert0(priv->sei.payload_count > 0);
249 
250  err = vaapi_encode_h264_add_nal(avctx, au, &priv->sei);
251  if (err < 0)
252  goto fail;
253  priv->sei_needed = 0;
254 
255  err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au);
256  if (err < 0)
257  goto fail;
258 
259  ff_cbs_fragment_uninit(priv->cbc, au);
260 
261  *type = VAEncPackedHeaderRawData;
262  return 0;
263 
264 #if !CONFIG_VAAPI_1
265  } else if (priv->sei_cbr_workaround_needed) {
266  // Insert a zero-length header using the old SEI type. This is
267  // required to avoid triggering broken behaviour on Intel platforms
268  // in CBR mode where an invalid SEI message is generated by the
269  // driver and inserted into the stream.
270  *data_len = 0;
271  *type = VAEncPackedHeaderH264_SEI;
272  priv->sei_cbr_workaround_needed = 0;
273  return 0;
274 #endif
275 
276  } else {
277  return AVERROR_EOF;
278  }
279 
280 fail:
281  ff_cbs_fragment_uninit(priv->cbc, au);
282  return err;
283 }
284 
286 {
287  VAAPIEncodeContext *ctx = avctx->priv_data;
288  VAAPIEncodeH264Context *priv = ctx->priv_data;
290  H264RawSPS *sps = &priv->sps;
291  H264RawPPS *pps = &priv->pps;
292  VAEncSequenceParameterBufferH264 *vseq = ctx->codec_sequence_params;
293  VAEncPictureParameterBufferH264 *vpic = ctx->codec_picture_params;
294 
295  memset(&priv->current_access_unit, 0,
296  sizeof(priv->current_access_unit));
297 
298  memset(sps, 0, sizeof(*sps));
299  memset(pps, 0, sizeof(*pps));
300 
301  sps->nal_unit_header.nal_ref_idc = 3;
303 
304  sps->profile_idc = avctx->profile & 0xff;
305  sps->constraint_set1_flag =
307  sps->constraint_set3_flag =
308  !!(avctx->profile & FF_PROFILE_H264_INTRA);
309 
310  sps->level_idc = avctx->level;
311 
312  sps->seq_parameter_set_id = 0;
313  sps->chroma_format_idc = 1;
314 
315  sps->log2_max_frame_num_minus4 = 4;
316  sps->pic_order_cnt_type = 0;
318  av_clip(av_log2(ctx->b_per_p + 1) - 2, 0, 12);
319 
320  sps->max_num_ref_frames =
321  (avctx->profile & FF_PROFILE_H264_INTRA) ? 0 :
322  1 + (ctx->b_per_p > 0);
323 
324  sps->pic_width_in_mbs_minus1 = priv->mb_width - 1;
325  sps->pic_height_in_map_units_minus1 = priv->mb_height - 1;
326 
327  sps->frame_mbs_only_flag = 1;
328  sps->direct_8x8_inference_flag = 1;
329 
330  if (avctx->width != 16 * priv->mb_width ||
331  avctx->height != 16 * priv->mb_height) {
332  sps->frame_cropping_flag = 1;
333 
334  sps->frame_crop_left_offset = 0;
336  (16 * priv->mb_width - avctx->width) / 2;
337  sps->frame_crop_top_offset = 0;
339  (16 * priv->mb_height - avctx->height) / 2;
340  } else {
341  sps->frame_cropping_flag = 0;
342  }
343 
345 
346  if (avctx->sample_aspect_ratio.num != 0 &&
347  avctx->sample_aspect_ratio.den != 0) {
348  static const AVRational sar_idc[] = {
349  { 0, 0 },
350  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
351  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
352  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
353  { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
354  };
355  int i;
356  for (i = 0; i < FF_ARRAY_ELEMS(sar_idc); i++) {
357  if (avctx->sample_aspect_ratio.num == sar_idc[i].num &&
358  avctx->sample_aspect_ratio.den == sar_idc[i].den) {
359  sps->vui.aspect_ratio_idc = i;
360  break;
361  }
362  }
363  if (i >= FF_ARRAY_ELEMS(sar_idc)) {
364  sps->vui.aspect_ratio_idc = 255;
365  sps->vui.sar_width = avctx->sample_aspect_ratio.num;
366  sps->vui.sar_height = avctx->sample_aspect_ratio.den;
367  }
369  }
370 
371  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED ||
373  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
374  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
376  sps->vui.video_format = 5; // Unspecified.
378  avctx->color_range == AVCOL_RANGE_JPEG;
379 
380  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
381  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
382  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
384  sps->vui.colour_primaries = avctx->color_primaries;
385  sps->vui.transfer_characteristics = avctx->color_trc;
386  sps->vui.matrix_coefficients = avctx->colorspace;
387  }
388  } else {
389  sps->vui.video_format = 5;
390  sps->vui.video_full_range_flag = 0;
391  sps->vui.colour_primaries = avctx->color_primaries;
392  sps->vui.transfer_characteristics = avctx->color_trc;
393  sps->vui.matrix_coefficients = avctx->colorspace;
394  }
395 
400  avctx->chroma_sample_location - 1;
401  }
402 
403  sps->vui.timing_info_present_flag = 1;
404  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
405  sps->vui.num_units_in_tick = avctx->framerate.den;
406  sps->vui.time_scale = 2 * avctx->framerate.num;
407  sps->vui.fixed_frame_rate_flag = 1;
408  } else {
409  sps->vui.num_units_in_tick = avctx->time_base.num;
410  sps->vui.time_scale = 2 * avctx->time_base.den;
411  sps->vui.fixed_frame_rate_flag = 0;
412  }
413 
414  if (opt->sei & SEI_TIMING) {
415  H264RawHRD *hrd = &sps->vui.nal_hrd_parameters;
416 
418 
419  hrd->cpb_cnt_minus1 = 0;
420 
421  // Try to scale these to a sensible range so that the
422  // golomb encode of the value is not overlong.
423  hrd->bit_rate_scale =
424  av_clip_uintp2(av_log2(avctx->bit_rate) - 15 - 6, 4);
425  hrd->bit_rate_value_minus1[0] =
426  (avctx->bit_rate >> hrd->bit_rate_scale + 6) - 1;
427 
428  hrd->cpb_size_scale =
429  av_clip_uintp2(av_log2(ctx->hrd_params.hrd.buffer_size) - 15 - 4, 4);
430  hrd->cpb_size_value_minus1[0] =
431  (ctx->hrd_params.hrd.buffer_size >> hrd->cpb_size_scale + 4) - 1;
432 
433  // CBR mode as defined for the HRD cannot be achieved without filler
434  // data, so this flag cannot be set even with VAAPI CBR modes.
435  hrd->cbr_flag[0] = 0;
436 
440  hrd->time_offset_length = 0;
441 
443 
444  // This calculation can easily overflow 32 bits.
446  (uint64_t)ctx->hrd_params.hrd.initial_buffer_fullness /
447  ctx->hrd_params.hrd.buffer_size;
449  } else {
452  }
453 
458  sps->vui.max_num_reorder_frames = (ctx->b_per_p > 0);
460 
461  pps->nal_unit_header.nal_ref_idc = 3;
463 
464  pps->pic_parameter_set_id = 0;
465  pps->seq_parameter_set_id = 0;
466 
471  if (!opt->coder && pps->entropy_coding_mode_flag)
472  pps->entropy_coding_mode_flag = 0;
473 
476 
477  pps->pic_init_qp_minus26 = priv->fixed_qp_idr - 26;
478 
482  pps->more_rbsp_data = 0;
483  } else {
484  pps->more_rbsp_data = 1;
485 
486  pps->transform_8x8_mode_flag = 1;
487  }
488 
489  *vseq = (VAEncSequenceParameterBufferH264) {
490  .seq_parameter_set_id = sps->seq_parameter_set_id,
491  .level_idc = sps->level_idc,
492  .intra_period = avctx->gop_size,
493  .intra_idr_period = avctx->gop_size,
494  .ip_period = ctx->b_per_p + 1,
495 
496  .bits_per_second = avctx->bit_rate,
497  .max_num_ref_frames = sps->max_num_ref_frames,
498  .picture_width_in_mbs = sps->pic_width_in_mbs_minus1 + 1,
499  .picture_height_in_mbs = sps->pic_height_in_map_units_minus1 + 1,
500 
501  .seq_fields.bits = {
502  .chroma_format_idc = sps->chroma_format_idc,
503  .frame_mbs_only_flag = sps->frame_mbs_only_flag,
504  .mb_adaptive_frame_field_flag = sps->mb_adaptive_frame_field_flag,
505  .seq_scaling_matrix_present_flag = sps->seq_scaling_matrix_present_flag,
506  .direct_8x8_inference_flag = sps->direct_8x8_inference_flag,
507  .log2_max_frame_num_minus4 = sps->log2_max_frame_num_minus4,
508  .pic_order_cnt_type = sps->pic_order_cnt_type,
509  .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_pic_order_cnt_lsb_minus4,
510  .delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag,
511  },
512 
513  .bit_depth_luma_minus8 = sps->bit_depth_luma_minus8,
514  .bit_depth_chroma_minus8 = sps->bit_depth_chroma_minus8,
515 
516  .frame_cropping_flag = sps->frame_cropping_flag,
517  .frame_crop_left_offset = sps->frame_crop_left_offset,
518  .frame_crop_right_offset = sps->frame_crop_right_offset,
519  .frame_crop_top_offset = sps->frame_crop_top_offset,
520  .frame_crop_bottom_offset = sps->frame_crop_bottom_offset,
521 
522  .vui_parameters_present_flag = sps->vui_parameters_present_flag,
523 
524  .vui_fields.bits = {
525  .aspect_ratio_info_present_flag = sps->vui.aspect_ratio_info_present_flag,
526  .timing_info_present_flag = sps->vui.timing_info_present_flag,
527  .bitstream_restriction_flag = sps->vui.bitstream_restriction_flag,
528  .log2_max_mv_length_horizontal = sps->vui.log2_max_mv_length_horizontal,
529  .log2_max_mv_length_vertical = sps->vui.log2_max_mv_length_vertical,
530  },
531 
532  .aspect_ratio_idc = sps->vui.aspect_ratio_idc,
533  .sar_width = sps->vui.sar_width,
534  .sar_height = sps->vui.sar_height,
535  .num_units_in_tick = sps->vui.num_units_in_tick,
536  .time_scale = sps->vui.time_scale,
537  };
538 
539  *vpic = (VAEncPictureParameterBufferH264) {
540  .CurrPic = {
541  .picture_id = VA_INVALID_ID,
542  .flags = VA_PICTURE_H264_INVALID,
543  },
544 
545  .coded_buf = VA_INVALID_ID,
546 
547  .pic_parameter_set_id = pps->pic_parameter_set_id,
548  .seq_parameter_set_id = pps->seq_parameter_set_id,
549 
550  .pic_init_qp = pps->pic_init_qp_minus26 + 26,
551  .num_ref_idx_l0_active_minus1 = pps->num_ref_idx_l0_default_active_minus1,
552  .num_ref_idx_l1_active_minus1 = pps->num_ref_idx_l1_default_active_minus1,
553 
554  .chroma_qp_index_offset = pps->chroma_qp_index_offset,
555  .second_chroma_qp_index_offset = pps->second_chroma_qp_index_offset,
556 
557  .pic_fields.bits = {
558  .entropy_coding_mode_flag = pps->entropy_coding_mode_flag,
559  .weighted_pred_flag = pps->weighted_pred_flag,
560  .weighted_bipred_idc = pps->weighted_bipred_idc,
561  .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
562  .transform_8x8_mode_flag = pps->transform_8x8_mode_flag,
563  .deblocking_filter_control_present_flag =
565  .redundant_pic_cnt_present_flag = pps->redundant_pic_cnt_present_flag,
566  .pic_order_present_flag =
568  .pic_scaling_matrix_present_flag = pps->pic_scaling_matrix_present_flag,
569  },
570  };
571 
572  return 0;
573 }
574 
576  VAAPIEncodePicture *pic)
577 {
578  VAAPIEncodeContext *ctx = avctx->priv_data;
579  VAAPIEncodeH264Context *priv = ctx->priv_data;
581  H264RawSPS *sps = &priv->sps;
582  VAEncPictureParameterBufferH264 *vpic = pic->codec_picture_params;
583  int i;
584 
585  memset(&priv->current_access_unit, 0,
586  sizeof(priv->current_access_unit));
587 
588  if (pic->type == PICTURE_TYPE_IDR) {
589  av_assert0(pic->display_order == pic->encode_order);
590  priv->frame_num = 0;
591  priv->next_frame_num = 1;
592  priv->cpb_delay = 0;
593  priv->last_idr_frame = pic->display_order;
594  ++priv->idr_pic_count;
595 
596  priv->slice_type = 7;
597  priv->primary_pic_type = 0;
598  } else {
599  priv->frame_num = priv->next_frame_num;
600 
601  if (pic->type != PICTURE_TYPE_B) {
602  // Reference picture, so frame_num advances.
603  priv->next_frame_num = (priv->frame_num + 1) &
604  ((1 << (4 + sps->log2_max_frame_num_minus4)) - 1);
605  }
606  ++priv->cpb_delay;
607 
608  if (pic->type == PICTURE_TYPE_I) {
609  priv->slice_type = 7;
610  priv->primary_pic_type = 0;
611  } else if (pic->type == PICTURE_TYPE_P) {
612  priv->slice_type = 5;
613  priv->primary_pic_type = 1;
614  } else {
615  priv->slice_type = 6;
616  priv->primary_pic_type = 2;
617  }
618  }
619  priv->pic_order_cnt = pic->display_order - priv->last_idr_frame;
620  priv->dpb_delay = pic->display_order - pic->encode_order + 1;
621 
622  if (opt->aud) {
623  priv->aud_needed = 1;
625  priv->aud.primary_pic_type = priv->primary_pic_type;
626  } else {
627  priv->aud_needed = 0;
628  }
629 
630  priv->sei_needed = 0;
631 
632  if (opt->sei & SEI_IDENTIFIER && pic->encode_order == 0)
633  priv->sei_needed |= SEI_IDENTIFIER;
634 #if !CONFIG_VAAPI_1
635  if (ctx->va_rc_mode == VA_RC_CBR)
636  priv->sei_cbr_workaround_needed = 1;
637 #endif
638 
639  if (opt->sei & SEI_TIMING) {
640  memset(&priv->pic_timing, 0, sizeof(priv->pic_timing));
641 
642  priv->pic_timing.cpb_removal_delay = 2 * priv->cpb_delay;
643  priv->pic_timing.dpb_output_delay = 2 * priv->dpb_delay;
644 
645  priv->sei_needed |= SEI_TIMING;
646  }
647 
648  if (opt->sei & SEI_RECOVERY_POINT && pic->type == PICTURE_TYPE_I) {
651  priv->recovery_point.broken_link_flag = ctx->b_per_p > 0;
652 
654  }
655 
656  vpic->CurrPic = (VAPictureH264) {
657  .picture_id = pic->recon_surface,
658  .frame_idx = priv->frame_num,
659  .flags = 0,
660  .TopFieldOrderCnt = priv->pic_order_cnt,
661  .BottomFieldOrderCnt = priv->pic_order_cnt,
662  };
663 
664  for (i = 0; i < pic->nb_refs; i++) {
665  VAAPIEncodePicture *ref = pic->refs[i];
666  unsigned int frame_num = (ref->encode_order - priv->last_idr_frame) &
667  ((1 << (4 + sps->log2_max_frame_num_minus4)) - 1);
668  unsigned int pic_order_cnt = ref->display_order - priv->last_idr_frame;
669 
670  av_assert0(ref && ref->encode_order < pic->encode_order);
671  vpic->ReferenceFrames[i] = (VAPictureH264) {
672  .picture_id = ref->recon_surface,
673  .frame_idx = frame_num,
674  .flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE,
675  .TopFieldOrderCnt = pic_order_cnt,
676  .BottomFieldOrderCnt = pic_order_cnt,
677  };
678  }
679  for (; i < FF_ARRAY_ELEMS(vpic->ReferenceFrames); i++) {
680  vpic->ReferenceFrames[i] = (VAPictureH264) {
681  .picture_id = VA_INVALID_ID,
682  .flags = VA_PICTURE_H264_INVALID,
683  };
684  }
685 
686  vpic->coded_buf = pic->output_buffer;
687 
688  vpic->frame_num = priv->frame_num;
689 
690  vpic->pic_fields.bits.idr_pic_flag = (pic->type == PICTURE_TYPE_IDR);
691  vpic->pic_fields.bits.reference_pic_flag = (pic->type != PICTURE_TYPE_B);
692 
693  pic->nb_slices = 1;
694 
695  return 0;
696 }
697 
699  VAAPIEncodePicture *pic,
700  VAAPIEncodeSlice *slice)
701 {
702  VAAPIEncodeContext *ctx = avctx->priv_data;
703  VAAPIEncodeH264Context *priv = ctx->priv_data;
704  H264RawSPS *sps = &priv->sps;
705  H264RawPPS *pps = &priv->pps;
706  H264RawSliceHeader *sh = &priv->slice.header;
707  VAEncPictureParameterBufferH264 *vpic = pic->codec_picture_params;
708  VAEncSliceParameterBufferH264 *vslice = slice->codec_slice_params;
709  int i;
710 
711  if (pic->type == PICTURE_TYPE_IDR) {
714  } else {
717  }
718 
719  // Only one slice per frame.
720  sh->first_mb_in_slice = 0;
721  sh->slice_type = priv->slice_type;
722 
724 
725  sh->frame_num = priv->frame_num;
726  sh->idr_pic_id = priv->idr_pic_count;
727 
728  sh->pic_order_cnt_lsb = priv->pic_order_cnt &
729  ((1 << (4 + sps->log2_max_pic_order_cnt_lsb_minus4)) - 1);
730 
732 
733  if (pic->type == PICTURE_TYPE_B)
734  sh->slice_qp_delta = priv->fixed_qp_b - (pps->pic_init_qp_minus26 + 26);
735  else if (pic->type == PICTURE_TYPE_P)
736  sh->slice_qp_delta = priv->fixed_qp_p - (pps->pic_init_qp_minus26 + 26);
737  else
738  sh->slice_qp_delta = priv->fixed_qp_idr - (pps->pic_init_qp_minus26 + 26);
739 
740 
741  vslice->macroblock_address = sh->first_mb_in_slice;
742  vslice->num_macroblocks = priv->mb_width * priv->mb_height;
743 
744  vslice->macroblock_info = VA_INVALID_ID;
745 
746  vslice->slice_type = sh->slice_type % 5;
747  vslice->pic_parameter_set_id = sh->pic_parameter_set_id;
748  vslice->idr_pic_id = sh->idr_pic_id;
749 
750  vslice->pic_order_cnt_lsb = sh->pic_order_cnt_lsb;
751 
752  vslice->direct_spatial_mv_pred_flag = sh->direct_spatial_mv_pred_flag;
753 
754  for (i = 0; i < FF_ARRAY_ELEMS(vslice->RefPicList0); i++) {
755  vslice->RefPicList0[i].picture_id = VA_INVALID_ID;
756  vslice->RefPicList0[i].flags = VA_PICTURE_H264_INVALID;
757  vslice->RefPicList1[i].picture_id = VA_INVALID_ID;
758  vslice->RefPicList1[i].flags = VA_PICTURE_H264_INVALID;
759  }
760 
761  av_assert0(pic->nb_refs <= 2);
762  if (pic->nb_refs >= 1) {
763  // Backward reference for P- or B-frame.
764  av_assert0(pic->type == PICTURE_TYPE_P ||
765  pic->type == PICTURE_TYPE_B);
766  vslice->RefPicList0[0] = vpic->ReferenceFrames[0];
767  }
768  if (pic->nb_refs >= 2) {
769  // Forward reference for B-frame.
770  av_assert0(pic->type == PICTURE_TYPE_B);
771  vslice->RefPicList1[0] = vpic->ReferenceFrames[1];
772  }
773 
774  vslice->slice_qp_delta = sh->slice_qp_delta;
775 
776  return 0;
777 }
778 
780 {
781  VAAPIEncodeContext *ctx = avctx->priv_data;
782  VAAPIEncodeH264Context *priv = ctx->priv_data;
784  int err;
785 
786  err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_H264, avctx);
787  if (err < 0)
788  return err;
789 
790  priv->mb_width = FFALIGN(avctx->width, 16) / 16;
791  priv->mb_height = FFALIGN(avctx->height, 16) / 16;
792 
793  if (ctx->va_rc_mode == VA_RC_CQP) {
794  priv->fixed_qp_p = opt->qp;
795  if (avctx->i_quant_factor > 0.0)
796  priv->fixed_qp_idr = (int)((priv->fixed_qp_p * avctx->i_quant_factor +
797  avctx->i_quant_offset) + 0.5);
798  else
799  priv->fixed_qp_idr = priv->fixed_qp_p;
800  if (avctx->b_quant_factor > 0.0)
801  priv->fixed_qp_b = (int)((priv->fixed_qp_p * avctx->b_quant_factor +
802  avctx->b_quant_offset) + 0.5);
803  else
804  priv->fixed_qp_b = priv->fixed_qp_p;
805 
806  opt->sei &= ~SEI_TIMING;
807 
808  av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
809  "%d / %d / %d for IDR- / P- / B-frames.\n",
810  priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
811 
812  } else if (ctx->va_rc_mode == VA_RC_CBR ||
813  ctx->va_rc_mode == VA_RC_VBR) {
814  // These still need to be set for pic_init_qp/slice_qp_delta.
815  priv->fixed_qp_idr = 26;
816  priv->fixed_qp_p = 26;
817  priv->fixed_qp_b = 26;
818 
819  av_log(avctx, AV_LOG_DEBUG, "Using %s-bitrate = %"PRId64" bps.\n",
820  ctx->va_rc_mode == VA_RC_CBR ? "constant" : "variable",
821  avctx->bit_rate);
822 
823  } else {
824  av_assert0(0 && "Invalid RC mode.");
825  }
826 
828  avctx->compression_level = opt->quality;
829 
830  if (opt->sei & SEI_IDENTIFIER) {
831  const char *lavc = LIBAVCODEC_IDENT;
832  const char *vaapi = VA_VERSION_S;
833  const char *driver;
834  int len;
835 
836  memcpy(priv->identifier.uuid_iso_iec_11578,
838  sizeof(priv->identifier.uuid_iso_iec_11578));
839 
840  driver = vaQueryVendorString(ctx->hwctx->display);
841  if (!driver)
842  driver = "unknown driver";
843 
844  len = snprintf(NULL, 0, "%s / VAAPI %s / %s", lavc, vaapi, driver);
845  if (len >= 0) {
846  priv->identifier_string = av_malloc(len + 1);
847  if (!priv->identifier_string)
848  return AVERROR(ENOMEM);
849 
850  snprintf(priv->identifier_string, len + 1,
851  "%s / VAAPI %s / %s", lavc, vaapi, driver);
852 
853  priv->identifier.data = priv->identifier_string;
854  priv->identifier.data_length = len + 1;
855  }
856  }
857 
858  return 0;
859 }
860 
863 
864  .configure = &vaapi_encode_h264_configure,
865 
866  .sequence_params_size = sizeof(VAEncSequenceParameterBufferH264),
867  .init_sequence_params = &vaapi_encode_h264_init_sequence_params,
868 
869  .picture_params_size = sizeof(VAEncPictureParameterBufferH264),
870  .init_picture_params = &vaapi_encode_h264_init_picture_params,
871 
872  .slice_params_size = sizeof(VAEncSliceParameterBufferH264),
873  .init_slice_params = &vaapi_encode_h264_init_slice_params,
874 
875  .sequence_header_type = VAEncPackedHeaderSequence,
876  .write_sequence_header = &vaapi_encode_h264_write_sequence_header,
877 
878  .slice_header_type = VAEncPackedHeaderH264_Slice,
879  .write_slice_header = &vaapi_encode_h264_write_slice_header,
880 
881  .write_extra_header = &vaapi_encode_h264_write_extra_header,
882 };
883 
885 {
886  VAAPIEncodeContext *ctx = avctx->priv_data;
889 
890  ctx->codec = &vaapi_encode_type_h264;
891 
892  if (avctx->profile == FF_PROFILE_UNKNOWN)
893  avctx->profile = opt->profile;
894  if (avctx->level == FF_LEVEL_UNKNOWN)
895  avctx->level = opt->level;
896 
897  switch (avctx->profile) {
899  av_log(avctx, AV_LOG_WARNING, "H.264 baseline profile is not "
900  "supported, using constrained baseline profile instead.\n");
903  ctx->va_profile = VAProfileH264ConstrainedBaseline;
904  if (avctx->max_b_frames != 0) {
905  avctx->max_b_frames = 0;
906  av_log(avctx, AV_LOG_WARNING, "H.264 constrained baseline profile "
907  "doesn't support encoding with B frames, disabling them.\n");
908  }
909  break;
911  ctx->va_profile = VAProfileH264Main;
912  break;
914  av_log(avctx, AV_LOG_ERROR, "H.264 extended profile "
915  "is not supported.\n");
916  return AVERROR_PATCHWELCOME;
917  case FF_PROFILE_UNKNOWN:
919  ctx->va_profile = VAProfileH264High;
920  break;
923  av_log(avctx, AV_LOG_ERROR, "H.264 10-bit profiles "
924  "are not supported.\n");
925  return AVERROR_PATCHWELCOME;
932  av_log(avctx, AV_LOG_ERROR, "H.264 non-4:2:0 profiles "
933  "are not supported.\n");
934  return AVERROR_PATCHWELCOME;
935  default:
936  av_log(avctx, AV_LOG_ERROR, "Unknown H.264 profile %d.\n",
937  avctx->profile);
938  return AVERROR(EINVAL);
939  }
940  if (opt->low_power) {
941 #if VA_CHECK_VERSION(0, 39, 2)
942  ctx->va_entrypoint = VAEntrypointEncSliceLP;
943 #else
944  av_log(avctx, AV_LOG_ERROR, "Low-power encoding is not "
945  "supported with this VAAPI version.\n");
946  return AVERROR(EINVAL);
947 #endif
948  } else {
949  ctx->va_entrypoint = VAEntrypointEncSlice;
950  }
951 
952  // Only 8-bit encode is supported.
953  ctx->va_rt_format = VA_RT_FORMAT_YUV420;
954 
955  if (avctx->bit_rate > 0) {
956  if (avctx->rc_max_rate == avctx->bit_rate)
957  ctx->va_rc_mode = VA_RC_CBR;
958  else
959  ctx->va_rc_mode = VA_RC_VBR;
960  } else
961  ctx->va_rc_mode = VA_RC_CQP;
962 
963  ctx->va_packed_headers =
964  VA_ENC_PACKED_HEADER_SEQUENCE | // SPS and PPS.
965  VA_ENC_PACKED_HEADER_SLICE | // Slice headers.
966  VA_ENC_PACKED_HEADER_MISC; // SEI.
967 
968  ctx->surface_width = FFALIGN(avctx->width, 16);
969  ctx->surface_height = FFALIGN(avctx->height, 16);
970 
971  return ff_vaapi_encode_init(avctx);
972 }
973 
975 {
976  VAAPIEncodeContext *ctx = avctx->priv_data;
977  VAAPIEncodeH264Context *priv = ctx->priv_data;
978 
979  if (priv) {
980  ff_cbs_close(&priv->cbc);
981  av_freep(&priv->identifier_string);
982  }
983 
984  return ff_vaapi_encode_close(avctx);
985 }
986 
987 #define OFFSET(x) (offsetof(VAAPIEncodeContext, codec_options_data) + \
988  offsetof(VAAPIEncodeH264Options, x))
989 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
991  { "qp", "Constant QP (for P-frames; scaled by qfactor/qoffset for I/B)",
992  OFFSET(qp), AV_OPT_TYPE_INT, { .i64 = 20 }, 0, 52, FLAGS },
993  { "quality", "Set encode quality (trades off against speed, higher is faster)",
994  OFFSET(quality), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8, FLAGS },
995  { "low_power", "Use low-power encoding mode (experimental: only supported "
996  "on some platforms, does not support all features)",
997  OFFSET(low_power), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
998  { "coder", "Entropy coder type",
999  OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, FLAGS, "coder" },
1000  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, FLAGS, "coder" },
1001  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, FLAGS, "coder" },
1002  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, FLAGS, "coder" },
1003  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, FLAGS, "coder" },
1004 
1005  { "aud", "Include AUD",
1006  OFFSET(aud), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
1007 
1008  { "sei", "Set SEI to include",
1011  0, INT_MAX, FLAGS, "sei" },
1012  { "identifier", "Include encoder version identifier",
1013  0, AV_OPT_TYPE_CONST, { .i64 = SEI_IDENTIFIER },
1014  INT_MIN, INT_MAX, FLAGS, "sei" },
1015  { "timing", "Include timing parameters (buffering_period and pic_timing)",
1016  0, AV_OPT_TYPE_CONST, { .i64 = SEI_TIMING },
1017  INT_MIN, INT_MAX, FLAGS, "sei" },
1018  { "recovery_point", "Include recovery points where appropriate",
1019  0, AV_OPT_TYPE_CONST, { .i64 = SEI_RECOVERY_POINT },
1020  INT_MIN, INT_MAX, FLAGS, "sei" },
1021 
1022  { "profile", "Set profile (profile_idc and constraint_set*_flag)",
1024  { .i64 = FF_PROFILE_H264_HIGH }, 0x0000, 0xffff, FLAGS, "profile" },
1025 
1026 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1027  { .i64 = value }, 0, 0, FLAGS, "profile"
1028  { PROFILE("constrained_baseline", FF_PROFILE_H264_CONSTRAINED_BASELINE) },
1029  { PROFILE("main", FF_PROFILE_H264_MAIN) },
1030  { PROFILE("high", FF_PROFILE_H264_HIGH) },
1031 #undef PROFILE
1032 
1033  { "level", "Set level (level_idc)",
1035  { .i64 = 51 }, 0x00, 0xff, FLAGS, "level" },
1036 
1037 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1038  { .i64 = value }, 0, 0, FLAGS, "level"
1039  { LEVEL("1", 10) },
1040  { LEVEL("1.1", 11) },
1041  { LEVEL("1.2", 12) },
1042  { LEVEL("1.3", 13) },
1043  { LEVEL("2", 20) },
1044  { LEVEL("2.1", 21) },
1045  { LEVEL("2.2", 22) },
1046  { LEVEL("3", 30) },
1047  { LEVEL("3.1", 31) },
1048  { LEVEL("3.2", 32) },
1049  { LEVEL("4", 40) },
1050  { LEVEL("4.1", 41) },
1051  { LEVEL("4.2", 42) },
1052  { LEVEL("5", 50) },
1053  { LEVEL("5.1", 51) },
1054  { LEVEL("5.2", 52) },
1055  { LEVEL("6", 60) },
1056  { LEVEL("6.1", 61) },
1057  { LEVEL("6.2", 62) },
1058 #undef LEVEL
1059 
1060  { NULL },
1061 };
1062 
1064  { "b", "0" },
1065  { "bf", "2" },
1066  { "g", "120" },
1067  { "i_qfactor", "1" },
1068  { "i_qoffset", "0" },
1069  { "b_qfactor", "6/5" },
1070  { "b_qoffset", "0" },
1071  { "qmin", "0" },
1072  { NULL },
1073 };
1074 
1076  .class_name = "h264_vaapi",
1077  .item_name = av_default_item_name,
1078  .option = vaapi_encode_h264_options,
1079  .version = LIBAVUTIL_VERSION_INT,
1080 };
1081 
1083  .name = "h264_vaapi",
1084  .long_name = NULL_IF_CONFIG_SMALL("H.264/AVC (VAAPI)"),
1085  .type = AVMEDIA_TYPE_VIDEO,
1086  .id = AV_CODEC_ID_H264,
1087  .priv_data_size = (sizeof(VAAPIEncodeContext) +
1088  sizeof(VAAPIEncodeH264Options)),
1090  .encode2 = &ff_vaapi_encode2,
1091  .close = &vaapi_encode_h264_close,
1092  .priv_class = &vaapi_encode_h264_class,
1093  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE,
1094  .defaults = vaapi_encode_h264_defaults,
1095  .pix_fmts = (const enum AVPixelFormat[]) {
1098  },
1099  .wrapper_name = "vaapi",
1100 };
#define FF_PROFILE_H264_MAIN
Definition: avcodec.h:2887
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:182
uint8_t frame_cropping_flag
Definition: cbs_h264.h:157
uint8_t deblocking_filter_control_present_flag
Definition: cbs_h264.h:212
uint32_t payload_type
Definition: cbs_h264.h:319
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3043
static const VAAPIEncodeType vaapi_encode_type_h264
#define FF_PROFILE_H264_CAVLC_444
Definition: avcodec.h:2899
uint8_t bit_depth_chroma_minus8
Definition: cbs_h264.h:130
#define FF_COMPRESSION_DEFAULT
Definition: avcodec.h:1594
uint8_t aspect_ratio_idc
Definition: cbs_h264.h:70
VAProfile va_profile
Definition: vaapi_encode.h:96
static av_cold int vaapi_encode_h264_configure(AVCodecContext *avctx)
VAEntrypoint va_entrypoint
Definition: vaapi_encode.h:98
uint8_t video_format
Definition: cbs_h264.h:78
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
uint8_t bit_rate_scale
Definition: cbs_h264.h:55
uint16_t recovery_frame_cnt
Definition: cbs_h264.h:294
uint8_t dpb_output_delay_length_minus1
Definition: cbs_h264.h:64
uint8_t initial_cpb_removal_delay_length_minus1
Definition: cbs_h264.h:62
char codec_options_data[0]
Definition: vaapi_encode.h:213
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1571
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
uint8_t chroma_sample_loc_type_bottom_field
Definition: cbs_h264.h:87
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:1780
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: avcodec.h:1059
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:62
struct H264RawSEIBufferingPeriod::@41 nal
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:340
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2151
H264RawSEIRecoveryPoint recovery_point
Definition: cbs_h264.h:328
#define FF_PROFILE_H264_INTRA
Definition: avcodec.h:2883
int num
Numerator.
Definition: rational.h:59
uint8_t log2_max_frame_num_minus4
Definition: cbs_h264.h:138
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
int av_log2(unsigned v)
Definition: intmath.c:26
size_t priv_data_size
Definition: vaapi_encode.h:218
int ff_cbs_insert_unit_content(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, AVBufferRef *content_buf)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:558
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:1899
uint16_t pic_order_cnt_lsb
Definition: cbs_h264.h:362
uint8_t time_offset_length
Definition: cbs_h264.h:65
uint8_t low_delay_hrd_flag
Definition: cbs_h264.h:98
void * codec_sequence_params
Definition: vaapi_encode.h:168
VAEncMiscParameterHRD hrd
Definition: vaapi_encode.h:154
#define FLAGS
#define OFFSET(x)
uint8_t max_dec_frame_buffering
Definition: cbs_h264.h:109
int profile
profile
Definition: avcodec.h:2846
uint8_t fixed_frame_rate_flag
Definition: cbs_h264.h:92
H264RawVUI vui
Definition: cbs_h264.h:164
AVCodec.
Definition: avcodec.h:3411
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:1832
uint32_t first_mb_in_slice
Definition: cbs_h264.h:349
static const AVClass vaapi_encode_h264_class
#define FF_PROFILE_H264_HIGH_444_PREDICTIVE
Definition: avcodec.h:2897
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1643
unsigned int va_packed_headers
Definition: vaapi_encode.h:105
uint8_t weighted_pred_flag
Definition: cbs_h264.h:205
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:2957
H264RawHRD nal_hrd_parameters
Definition: cbs_h264.h:95
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: avcodec.h:987
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:412
static const AVOption vaapi_encode_h264_options[]
#define FF_PROFILE_H264_BASELINE
Definition: avcodec.h:2885
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVOptions.
uint16_t frame_crop_top_offset
Definition: cbs_h264.h:160
uint16_t pic_width_in_mbs_minus1
Definition: cbs_h264.h:150
static const AVCodecDefault vaapi_encode_h264_defaults[]
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:1789
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:347
static const uint8_t vaapi_encode_h264_sei_identifier_uuid[16]
uint32_t num_units_in_tick
Definition: cbs_h264.h:90
unregistered user data
Definition: h264_sei.h:33
uint8_t mb_adaptive_frame_field_flag
Definition: cbs_h264.h:154
uint8_t transform_8x8_mode_flag
Definition: cbs_h264.h:218
uint8_t constrained_intra_pred_flag
Definition: cbs_h264.h:213
uint32_t cpb_size_value_minus1[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:59
uint16_t frame_crop_left_offset
Definition: cbs_h264.h:158
static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, VAAPIEncodePicture *pic)
static av_cold int vaapi_encode_h264_init(AVCodecContext *avctx)
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define FF_PROFILE_H264_EXTENDED
Definition: avcodec.h:2888
VASurfaceID recon_surface
Definition: vaapi_encode.h:71
static const uint8_t header[24]
Definition: sdr2.c:67
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:229
uint16_t idr_pic_id
Definition: cbs_h264.h:360
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2158
#define FFALIGN(x, a)
Definition: macros.h:48
int8_t second_chroma_qp_index_offset
Definition: cbs_h264.h:225
#define av_log(a,...)
uint8_t cpb_size_scale
Definition: cbs_h264.h:56
uint8_t nal_hrd_parameters_present_flag
Definition: cbs_h264.h:94
uint8_t bit_depth_luma_minus8
Definition: cbs_h264.h:129
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:129
uint8_t primary_pic_type
Definition: cbs_h264.h:231
H.264 common definitions.
uint8_t pic_scaling_matrix_present_flag
Definition: cbs_h264.h:220
unsigned int va_rc_mode
Definition: vaapi_encode.h:102
uint8_t chroma_sample_loc_type_top_field
Definition: cbs_h264.h:86
union H264RawSEIPayload::@42 payload
buffering period (H.264, D.1.1)
Definition: h264_sei.h:28
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
uint8_t aspect_ratio_info_present_flag
Definition: cbs_h264.h:69
void ff_cbs_fragment_uninit(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free all allocated memory in a fragment.
Definition: cbs.c:127
#define AVERROR(e)
Definition: error.h:43
uint8_t max_num_ref_frames
Definition: cbs_h264.h:147
uint8_t weighted_bipred_idc
Definition: cbs_h264.h:206
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
uint8_t transfer_characteristics
Definition: cbs_h264.h:82
static int vaapi_encode_h264_write_access_unit(AVCodecContext *avctx, char *data, size_t *data_len, CodedBitstreamFragment *au)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
CodedBitstreamContext * cbc
#define FF_PROFILE_H264_HIGH_422
Definition: avcodec.h:2893
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:2889
uint16_t sar_width
Definition: cbs_h264.h:71
uint32_t initial_cpb_removal_delay_offset[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:238
uint8_t slice_type
Definition: cbs_h264.h:350
uint8_t num_ref_idx_l1_default_active_minus1
Definition: cbs_h264.h:203
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3418
uint8_t frame_mbs_only_flag
Definition: cbs_h264.h:153
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:1825
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
uint8_t seq_parameter_set_id
Definition: cbs_h264.h:125
uint8_t seq_scaling_matrix_present_flag
Definition: cbs_h264.h:133
static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
void * codec_picture_params
Definition: vaapi_encode.h:80
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:133
H264RawSEIPicTiming pic_timing
Definition: cbs_h264.h:323
#define fail()
Definition: checkasm.h:117
uint8_t timing_info_present_flag
Definition: cbs_h264.h:89
uint8_t more_rbsp_data
Definition: cbs_h264.h:215
uint8_t video_full_range_flag
Definition: cbs_h264.h:79
uint8_t seq_parameter_set_id
Definition: cbs_h264.h:185
#define LEVEL(name, value)
H264RawSEIUserDataUnregistered user_data_unregistered
Definition: cbs_h264.h:327
common internal API header
AVCodec ff_h264_vaapi_encoder
uint8_t colour_primaries
Definition: cbs_h264.h:81
picture timing
Definition: h264_sei.h:29
static int vaapi_encode_h264_write_sequence_header(AVCodecContext *avctx, char *data, size_t *data_len)
uint16_t sar_height
Definition: cbs_h264.h:72
uint16_t frame_crop_bottom_offset
Definition: cbs_h264.h:161
int width
picture width / height.
Definition: avcodec.h:1693
uint8_t vui_parameters_present_flag
Definition: cbs_h264.h:163
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2847
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
H264RawSEIPicTiming pic_timing
uint32_t cpb_removal_delay
Definition: cbs_h264.h:260
AVFormatContext * ctx
Definition: movenc.c:48
uint8_t colour_description_present_flag
Definition: cbs_h264.h:80
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2130
unsigned int va_rt_format
Definition: vaapi_encode.h:100
uint32_t dpb_output_delay
Definition: cbs_h264.h:261
uint8_t video_signal_type_present_flag
Definition: cbs_h264.h:77
int level
level
Definition: avcodec.h:2956
void * codec_picture_params
Definition: vaapi_encode.h:172
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:210
uint8_t pic_parameter_set_id
Definition: cbs_h264.h:352
uint8_t chroma_format_idc
Definition: cbs_h264.h:127
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:122
#define FF_ARRAY_ELEMS(a)
uint8_t profile_idc
Definition: cbs_h264.h:115
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:512
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:270
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:83
uint32_t bit_rate_value_minus1[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:58
uint8_t cpb_cnt_minus1
Definition: cbs_h264.h:54
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:113
uint8_t chroma_loc_info_present_flag
Definition: cbs_h264.h:85
uint8_t cbr_flag[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:60
const struct VAAPIEncodeType * codec
Definition: vaapi_encode.h:93
Libavcodec external API header.
#define FF_PROFILE_H264_HIGH_422_INTRA
Definition: avcodec.h:2894
int compression_level
Definition: avcodec.h:1593
uint8_t bottom_field_pic_order_in_frame_present_flag
Definition: cbs_h264.h:188
uint8_t entropy_coding_mode_flag
Definition: cbs_h264.h:187
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
main external API structure.
Definition: avcodec.h:1521
GLint GLenum type
Definition: opengl_enc.c:105
#define FF_PROFILE_H264_HIGH_10_INTRA
Definition: avcodec.h:2891
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
uint8_t pic_order_cnt_type
Definition: cbs_h264.h:139
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:159
uint8_t matrix_coefficients
Definition: cbs_h264.h:83
uint8_t num_ref_idx_l0_default_active_minus1
Definition: cbs_h264.h:202
int index
Definition: gxfenc.c:89
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2144
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2137
uint16_t frame_num
Definition: cbs_h264.h:356
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
recovery point (frame # to decoder sync)
Definition: h264_sei.h:34
#define FF_PROFILE_H264_HIGH_444
Definition: avcodec.h:2896
uint8_t log2_max_mv_length_horizontal
Definition: cbs_h264.h:106
uint8_t direct_spatial_mv_pred_flag
Definition: cbs_h264.h:367
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:101
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:1802
#define snprintf
Definition: snprintf.h:34
H264RawSEIBufferingPeriod buffering_period
Definition: cbs_h264.h:322
H264RawSEIPayload payload[H264_MAX_SEI_PAYLOADS]
Definition: cbs_h264.h:342
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
mfxU16 profile
Definition: qsvenc.c:44
CodedBitstreamFragment current_access_unit
uint8_t level
Definition: svq3.c:207
uint8_t direct_8x8_inference_flag
Definition: cbs_h264.h:155
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1715
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:237
int
common internal api header.
common internal and external API header
if(ret< 0)
Definition: vf_mcdeint.c:279
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
uint8_t redundant_pic_cnt_present_flag
Definition: cbs_h264.h:217
H264RawSEIUserDataUnregistered identifier
uint8_t cpb_removal_delay_length_minus1
Definition: cbs_h264.h:63
uint8_t motion_vectors_over_pic_boundaries_flag
Definition: cbs_h264.h:103
uint32_t time_scale
Definition: cbs_h264.h:91
int ff_vaapi_encode2(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *input_image, int *got_packet)
Definition: vaapi_encode.c:853
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
uint8_t bitstream_restriction_flag
Definition: cbs_h264.h:102
uint8_t level_idc
Definition: cbs_h264.h:123
uint16_t frame_crop_right_offset
Definition: cbs_h264.h:159
int den
Denominator.
Definition: rational.h:60
uint8_t pic_parameter_set_id
Definition: cbs_h264.h:184
uint8_t max_num_reorder_frames
Definition: cbs_h264.h:108
void * priv_data
Definition: avcodec.h:1548
#define PROFILE(name, value)
uint8_t log2_max_mv_length_vertical
Definition: cbs_h264.h:107
H264RawSliceHeader header
Definition: cbs_h264.h:425
H264RawSEIBufferingPeriod buffering_period
uint8_t log2_max_pic_order_cnt_lsb_minus4
Definition: cbs_h264.h:140
int len
static av_cold int vaapi_encode_h264_close(AVCodecContext *avctx)
void * codec_slice_params
Definition: vaapi_encode.h:52
uint8_t delta_pic_order_always_zero_flag
Definition: cbs_h264.h:141
#define FF_PROFILE_H264_HIGH_444_INTRA
Definition: avcodec.h:2898
int8_t pic_init_qp_minus26
Definition: cbs_h264.h:208
#define LIBAVCODEC_IDENT
Definition: version.h:42
uint8_t nal_ref_idc
Definition: cbs_h264.h:42
struct VAAPIEncodeContext::@145 hrd_params
#define av_freep(p)
uint8_t constraint_set1_flag
Definition: cbs_h264.h:117
#define FF_PROFILE_H264_CONSTRAINED
Definition: avcodec.h:2882
uint16_t pic_height_in_map_units_minus1
Definition: cbs_h264.h:151
#define FF_PROFILE_H264_CONSTRAINED_BASELINE
Definition: avcodec.h:2886
VABufferID output_buffer
Definition: vaapi_encode.h:77
#define FF_PROFILE_H264_HIGH_10
Definition: avcodec.h:2890
uint8_t nal_unit_type
Definition: cbs_h264.h:43
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
uint8_t payload_count
Definition: cbs_h264.h:343
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
H264RawSEIRecoveryPoint recovery_point
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2394
AVVAAPIDeviceContext * hwctx
Definition: vaapi_encode.h:128
uint8_t constraint_set3_flag
Definition: cbs_h264.h:119