FFmpeg: libavcodec/vaapi_encode_h264.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /