FFmpeg
vaapi_encode_mpeg2.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 <va/va.h>
20 #include <va/va_enc_mpeg2.h>
21 
22 #include "libavutil/avassert.h"
23 
24 #include "avcodec.h"
25 #include "cbs.h"
26 #include "cbs_mpeg2.h"
27 #include "mpeg12.h"
28 #include "vaapi_encode.h"
29 
30 typedef struct VAAPIEncodeMPEG2Context {
32 
33  // User options.
34  int profile;
35  int level;
36 
37  // Derived settings.
38  int quant_i;
39  int quant_p;
40  int quant_b;
41 
42  unsigned int bit_rate;
43  unsigned int vbv_buffer_size;
44 
46 
47  unsigned int f_code_horizontal;
48  unsigned int f_code_vertical;
49 
50  // Stream state.
51  int64_t last_i_frame;
52 
53  // Writer structures.
60 
64 
65 
67  char *data, size_t *data_len,
69 {
70  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
71  int err;
72 
73  err = ff_cbs_write_fragment_data(priv->cbc, frag);
74  if (err < 0) {
75  av_log(avctx, AV_LOG_ERROR, "Failed to write packed header.\n");
76  return err;
77  }
78 
79  if (*data_len < 8 * frag->data_size - frag->data_bit_padding) {
80  av_log(avctx, AV_LOG_ERROR, "Access unit too large: "
81  "%zu < %zu.\n", *data_len,
82  8 * frag->data_size - frag->data_bit_padding);
83  return AVERROR(ENOSPC);
84  }
85 
86  memcpy(data, frag->data, frag->data_size);
87  *data_len = 8 * frag->data_size - frag->data_bit_padding;
88 
89  return 0;
90 }
91 
94  int type, void *header)
95 {
96  int err;
97 
98  err = ff_cbs_insert_unit_content(frag, -1, type, header, NULL);
99  if (err < 0) {
100  av_log(avctx, AV_LOG_ERROR, "Failed to add header: "
101  "type = %d.\n", type);
102  return err;
103  }
104 
105  return 0;
106 }
107 
109  char *data, size_t *data_len)
110 {
111  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
113  int err;
114 
116  &priv->sequence_header);
117  if (err < 0)
118  goto fail;
119 
121  &priv->sequence_extension);
122  if (err < 0)
123  goto fail;
124 
127  if (err < 0)
128  goto fail;
129 
131  &priv->gop_header);
132  if (err < 0)
133  goto fail;
134 
135  err = vaapi_encode_mpeg2_write_fragment(avctx, data, data_len, frag);
136 fail:
137  ff_cbs_fragment_reset(frag);
138  return 0;
139 }
140 
142  VAAPIEncodePicture *pic,
143  char *data, size_t *data_len)
144 {
145  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
147  int err;
148 
150  &priv->picture_header);
151  if (err < 0)
152  goto fail;
153 
155  &priv->picture_coding_extension);
156  if (err < 0)
157  goto fail;
158 
159  err = vaapi_encode_mpeg2_write_fragment(avctx, data, data_len, frag);
160 fail:
161  ff_cbs_fragment_reset(frag);
162  return 0;
163 }
164 
166 {
167  VAAPIEncodeContext *ctx = avctx->priv_data;
168  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
175  VAEncSequenceParameterBufferMPEG2 *vseq = ctx->codec_sequence_params;
176  VAEncPictureParameterBufferMPEG2 *vpic = ctx->codec_picture_params;
177  int code, ext_n, ext_d;
178 
179  memset(sh, 0, sizeof(*sh));
180  memset(se, 0, sizeof(*se));
181  memset(sde, 0, sizeof(*sde));
182  memset(goph, 0, sizeof(*goph));
183  memset(ph, 0, sizeof(*ph));
184  memset(pce, 0, sizeof(*pce));
185 
186 
187  if (ctx->va_bit_rate > 0) {
188  priv->bit_rate = (ctx->va_bit_rate + 399) / 400;
189  } else {
190  // Unknown (not a bitrate-targetting mode), so just use the
191  // highest value.
192  priv->bit_rate = 0x3fffffff;
193  }
194  if (avctx->rc_buffer_size > 0) {
195  priv->vbv_buffer_size = (avctx->rc_buffer_size + (1 << 14) - 1) >> 14;
196  } else {
197  // Unknown, so guess a value from the bitrate.
198  priv->vbv_buffer_size = priv->bit_rate >> 14;
199  }
200 
201  switch (avctx->level) {
202  case 4: // High.
203  case 6: // High 1440.
204  priv->f_code_horizontal = 9;
205  priv->f_code_vertical = 5;
206  break;
207  case 8: // Main.
208  priv->f_code_horizontal = 8;
209  priv->f_code_vertical = 5;
210  break;
211  case 10: // Low.
212  default:
213  priv->f_code_horizontal = 7;
214  priv->f_code_vertical = 4;
215  break;
216  }
217 
218 
219  // Sequence header
220 
222 
223  sh->horizontal_size_value = avctx->width & 0xfff;
224  sh->vertical_size_value = avctx->height & 0xfff;
225 
226  if (avctx->sample_aspect_ratio.num != 0 &&
227  avctx->sample_aspect_ratio.den != 0) {
229  (AVRational) { avctx->width, avctx->height });
230 
231  if (av_cmp_q(avctx->sample_aspect_ratio, (AVRational) { 1, 1 }) == 0) {
232  sh->aspect_ratio_information = 1;
233  } else if (av_cmp_q(dar, (AVRational) { 3, 4 }) == 0) {
234  sh->aspect_ratio_information = 2;
235  } else if (av_cmp_q(dar, (AVRational) { 9, 16 }) == 0) {
236  sh->aspect_ratio_information = 3;
237  } else if (av_cmp_q(dar, (AVRational) { 100, 221 }) == 0) {
238  sh->aspect_ratio_information = 4;
239  } else {
240  av_log(avctx, AV_LOG_WARNING, "Sample aspect ratio %d:%d is not "
241  "representable, signalling square pixels instead.\n",
242  avctx->sample_aspect_ratio.num,
243  avctx->sample_aspect_ratio.den);
244  sh->aspect_ratio_information = 1;
245  }
246  } else {
247  // Unknown - assume square pixels.
248  sh->aspect_ratio_information = 1;
249  }
250 
251  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
252  priv->frame_rate = avctx->framerate;
253  else
254  priv->frame_rate = av_inv_q(avctx->time_base);
256  &code, &ext_n, &ext_d, 0);
257  sh->frame_rate_code = code;
258 
259  sh->bit_rate_value = priv->bit_rate & 0x3ffff;
260  sh->vbv_buffer_size_value = priv->vbv_buffer_size & 0x3ff;
261 
265 
266 
267  // Sequence extension
268 
272 
273  se->profile_and_level_indication = avctx->profile << 4 | avctx->level;
274  se->progressive_sequence = 1;
275  se->chroma_format = 1;
276 
277  se->horizontal_size_extension = avctx->width >> 12;
278  se->vertical_size_extension = avctx->height >> 12;
279 
280  se->bit_rate_extension = priv->bit_rate >> 18;
281  se->vbv_buffer_size_extension = priv->vbv_buffer_size >> 10;
282  se->low_delay = ctx->b_per_p == 0;
283 
284  se->frame_rate_extension_n = ext_n;
285  se->frame_rate_extension_d = ext_d;
286 
287 
288  // Sequence display extension
289 
294 
295  sde->video_format = 5;
296  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
297  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
298  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
299  sde->colour_description = 1;
300  sde->colour_primaries = avctx->color_primaries;
301  sde->transfer_characteristics = avctx->color_trc;
302  sde->matrix_coefficients = avctx->colorspace;
303  } else {
304  sde->colour_description = 0;
305  }
306 
307  sde->display_horizontal_size = avctx->width;
308  sde->display_vertical_size = avctx->height;
309 
310 
311  // GOP header
312 
314 
315  // Marker bit in the middle of time_code.
316  goph->time_code = 1 << 12;
317  goph->closed_gop = 1;
318  goph->broken_link = 0;
319 
320 
321  // Defaults for picture header
322 
324 
325  ph->vbv_delay = 0xffff; // Not currently calculated.
326 
327  ph->full_pel_forward_vector = 0;
328  ph->forward_f_code = 7;
329  ph->full_pel_backward_vector = 0;
330  ph->forward_f_code = 7;
331 
332 
333  // Defaults for picture coding extension
334 
339 
340  pce->intra_dc_precision = 0;
341  pce->picture_structure = 3;
342  pce->top_field_first = 0;
343  pce->frame_pred_frame_dct = 1;
345  pce->q_scale_type = 0;
346  pce->intra_vlc_format = 0;
347  pce->alternate_scan = 0;
348  pce->repeat_first_field = 0;
349  pce->progressive_frame = 1;
350  pce->composite_display_flag = 0;
351 
352 
353 
354  *vseq = (VAEncSequenceParameterBufferMPEG2) {
355  .intra_period = ctx->gop_size,
356  .ip_period = ctx->b_per_p + 1,
357 
358  .picture_width = avctx->width,
359  .picture_height = avctx->height,
360 
361  .bits_per_second = ctx->va_bit_rate,
362  .frame_rate = av_q2d(priv->frame_rate),
363  .aspect_ratio_information = sh->aspect_ratio_information,
364  .vbv_buffer_size = priv->vbv_buffer_size,
365 
366  .sequence_extension.bits = {
367  .profile_and_level_indication = se->profile_and_level_indication,
368  .progressive_sequence = se->progressive_sequence,
369  .chroma_format = se->chroma_format,
370  .low_delay = se->low_delay,
371  .frame_rate_extension_n = se->frame_rate_extension_n,
372  .frame_rate_extension_d = se->frame_rate_extension_d,
373  },
374 
375  .new_gop_header = 1,
376  .gop_header.bits = {
377  .time_code = goph->time_code,
378  .closed_gop = goph->closed_gop,
379  .broken_link = goph->broken_link,
380  },
381  };
382 
383  *vpic = (VAEncPictureParameterBufferMPEG2) {
384  .forward_reference_picture = VA_INVALID_ID,
385  .backward_reference_picture = VA_INVALID_ID,
386  .reconstructed_picture = VA_INVALID_ID,
387  .coded_buf = VA_INVALID_ID,
388 
389  .vbv_delay = 0xffff,
390  .f_code = { { 15, 15 }, { 15, 15 } },
391 
392  .picture_coding_extension.bits = {
393  .intra_dc_precision = pce->intra_dc_precision,
394  .picture_structure = pce->picture_structure,
395  .top_field_first = pce->top_field_first,
396  .frame_pred_frame_dct = pce->frame_pred_frame_dct,
397  .concealment_motion_vectors = pce->concealment_motion_vectors,
398  .q_scale_type = pce->q_scale_type,
399  .intra_vlc_format = pce->intra_vlc_format,
400  .alternate_scan = pce->alternate_scan,
401  .repeat_first_field = pce->repeat_first_field,
402  .progressive_frame = pce->progressive_frame,
403  .composite_display_flag = pce->composite_display_flag,
404  },
405 
406  .composite_display.bits = {
407  .v_axis = pce->v_axis,
408  .field_sequence = pce->field_sequence,
409  .sub_carrier = pce->sub_carrier,
410  .burst_amplitude = pce->burst_amplitude,
411  .sub_carrier_phase = pce->sub_carrier_phase,
412  },
413  };
414 
415  return 0;
416 }
417 
419  VAAPIEncodePicture *pic)
420 {
421  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
424  VAEncPictureParameterBufferMPEG2 *vpic = pic->codec_picture_params;
425 
426  if (pic->type == PICTURE_TYPE_IDR || pic->type == PICTURE_TYPE_I) {
427  ph->temporal_reference = 0;
428  ph->picture_coding_type = 1;
429  priv->last_i_frame = pic->display_order;
430  } else {
431  ph->temporal_reference = pic->display_order - priv->last_i_frame;
432  ph->picture_coding_type = pic->type == PICTURE_TYPE_B ? 3 : 2;
433  }
434 
435  if (pic->type == PICTURE_TYPE_P || pic->type == PICTURE_TYPE_B) {
436  pce->f_code[0][0] = priv->f_code_horizontal;
437  pce->f_code[0][1] = priv->f_code_vertical;
438  } else {
439  pce->f_code[0][0] = 15;
440  pce->f_code[0][1] = 15;
441  }
442  if (pic->type == PICTURE_TYPE_B) {
443  pce->f_code[1][0] = priv->f_code_horizontal;
444  pce->f_code[1][1] = priv->f_code_vertical;
445  } else {
446  pce->f_code[1][0] = 15;
447  pce->f_code[1][1] = 15;
448  }
449 
450  vpic->reconstructed_picture = pic->recon_surface;
451  vpic->coded_buf = pic->output_buffer;
452 
453  switch (pic->type) {
454  case PICTURE_TYPE_IDR:
455  case PICTURE_TYPE_I:
456  vpic->picture_type = VAEncPictureTypeIntra;
457  break;
458  case PICTURE_TYPE_P:
459  vpic->picture_type = VAEncPictureTypePredictive;
460  vpic->forward_reference_picture = pic->refs[0]->recon_surface;
461  break;
462  case PICTURE_TYPE_B:
463  vpic->picture_type = VAEncPictureTypeBidirectional;
464  vpic->forward_reference_picture = pic->refs[0]->recon_surface;
465  vpic->backward_reference_picture = pic->refs[1]->recon_surface;
466  break;
467  default:
468  av_assert0(0 && "invalid picture type");
469  }
470 
471  vpic->temporal_reference = ph->temporal_reference;
472  vpic->f_code[0][0] = pce->f_code[0][0];
473  vpic->f_code[0][1] = pce->f_code[0][1];
474  vpic->f_code[1][0] = pce->f_code[1][0];
475  vpic->f_code[1][1] = pce->f_code[1][1];
476 
477  return 0;
478 }
479 
481  VAAPIEncodePicture *pic,
482  VAAPIEncodeSlice *slice)
483 {
484  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
485  VAEncSliceParameterBufferMPEG2 *vslice = slice->codec_slice_params;
486  int qp;
487 
488  vslice->macroblock_address = slice->block_start;
489  vslice->num_macroblocks = slice->block_size;
490 
491  switch (pic->type) {
492  case PICTURE_TYPE_IDR:
493  case PICTURE_TYPE_I:
494  qp = priv->quant_i;
495  break;
496  case PICTURE_TYPE_P:
497  qp = priv->quant_p;
498  break;
499  case PICTURE_TYPE_B:
500  qp = priv->quant_b;
501  break;
502  default:
503  av_assert0(0 && "invalid picture type");
504  }
505 
506  vslice->quantiser_scale_code = qp;
507  vslice->is_intra_slice = (pic->type == PICTURE_TYPE_IDR ||
508  pic->type == PICTURE_TYPE_I);
509 
510  return 0;
511 }
512 
514 {
515  VAAPIEncodeContext *ctx = avctx->priv_data;
516  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
517  int err;
518 
519  err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_MPEG2VIDEO, avctx);
520  if (err < 0)
521  return err;
522 
523  if (ctx->va_rc_mode == VA_RC_CQP) {
524  priv->quant_p = av_clip(ctx->rc_quality, 1, 31);
525  if (avctx->i_quant_factor > 0.0)
526  priv->quant_i =
527  av_clip((avctx->i_quant_factor * priv->quant_p +
528  avctx->i_quant_offset) + 0.5, 1, 31);
529  else
530  priv->quant_i = priv->quant_p;
531  if (avctx->b_quant_factor > 0.0)
532  priv->quant_b =
533  av_clip((avctx->b_quant_factor * priv->quant_p +
534  avctx->b_quant_offset) + 0.5, 1, 31);
535  else
536  priv->quant_b = priv->quant_p;
537 
538  av_log(avctx, AV_LOG_DEBUG, "Using fixed quantiser "
539  "%d / %d / %d for I- / P- / B-frames.\n",
540  priv->quant_i, priv->quant_p, priv->quant_b);
541 
542  } else {
543  priv->quant_i = 16;
544  priv->quant_p = 16;
545  priv->quant_b = 16;
546  }
547 
548  ctx->slice_block_rows = FFALIGN(avctx->height, 16) / 16;
549  ctx->slice_block_cols = FFALIGN(avctx->width, 16) / 16;
550 
551  ctx->nb_slices = ctx->slice_block_rows;
552  ctx->slice_size = 1;
553 
554  ctx->roi_quant_range = 31;
555 
556  return 0;
557 }
558 
560  { FF_PROFILE_MPEG2_MAIN, 8, 3, 1, 1, VAProfileMPEG2Main },
561  { FF_PROFILE_MPEG2_SIMPLE, 8, 3, 1, 1, VAProfileMPEG2Simple },
563 };
564 
567 
568  .flags = FLAG_B_PICTURES,
569 
570  .configure = &vaapi_encode_mpeg2_configure,
571 
572  .default_quality = 10,
573 
574  .sequence_params_size = sizeof(VAEncSequenceParameterBufferMPEG2),
575  .init_sequence_params = &vaapi_encode_mpeg2_init_sequence_params,
576 
577  .picture_params_size = sizeof(VAEncPictureParameterBufferMPEG2),
578  .init_picture_params = &vaapi_encode_mpeg2_init_picture_params,
579 
580  .slice_params_size = sizeof(VAEncSliceParameterBufferMPEG2),
581  .init_slice_params = &vaapi_encode_mpeg2_init_slice_params,
582 
583  .sequence_header_type = VAEncPackedHeaderSequence,
584  .write_sequence_header = &vaapi_encode_mpeg2_write_sequence_header,
585 
586  .picture_header_type = VAEncPackedHeaderPicture,
587  .write_picture_header = &vaapi_encode_mpeg2_write_picture_header,
588 };
589 
591 {
592  VAAPIEncodeContext *ctx = avctx->priv_data;
593  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
594 
596 
597  if (avctx->profile == FF_PROFILE_UNKNOWN)
598  avctx->profile = priv->profile;
599  if (avctx->level == FF_LEVEL_UNKNOWN)
600  avctx->level = priv->level;
601 
602  // Reject unknown levels (these are required to set f_code for
603  // motion vector encoding).
604  switch (avctx->level) {
605  case 4: // High
606  case 6: // High 1440
607  case 8: // Main
608  case 10: // Low
609  break;
610  default:
611  av_log(avctx, AV_LOG_ERROR, "Unknown MPEG-2 level %d.\n",
612  avctx->level);
613  return AVERROR(EINVAL);
614  }
615 
616  if (avctx->height % 4096 == 0 || avctx->width % 4096 == 0) {
617  av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support picture "
618  "height or width divisible by 4096.\n");
619  return AVERROR(EINVAL);
620  }
621 
622  ctx->desired_packed_headers = VA_ENC_PACKED_HEADER_SEQUENCE |
623  VA_ENC_PACKED_HEADER_PICTURE;
624 
625  ctx->surface_width = FFALIGN(avctx->width, 16);
626  ctx->surface_height = FFALIGN(avctx->height, 16);
627 
628  return ff_vaapi_encode_init(avctx);
629 }
630 
632 {
633  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
634 
636  ff_cbs_close(&priv->cbc);
637 
638  return ff_vaapi_encode_close(avctx);
639 }
640 
641 #define OFFSET(x) offsetof(VAAPIEncodeMPEG2Context, x)
642 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
646 
647  { "profile", "Set profile (in profile_and_level_indication)",
649  { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 7, FLAGS, "profile" },
650 
651 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
652  { .i64 = value }, 0, 0, FLAGS, "profile"
653  { PROFILE("simple", FF_PROFILE_MPEG2_SIMPLE) },
654  { PROFILE("main", FF_PROFILE_MPEG2_MAIN) },
655 #undef PROFILE
656 
657  { "level", "Set level (in profile_and_level_indication)",
659  { .i64 = 4 }, 0, 15, FLAGS, "level" },
660 
661 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
662  { .i64 = value }, 0, 0, FLAGS, "level"
663  { LEVEL("low", 10) },
664  { LEVEL("main", 8) },
665  { LEVEL("high_1440", 6) },
666  { LEVEL("high", 4) },
667 #undef LEVEL
668 
669  { NULL },
670 };
671 
673  { "b", "0" },
674  { "bf", "1" },
675  { "g", "120" },
676  { "i_qfactor", "1" },
677  { "i_qoffset", "0" },
678  { "b_qfactor", "6/5" },
679  { "b_qoffset", "0" },
680  { "qmin", "-1" },
681  { "qmax", "-1" },
682  { NULL },
683 };
684 
686  .class_name = "mpeg2_vaapi",
687  .item_name = av_default_item_name,
688  .option = vaapi_encode_mpeg2_options,
689  .version = LIBAVUTIL_VERSION_INT,
690 };
691 
693  .name = "mpeg2_vaapi",
694  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 (VAAPI)"),
695  .type = AVMEDIA_TYPE_VIDEO,
697  .priv_data_size = sizeof(VAAPIEncodeMPEG2Context),
699  .receive_packet = &ff_vaapi_encode_receive_packet,
700  .close = &vaapi_encode_mpeg2_close,
701  .priv_class = &vaapi_encode_mpeg2_class,
702  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE,
703  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
704  .defaults = vaapi_encode_mpeg2_defaults,
705  .pix_fmts = (const enum AVPixelFormat[]) {
708  },
709  .hw_configs = ff_vaapi_encode_hw_configs,
710  .wrapper_name = "vaapi",
711 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
static av_cold int vaapi_encode_mpeg2_configure(AVCodecContext *avctx)
MPEG2RawExtensionData sequence_extension
uint8_t full_pel_backward_vector
Definition: cbs_mpeg2.h:132
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:2069
uint8_t load_non_intra_quantiser_matrix
Definition: cbs_mpeg2.h:72
uint8_t picture_start_code
Definition: cbs_mpeg2.h:124
uint8_t extension_start_code_identifier
Definition: cbs_mpeg2.h:179
#define FF_PROFILE_MPEG2_MAIN
Definition: avcodec.h:1892
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
#define se(name, range_min, range_max)
Definition: cbs_h2645.c:273
AVOption.
Definition: opt.h:248
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static const VAAPIEncodeProfile vaapi_encode_mpeg2_profiles[]
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
MPEG2RawSequenceExtension sequence
Definition: cbs_mpeg2.h:182
union MPEG2RawExtensionData::@41 data
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:150
int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:74
int num
Numerator.
Definition: rational.h:59
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:905
GLint GLenum type
Definition: opengl_enc.c:104
MPEG2RawExtensionData sequence_display_extension
void * codec_sequence_params
Definition: vaapi_encode.h:274
static av_cold int vaapi_encode_mpeg2_init(AVCodecContext *avctx)
int profile
profile
Definition: avcodec.h:1859
AVCodec.
Definition: codec.h:190
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:838
#define FLAGS
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:649
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1983
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:75
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint16_t vertical_size_value
Definition: cbs_mpeg2.h:63
static int vaapi_encode_mpeg2_write_picture_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, char *data, size_t *data_len)
#define av_cold
Definition: attributes.h:88
static int vaapi_encode_mpeg2_add_header(AVCodecContext *avctx, CodedBitstreamFragment *frag, int type, void *header)
static const AVClass vaapi_encode_mpeg2_class
uint8_t load_intra_quantiser_matrix
Definition: cbs_mpeg2.h:70
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
Definition: avcodec.h:795
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
VASurfaceID recon_surface
Definition: vaapi_encode.h:94
static const uint8_t header[24]
Definition: sdr2.c:67
MPEG2RawSequenceHeader sequence_header
static int vaapi_encode_mpeg2_write_fragment(AVCodecContext *avctx, char *data, size_t *data_len, CodedBitstreamFragment *frag)
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
uint8_t constrained_parameters_flag
Definition: cbs_mpeg2.h:68
void ff_cbs_fragment_reset(CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment&#39;s own data buffer, but not the units a...
Definition: cbs.c:141
MPEG2RawPictureCodingExtension picture_coding
Definition: cbs_mpeg2.h:185
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:131
unsigned int va_rc_mode
Definition: vaapi_encode.h:230
AVCodec ff_mpeg2_vaapi_encoder
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static int vaapi_encode_mpeg2_init_picture_params(AVCodecContext *avctx, VAAPIEncodePicture *pic)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
const AVCodecHWConfigInternal * ff_vaapi_encode_hw_configs[]
Definition: vaapi_encode.c:31
static const AVCodecDefault vaapi_encode_mpeg2_defaults[]
MPEG2RawPictureHeader picture_header
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: codec.h:197
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
Definition: avcodec.h:831
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
unsigned int va_bit_rate
Definition: vaapi_encode.h:232
void ff_mpeg12_find_best_frame_rate(AVRational frame_rate, int *code, int *ext_n, int *ext_d, int nonstandard)
void * codec_picture_params
Definition: vaapi_encode.h:103
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:135
#define fail()
Definition: checkasm.h:123
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1389
CodedBitstreamContext * cbc
#define PROFILE(name, value)
static av_cold int vaapi_encode_mpeg2_close(AVCodecContext *avctx)
static int vaapi_encode_mpeg2_init_sequence_params(AVCodecContext *avctx)
int width
picture width / height.
Definition: avcodec.h:699
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1860
const VAAPIEncodeProfile * profiles
Definition: vaapi_encode.h:369
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
AVFormatContext * ctx
Definition: movenc.c:48
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1140
int level
level
Definition: avcodec.h:1982
VAAPIEncodeContext common
void * codec_picture_params
Definition: vaapi_encode.h:278
int ff_vaapi_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
uint8_t horizontal_size_extension
Definition: cbs_mpeg2.h:88
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:124
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:336
struct VAAPIEncodePicture * refs[MAX_PICTURE_REFERENCES]
Definition: vaapi_encode.h:116
static int vaapi_encode_mpeg2_init_slice_params(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice)
const struct VAAPIEncodeType * codec
Definition: vaapi_encode.h:179
Libavcodec external API header.
#define VAAPI_ENCODE_RC_OPTIONS
Definition: vaapi_encode.h:463
MPEG2RawSequenceDisplayExtension sequence_display
Definition: cbs_mpeg2.h:183
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:118
main external API structure.
Definition: avcodec.h:526
uint8_t full_pel_forward_vector
Definition: cbs_mpeg2.h:130
uint8_t frame_rate_extension_n
Definition: cbs_mpeg2.h:93
uint8_t vbv_buffer_size_extension
Definition: cbs_mpeg2.h:91
uint8_t sequence_header_code
Definition: cbs_mpeg2.h:60
uint8_t frame_rate_extension_d
Definition: cbs_mpeg2.h:94
static const AVOption vaapi_encode_mpeg2_options[]
CodedBitstreamFragment current_fragment
Describe the class of an AVClass context structure.
Definition: log.h:67
Context structure for coded bitstream operations.
Definition: cbs.h:170
#define LEVEL(name, value)
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
MPEG2RawExtensionData picture_coding_extension
static const VAAPIEncodeType vaapi_encode_type_mpeg2
uint8_t extension_start_code
Definition: cbs_mpeg2.h:178
uint16_t horizontal_size_value
Definition: cbs_mpeg2.h:62
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:715
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:115
uint16_t temporal_reference
Definition: cbs_mpeg2.h:126
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:808
uint8_t aspect_ratio_information
Definition: cbs_mpeg2.h:64
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:300
uint8_t picture_coding_type
Definition: cbs_mpeg2.h:127
#define VAAPI_ENCODE_COMMON_OPTIONS
Definition: vaapi_encode.h:445
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
uint16_t vbv_buffer_size_value
Definition: cbs_mpeg2.h:67
uint32_t bit_rate_value
Definition: cbs_mpeg2.h:66
int den
Denominator.
Definition: rational.h:60
void * priv_data
Definition: avcodec.h:553
uint8_t profile_and_level_indication
Definition: cbs_mpeg2.h:85
#define OFFSET(x)
uint8_t vertical_size_extension
Definition: cbs_mpeg2.h:89
#define FF_PROFILE_MPEG2_SIMPLE
Definition: avcodec.h:1893
void * codec_slice_params
Definition: vaapi_encode.h:67
MPEG2RawGroupOfPicturesHeader gop_header
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:155
unsigned int desired_packed_headers
Definition: vaapi_encode.h:201
static int vaapi_encode_mpeg2_write_sequence_header(AVCodecContext *avctx, char *data, size_t *data_len)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
VABufferID output_buffer
Definition: vaapi_encode.h:100
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)