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 #include "libavutil/opt.h"
24 
25 #include "avcodec.h"
26 #include "cbs.h"
27 #include "cbs_mpeg2.h"
28 #include "codec_internal.h"
29 #include "mpeg12.h"
30 #include "vaapi_encode.h"
31 
32 typedef struct VAAPIEncodeMPEG2Context {
34 
35  // User options.
36  int profile;
37  int level;
38 
39  // Derived settings.
40  int quant_i;
41  int quant_p;
42  int quant_b;
43 
44  unsigned int bit_rate;
45  unsigned int vbv_buffer_size;
46 
48 
49  unsigned int f_code_horizontal;
50  unsigned int f_code_vertical;
51 
52  // Stream state.
54 
55  // Writer structures.
62 
66 
67 
69  char *data, size_t *data_len,
71 {
72  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
73  int err;
74 
75  err = ff_cbs_write_fragment_data(priv->cbc, frag);
76  if (err < 0) {
77  av_log(avctx, AV_LOG_ERROR, "Failed to write packed header.\n");
78  return err;
79  }
80 
81  if (*data_len < 8 * frag->data_size - frag->data_bit_padding) {
82  av_log(avctx, AV_LOG_ERROR, "Access unit too large: "
83  "%zu < %zu.\n", *data_len,
84  8 * frag->data_size - frag->data_bit_padding);
85  return AVERROR(ENOSPC);
86  }
87 
88  memcpy(data, frag->data, frag->data_size);
89  *data_len = 8 * frag->data_size - frag->data_bit_padding;
90 
91  return 0;
92 }
93 
96  int type, void *header)
97 {
98  int err;
99 
100  err = ff_cbs_insert_unit_content(frag, -1, type, header, NULL);
101  if (err < 0) {
102  av_log(avctx, AV_LOG_ERROR, "Failed to add header: "
103  "type = %d.\n", type);
104  return err;
105  }
106 
107  return 0;
108 }
109 
111  char *data, size_t *data_len)
112 {
113  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
115  int err;
116 
118  &priv->sequence_header);
119  if (err < 0)
120  goto fail;
121 
123  &priv->sequence_extension);
124  if (err < 0)
125  goto fail;
126 
129  if (err < 0)
130  goto fail;
131 
133  &priv->gop_header);
134  if (err < 0)
135  goto fail;
136 
137  err = vaapi_encode_mpeg2_write_fragment(avctx, data, data_len, frag);
138 fail:
139  ff_cbs_fragment_reset(frag);
140  return 0;
141 }
142 
145  char *data, size_t *data_len)
146 {
147  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
149  int err;
150 
152  &priv->picture_header);
153  if (err < 0)
154  goto fail;
155 
157  &priv->picture_coding_extension);
158  if (err < 0)
159  goto fail;
160 
161  err = vaapi_encode_mpeg2_write_fragment(avctx, data, data_len, frag);
162 fail:
163  ff_cbs_fragment_reset(frag);
164  return 0;
165 }
166 
168 {
169  FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
170  VAAPIEncodeContext *ctx = avctx->priv_data;
171  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
178  VAEncSequenceParameterBufferMPEG2 *vseq = ctx->codec_sequence_params;
179  VAEncPictureParameterBufferMPEG2 *vpic = ctx->codec_picture_params;
180  int code, ext_n, ext_d;
181 
182  memset(sh, 0, sizeof(*sh));
183  memset(se, 0, sizeof(*se));
184  memset(sde, 0, sizeof(*sde));
185  memset(goph, 0, sizeof(*goph));
186  memset(ph, 0, sizeof(*ph));
187  memset(pce, 0, sizeof(*pce));
188 
189 
190  if (ctx->va_bit_rate > 0) {
191  priv->bit_rate = (ctx->va_bit_rate + 399) / 400;
192  } else {
193  // Unknown (not a bitrate-targetting mode), so just use the
194  // highest value.
195  priv->bit_rate = 0x3fffffff;
196  }
197  if (avctx->rc_buffer_size > 0) {
198  priv->vbv_buffer_size = (avctx->rc_buffer_size + (1 << 14) - 1) >> 14;
199  } else {
200  // Unknown, so guess a value from the bitrate.
201  priv->vbv_buffer_size = priv->bit_rate >> 14;
202  }
203 
204  switch (avctx->level) {
205  case 4: // High.
206  case 6: // High 1440.
207  priv->f_code_horizontal = 9;
208  priv->f_code_vertical = 5;
209  break;
210  case 8: // Main.
211  priv->f_code_horizontal = 8;
212  priv->f_code_vertical = 5;
213  break;
214  case 10: // Low.
215  default:
216  priv->f_code_horizontal = 7;
217  priv->f_code_vertical = 4;
218  break;
219  }
220 
221 
222  // Sequence header
223 
225 
226  sh->horizontal_size_value = avctx->width & 0xfff;
227  sh->vertical_size_value = avctx->height & 0xfff;
228 
229  if (avctx->sample_aspect_ratio.num != 0 &&
230  avctx->sample_aspect_ratio.den != 0) {
232  (AVRational) { avctx->width, avctx->height });
233 
234  if (av_cmp_q(avctx->sample_aspect_ratio, (AVRational) { 1, 1 }) == 0) {
235  sh->aspect_ratio_information = 1;
236  } else if (av_cmp_q(dar, (AVRational) { 3, 4 }) == 0) {
237  sh->aspect_ratio_information = 2;
238  } else if (av_cmp_q(dar, (AVRational) { 9, 16 }) == 0) {
239  sh->aspect_ratio_information = 3;
240  } else if (av_cmp_q(dar, (AVRational) { 100, 221 }) == 0) {
241  sh->aspect_ratio_information = 4;
242  } else {
243  av_log(avctx, AV_LOG_WARNING, "Sample aspect ratio %d:%d is not "
244  "representable, signalling square pixels instead.\n",
245  avctx->sample_aspect_ratio.num,
246  avctx->sample_aspect_ratio.den);
247  sh->aspect_ratio_information = 1;
248  }
249  } else {
250  // Unknown - assume square pixels.
251  sh->aspect_ratio_information = 1;
252  }
253 
254  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
255  priv->frame_rate = avctx->framerate;
256  else
257  priv->frame_rate = av_inv_q(avctx->time_base);
259  &code, &ext_n, &ext_d, 0);
260  sh->frame_rate_code = code;
261 
262  sh->bit_rate_value = priv->bit_rate & 0x3ffff;
263  sh->vbv_buffer_size_value = priv->vbv_buffer_size & 0x3ff;
264 
268 
269 
270  // Sequence extension
271 
275 
276  se->profile_and_level_indication = avctx->profile << 4 | avctx->level;
277  se->progressive_sequence = 1;
278  se->chroma_format = 1;
279 
280  se->horizontal_size_extension = avctx->width >> 12;
281  se->vertical_size_extension = avctx->height >> 12;
282 
283  se->bit_rate_extension = priv->bit_rate >> 18;
284  se->vbv_buffer_size_extension = priv->vbv_buffer_size >> 10;
285  se->low_delay = base_ctx->b_per_p == 0;
286 
287  se->frame_rate_extension_n = ext_n;
288  se->frame_rate_extension_d = ext_d;
289 
290 
291  // Sequence display extension
292 
297 
298  // Unspecified video format, from table 6-6.
299  sde->video_format = 5;
300 
301  sde->colour_primaries = avctx->color_primaries;
302  sde->transfer_characteristics = avctx->color_trc;
303  sde->matrix_coefficients = avctx->colorspace;
304  sde->colour_description =
306  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
308 
309  sde->display_horizontal_size = avctx->width;
310  sde->display_vertical_size = avctx->height;
311 
312 
313  // GOP header
314 
316 
317  // Marker bit in the middle of time_code.
318  goph->time_code = 1 << 12;
319  goph->closed_gop = 1;
320  goph->broken_link = 0;
321 
322 
323  // Defaults for picture header
324 
325  ph->picture_start_code = MPEG2_START_PICTURE;
326 
327  ph->vbv_delay = 0xffff; // Not currently calculated.
328 
329  ph->full_pel_forward_vector = 0;
330  ph->forward_f_code = 7;
331  ph->full_pel_backward_vector = 0;
332  ph->forward_f_code = 7;
333 
334 
335  // Defaults for picture coding extension
336 
341 
342  pce->intra_dc_precision = 0;
343  pce->picture_structure = 3;
344  pce->top_field_first = 0;
345  pce->frame_pred_frame_dct = 1;
347  pce->q_scale_type = 0;
348  pce->intra_vlc_format = 0;
349  pce->alternate_scan = 0;
350  pce->repeat_first_field = 0;
351  pce->progressive_frame = 1;
352  pce->composite_display_flag = 0;
353 
354 
355 
356  *vseq = (VAEncSequenceParameterBufferMPEG2) {
357  .intra_period = base_ctx->gop_size,
358  .ip_period = base_ctx->b_per_p + 1,
359 
360  .picture_width = avctx->width,
361  .picture_height = avctx->height,
362 
363  .bits_per_second = ctx->va_bit_rate,
364  .frame_rate = av_q2d(priv->frame_rate),
365  .aspect_ratio_information = sh->aspect_ratio_information,
366  .vbv_buffer_size = priv->vbv_buffer_size,
367 
368  .sequence_extension.bits = {
369  .profile_and_level_indication = se->profile_and_level_indication,
370  .progressive_sequence = se->progressive_sequence,
371  .chroma_format = se->chroma_format,
372  .low_delay = se->low_delay,
373  .frame_rate_extension_n = se->frame_rate_extension_n,
374  .frame_rate_extension_d = se->frame_rate_extension_d,
375  },
376 
377  .new_gop_header = 1,
378  .gop_header.bits = {
379  .time_code = goph->time_code,
380  .closed_gop = goph->closed_gop,
381  .broken_link = goph->broken_link,
382  },
383  };
384 
385  *vpic = (VAEncPictureParameterBufferMPEG2) {
386  .forward_reference_picture = VA_INVALID_ID,
387  .backward_reference_picture = VA_INVALID_ID,
388  .reconstructed_picture = VA_INVALID_ID,
389  .coded_buf = VA_INVALID_ID,
390 
391  .vbv_delay = 0xffff,
392  .f_code = { { 15, 15 }, { 15, 15 } },
393 
394  .picture_coding_extension.bits = {
395  .intra_dc_precision = pce->intra_dc_precision,
396  .picture_structure = pce->picture_structure,
397  .top_field_first = pce->top_field_first,
398  .frame_pred_frame_dct = pce->frame_pred_frame_dct,
399  .concealment_motion_vectors = pce->concealment_motion_vectors,
400  .q_scale_type = pce->q_scale_type,
401  .intra_vlc_format = pce->intra_vlc_format,
402  .alternate_scan = pce->alternate_scan,
403  .repeat_first_field = pce->repeat_first_field,
404  .progressive_frame = pce->progressive_frame,
405  .composite_display_flag = pce->composite_display_flag,
406  },
407 
408  .composite_display.bits = {
409  .v_axis = pce->v_axis,
410  .field_sequence = pce->field_sequence,
411  .sub_carrier = pce->sub_carrier,
412  .burst_amplitude = pce->burst_amplitude,
413  .sub_carrier_phase = pce->sub_carrier_phase,
414  },
415  };
416 
417  return 0;
418 }
419 
422 {
423  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
424  VAAPIEncodePicture *vaapi_pic = pic->priv;
427  VAEncPictureParameterBufferMPEG2 *vpic = vaapi_pic->codec_picture_params;
428 
429  if (pic->type == FF_HW_PICTURE_TYPE_IDR || pic->type == FF_HW_PICTURE_TYPE_I) {
430  ph->temporal_reference = 0;
431  ph->picture_coding_type = 1;
432  priv->last_i_frame = pic->display_order;
433  } else {
434  ph->temporal_reference = pic->display_order - priv->last_i_frame;
435  ph->picture_coding_type = pic->type == FF_HW_PICTURE_TYPE_B ? 3 : 2;
436  }
437 
438  if (pic->type == FF_HW_PICTURE_TYPE_P || pic->type == FF_HW_PICTURE_TYPE_B) {
439  pce->f_code[0][0] = priv->f_code_horizontal;
440  pce->f_code[0][1] = priv->f_code_vertical;
441  } else {
442  pce->f_code[0][0] = 15;
443  pce->f_code[0][1] = 15;
444  }
445  if (pic->type == FF_HW_PICTURE_TYPE_B) {
446  pce->f_code[1][0] = priv->f_code_horizontal;
447  pce->f_code[1][1] = priv->f_code_vertical;
448  } else {
449  pce->f_code[1][0] = 15;
450  pce->f_code[1][1] = 15;
451  }
452 
453  vpic->reconstructed_picture = vaapi_pic->recon_surface;
454  vpic->coded_buf = vaapi_pic->output_buffer;
455 
456  switch (pic->type) {
459  vpic->picture_type = VAEncPictureTypeIntra;
460  break;
462  vpic->picture_type = VAEncPictureTypePredictive;
463  vpic->forward_reference_picture = ((VAAPIEncodePicture *)pic->refs[0][0]->priv)->recon_surface;
464  break;
466  vpic->picture_type = VAEncPictureTypeBidirectional;
467  vpic->forward_reference_picture = ((VAAPIEncodePicture *)pic->refs[0][0]->priv)->recon_surface;
468  vpic->backward_reference_picture = ((VAAPIEncodePicture *)pic->refs[1][0]->priv)->recon_surface;
469  break;
470  default:
471  av_assert0(0 && "invalid picture type");
472  }
473 
474  vpic->temporal_reference = ph->temporal_reference;
475  vpic->f_code[0][0] = pce->f_code[0][0];
476  vpic->f_code[0][1] = pce->f_code[0][1];
477  vpic->f_code[1][0] = pce->f_code[1][0];
478  vpic->f_code[1][1] = pce->f_code[1][1];
479 
480  return 0;
481 }
482 
485  VAAPIEncodeSlice *slice)
486 {
487  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
488  VAEncSliceParameterBufferMPEG2 *vslice = slice->codec_slice_params;
489  int qp;
490 
491  vslice->macroblock_address = slice->block_start;
492  vslice->num_macroblocks = slice->block_size;
493 
494  switch (pic->type) {
497  qp = priv->quant_i;
498  break;
500  qp = priv->quant_p;
501  break;
503  qp = priv->quant_b;
504  break;
505  default:
506  av_assert0(0 && "invalid picture type");
507  }
508 
509  vslice->quantiser_scale_code = qp;
510  vslice->is_intra_slice = (pic->type == FF_HW_PICTURE_TYPE_IDR ||
511  pic->type == FF_HW_PICTURE_TYPE_I);
512 
513  return 0;
514 }
515 
517 {
518  VAAPIEncodeContext *ctx = avctx->priv_data;
519  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
520  int err;
521 
522  err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_MPEG2VIDEO, avctx);
523  if (err < 0)
524  return err;
525 
526  if (ctx->va_rc_mode == VA_RC_CQP) {
527  priv->quant_p = av_clip(ctx->rc_quality, 1, 31);
528  if (avctx->i_quant_factor > 0.0)
529  priv->quant_i =
530  av_clip((avctx->i_quant_factor * priv->quant_p +
531  avctx->i_quant_offset) + 0.5, 1, 31);
532  else
533  priv->quant_i = priv->quant_p;
534  if (avctx->b_quant_factor > 0.0)
535  priv->quant_b =
536  av_clip((avctx->b_quant_factor * priv->quant_p +
537  avctx->b_quant_offset) + 0.5, 1, 31);
538  else
539  priv->quant_b = priv->quant_p;
540 
541  av_log(avctx, AV_LOG_DEBUG, "Using fixed quantiser "
542  "%d / %d / %d for I- / P- / B-frames.\n",
543  priv->quant_i, priv->quant_p, priv->quant_b);
544 
545  } else {
546  priv->quant_i = 16;
547  priv->quant_p = 16;
548  priv->quant_b = 16;
549  }
550 
551  ctx->slice_block_rows = FFALIGN(avctx->height, 16) / 16;
552  ctx->slice_block_cols = FFALIGN(avctx->width, 16) / 16;
553 
554  ctx->nb_slices = ctx->slice_block_rows;
555  ctx->slice_size = 1;
556 
557  ctx->roi_quant_range = 31;
558 
559  return 0;
560 }
561 
563  { AV_PROFILE_MPEG2_MAIN, 8, 3, 1, 1, VAProfileMPEG2Main },
564  { AV_PROFILE_MPEG2_SIMPLE, 8, 3, 1, 1, VAProfileMPEG2Simple },
566 };
567 
570 
571  .flags = FF_HW_FLAG_B_PICTURES,
572 
573  .configure = &vaapi_encode_mpeg2_configure,
574 
575  .default_quality = 10,
576 
577  .sequence_params_size = sizeof(VAEncSequenceParameterBufferMPEG2),
578  .init_sequence_params = &vaapi_encode_mpeg2_init_sequence_params,
579 
580  .picture_params_size = sizeof(VAEncPictureParameterBufferMPEG2),
581  .init_picture_params = &vaapi_encode_mpeg2_init_picture_params,
582 
583  .slice_params_size = sizeof(VAEncSliceParameterBufferMPEG2),
584  .init_slice_params = &vaapi_encode_mpeg2_init_slice_params,
585 
586  .sequence_header_type = VAEncPackedHeaderSequence,
587  .write_sequence_header = &vaapi_encode_mpeg2_write_sequence_header,
588 
589  .picture_header_type = VAEncPackedHeaderPicture,
590  .write_picture_header = &vaapi_encode_mpeg2_write_picture_header,
591 };
592 
594 {
595  VAAPIEncodeContext *ctx = avctx->priv_data;
596  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
597 
598  ctx->codec = &vaapi_encode_type_mpeg2;
599 
600  if (avctx->profile == AV_PROFILE_UNKNOWN)
601  avctx->profile = priv->profile;
602  if (avctx->level == AV_LEVEL_UNKNOWN)
603  avctx->level = priv->level;
604 
605  // Reject unknown levels (these are required to set f_code for
606  // motion vector encoding).
607  switch (avctx->level) {
608  case 4: // High
609  case 6: // High 1440
610  case 8: // Main
611  case 10: // Low
612  break;
613  default:
614  av_log(avctx, AV_LOG_ERROR, "Unknown MPEG-2 level %d.\n",
615  avctx->level);
616  return AVERROR(EINVAL);
617  }
618 
619  if (avctx->height % 4096 == 0 || avctx->width % 4096 == 0) {
620  av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support picture "
621  "height or width divisible by 4096.\n");
622  return AVERROR(EINVAL);
623  }
624 
625  ctx->desired_packed_headers = VA_ENC_PACKED_HEADER_SEQUENCE |
626  VA_ENC_PACKED_HEADER_PICTURE;
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)
647 
648  { "profile", "Set profile (in profile_and_level_indication)",
650  { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, 7, FLAGS, .unit = "profile" },
651 
652 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
653  { .i64 = value }, 0, 0, FLAGS, .unit = "profile"
654  { PROFILE("simple", AV_PROFILE_MPEG2_SIMPLE) },
655  { PROFILE("main", AV_PROFILE_MPEG2_MAIN) },
656 #undef PROFILE
657 
658  { "level", "Set level (in profile_and_level_indication)",
660  { .i64 = 4 }, 0, 15, FLAGS, .unit = "level" },
661 
662 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
663  { .i64 = value }, 0, 0, FLAGS, .unit = "level"
664  { LEVEL("low", 10) },
665  { LEVEL("main", 8) },
666  { LEVEL("high_1440", 6) },
667  { LEVEL("high", 4) },
668 #undef LEVEL
669 
670  { NULL },
671 };
672 
674  { "b", "0" },
675  { "bf", "1" },
676  { "g", "120" },
677  { "i_qfactor", "1" },
678  { "i_qoffset", "0" },
679  { "b_qfactor", "6/5" },
680  { "b_qoffset", "0" },
681  { "qmin", "-1" },
682  { "qmax", "-1" },
683  { NULL },
684 };
685 
687  .class_name = "mpeg2_vaapi",
688  .item_name = av_default_item_name,
689  .option = vaapi_encode_mpeg2_options,
690  .version = LIBAVUTIL_VERSION_INT,
691 };
692 
694  .p.name = "mpeg2_vaapi",
695  CODEC_LONG_NAME("MPEG-2 (VAAPI)"),
696  .p.type = AVMEDIA_TYPE_VIDEO,
697  .p.id = AV_CODEC_ID_MPEG2VIDEO,
698  .priv_data_size = sizeof(VAAPIEncodeMPEG2Context),
701  .close = &vaapi_encode_mpeg2_close,
702  .p.priv_class = &vaapi_encode_mpeg2_class,
703  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE |
705  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
707  .defaults = vaapi_encode_mpeg2_defaults,
708  .p.pix_fmts = (const enum AVPixelFormat[]) {
711  },
712  .color_ranges = AVCOL_RANGE_MPEG,
713  .hw_configs = ff_vaapi_encode_hw_configs,
714  .p.wrapper_name = "vaapi",
715 };
VAAPIEncodeMPEG2Context::cbc
CodedBitstreamContext * cbc
Definition: vaapi_encode_mpeg2.c:63
VAAPIEncodeMPEG2Context::picture_header
MPEG2RawPictureHeader picture_header
Definition: vaapi_encode_mpeg2.c:60
vaapi_encode_mpeg2_write_fragment
static int vaapi_encode_mpeg2_write_fragment(AVCodecContext *avctx, char *data, size_t *data_len, CodedBitstreamFragment *frag)
Definition: vaapi_encode_mpeg2.c:68
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
VAAPIEncodeSlice::codec_slice_params
void * codec_slice_params
Definition: vaapi_encode.h:62
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
MPEG2RawPictureCodingExtension
Definition: cbs_mpeg2.h:138
level
uint8_t level
Definition: svq3.c:205
av_clip
#define av_clip
Definition: common.h:100
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
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
FF_HW_PICTURE_TYPE_P
@ FF_HW_PICTURE_TYPE_P
Definition: hw_base_encode.h:41
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:691
MPEG2_EXTENSION_SEQUENCE
@ MPEG2_EXTENSION_SEQUENCE
Definition: cbs_mpeg2.h:45
FFHWBaseEncodePicture::priv
void * priv
Definition: hw_base_encode.h:63
VAAPIEncodeMPEG2Context::gop_header
MPEG2RawGroupOfPicturesHeader gop_header
Definition: vaapi_encode_mpeg2.c:59
VAAPIEncodeMPEG2Context::vbv_buffer_size
unsigned int vbv_buffer_size
Definition: vaapi_encode_mpeg2.c:45
AV_PROFILE_MPEG2_SIMPLE
#define AV_PROFILE_MPEG2_SIMPLE
Definition: defs.h:105
ff_cbs_fragment_free
av_cold void ff_cbs_fragment_free(CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:186
AV_CODEC_CAP_HARDWARE
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:145
vaapi_encode_mpeg2_write_picture_header
static int vaapi_encode_mpeg2_write_picture_header(AVCodecContext *avctx, FFHWBaseEncodePicture *pic, char *data, size_t *data_len)
Definition: vaapi_encode_mpeg2.c:143
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
ff_cbs_insert_unit_content
int ff_cbs_insert_unit_content(CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, void *content_ref)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:783
int64_t
long long int64_t
Definition: coverity.c:34
se
#define se(name, range_min, range_max)
Definition: cbs_h2645.c:260
MPEG2RawExtensionData::data
union MPEG2RawExtensionData::@82 data
MPEG2RawPictureHeader
Definition: cbs_mpeg2.h:123
VAAPIEncodeMPEG2Context::f_code_horizontal
unsigned int f_code_horizontal
Definition: vaapi_encode_mpeg2.c:49
ph
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
Definition: cbs_h266_syntax_template.c:3043
MPEG2RawExtensionData::sequence_display
MPEG2RawSequenceDisplayExtension sequence_display
Definition: cbs_mpeg2.h:183
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:684
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:172
MPEG2RawPictureCodingExtension::alternate_scan
uint8_t alternate_scan
Definition: cbs_mpeg2.h:148
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:219
VAAPIEncodeSlice
Definition: vaapi_encode.h:56
AVOption
AVOption.
Definition: opt.h:429
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:614
data
const char data[16]
Definition: mxf.c:149
AVCodecContext::b_quant_offset
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:817
VAAPIEncodeSlice::block_start
int block_start
Definition: vaapi_encode.h:60
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:35
FFCodec
Definition: codec_internal.h:127
ff_vaapi_encode_close
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
Definition: vaapi_encode.c:2275
cbs.h
MPEG2RawExtensionData
Definition: cbs_mpeg2.h:177
MPEG2RawSequenceDisplayExtension::display_horizontal_size
uint16_t display_horizontal_size
Definition: cbs_mpeg2.h:105
VAAPIEncodeMPEG2Context::profile
int profile
Definition: vaapi_encode_mpeg2.c:36
vaapi_encode_mpeg2_close
static av_cold int vaapi_encode_mpeg2_close(AVCodecContext *avctx)
Definition: vaapi_encode_mpeg2.c:631
MPEG2RawSequenceHeader::load_intra_quantiser_matrix
uint8_t load_intra_quantiser_matrix
Definition: cbs_mpeg2.h:70
MPEG2RawSequenceHeader::frame_rate_code
uint8_t frame_rate_code
Definition: cbs_mpeg2.h:65
VAAPIEncodeMPEG2Context
Definition: vaapi_encode_mpeg2.c:32
MPEG2_EXTENSION_PICTURE_CODING
@ MPEG2_EXTENSION_PICTURE_CODING
Definition: cbs_mpeg2.h:51
ff_mpeg12_find_best_frame_rate
void ff_mpeg12_find_best_frame_rate(AVRational frame_rate, int *code, int *ext_n, int *ext_d, int nonstandard)
Definition: mpeg12framerate.c:44
MPEG2RawPictureCodingExtension::q_scale_type
uint8_t q_scale_type
Definition: cbs_mpeg2.h:146
ff_cbs_close
av_cold void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:142
FFHWBaseEncodeContext
Definition: hw_base_encode.h:122
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:566
vaapi_encode_mpeg2_configure
static av_cold int vaapi_encode_mpeg2_configure(AVCodecContext *avctx)
Definition: vaapi_encode_mpeg2.c:516
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:826
FFCodecDefault
Definition: codec_internal.h:97
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
FLAGS
#define FLAGS
Definition: vaapi_encode_mpeg2.c:642
FFHWBaseEncodePicture::type
int type
Definition: hw_base_encode.h:78
vaapi_encode.h
fail
#define fail()
Definition: checkasm.h:193
VAAPIEncodePicture
Definition: vaapi_encode.h:65
MPEG2RawGroupOfPicturesHeader
Definition: cbs_mpeg2.h:109
MPEG2RawPictureCodingExtension::frame_pred_frame_dct
uint8_t frame_pred_frame_dct
Definition: cbs_mpeg2.h:144
MPEG2RawExtensionData::extension_start_code
uint8_t extension_start_code
Definition: cbs_mpeg2.h:178
vaapi_encode_mpeg2_options
static const AVOption vaapi_encode_mpeg2_options[]
Definition: vaapi_encode_mpeg2.c:643
FF_HW_FLAG_B_PICTURES
@ FF_HW_FLAG_B_PICTURES
Definition: hw_base_encode.h:53
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
AVRational::num
int num
Numerator.
Definition: rational.h:59
MPEG2RawPictureCodingExtension::concealment_motion_vectors
uint8_t concealment_motion_vectors
Definition: cbs_mpeg2.h:145
VAAPIEncodeMPEG2Context::common
VAAPIEncodeContext common
Definition: vaapi_encode_mpeg2.c:33
VAAPIEncodeMPEG2Context::last_i_frame
int64_t last_i_frame
Definition: vaapi_encode_mpeg2.c:53
MPEG2RawSequenceDisplayExtension::colour_description
uint8_t colour_description
Definition: cbs_mpeg2.h:100
avassert.h
mpeg12.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:677
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
av_cold
#define av_cold
Definition: attributes.h:90
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
MPEG2RawGroupOfPicturesHeader::time_code
uint32_t time_code
Definition: cbs_mpeg2.h:112
MPEG2RawPictureCodingExtension::field_sequence
uint8_t field_sequence
Definition: cbs_mpeg2.h:155
MPEG2RawSequenceExtension
Definition: cbs_mpeg2.h:84
VAAPIEncodePicture::codec_picture_params
void * codec_picture_params
Definition: vaapi_encode.h:83
MPEG2RawPictureCodingExtension::composite_display_flag
uint8_t composite_display_flag
Definition: cbs_mpeg2.h:153
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:122
CodedBitstreamFragment::data_size
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:135
MPEG2RawSequenceDisplayExtension
Definition: cbs_mpeg2.h:97
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
MPEG2RawSequenceHeader::constrained_parameters_flag
uint8_t constrained_parameters_flag
Definition: cbs_mpeg2.h:68
VAAPIEncodeMPEG2Context::quant_i
int quant_i
Definition: vaapi_encode_mpeg2.c:40
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
LEVEL
#define LEVEL(name, value)
ctx
AVFormatContext * ctx
Definition: movenc.c:49
FF_HW_PICTURE_TYPE_IDR
@ FF_HW_PICTURE_TYPE_IDR
Definition: hw_base_encode.h:39
MPEG2RawSequenceDisplayExtension::video_format
uint8_t video_format
Definition: cbs_mpeg2.h:98
ff_vaapi_encode_receive_packet
int ff_vaapi_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: vaapi_encode.c:2086
MPEG2RawSequenceHeader::vertical_size_value
uint16_t vertical_size_value
Definition: cbs_mpeg2.h:63
CodedBitstreamFragment::data_bit_padding
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:139
ff_mpeg2_vaapi_encoder
const FFCodec ff_mpeg2_vaapi_encoder
Definition: vaapi_encode_mpeg2.c:693
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:589
VAAPIEncodeType
Definition: vaapi_encode.h:265
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
FFHWBaseEncodeContext::b_per_p
int b_per_p
Definition: hw_base_encode.h:189
VAAPIEncodeContext
Definition: vaapi_encode.h:145
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1287
MPEG2_EXTENSION_SEQUENCE_DISPLAY
@ MPEG2_EXTENSION_SEQUENCE_DISPLAY
Definition: cbs_mpeg2.h:46
MPEG2_START_PICTURE
@ MPEG2_START_PICTURE
Definition: cbs_mpeg2.h:29
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
MPEG2RawSequenceDisplayExtension::colour_primaries
uint8_t colour_primaries
Definition: cbs_mpeg2.h:101
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
AV_LEVEL_UNKNOWN
#define AV_LEVEL_UNKNOWN
Definition: defs.h:198
MPEG2_START_GROUP
@ MPEG2_START_GROUP
Definition: cbs_mpeg2.h:37
VAAPIEncodeType::profiles
const VAAPIEncodeProfile * profiles
Definition: vaapi_encode.h:268
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
FF_CODEC_RECEIVE_PACKET_CB
#define FF_CODEC_RECEIVE_PACKET_CB(func)
Definition: codec_internal.h:326
MPEG2RawGroupOfPicturesHeader::broken_link
uint8_t broken_link
Definition: cbs_mpeg2.h:114
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
MPEG2RawPictureCodingExtension::repeat_first_field
uint8_t repeat_first_field
Definition: cbs_mpeg2.h:149
MPEG2_START_EXTENSION
@ MPEG2_START_EXTENSION
Definition: cbs_mpeg2.h:35
PROFILE
#define PROFILE(name, value)
VAAPIEncodeMPEG2Context::picture_coding_extension
MPEG2RawExtensionData picture_coding_extension
Definition: vaapi_encode_mpeg2.c:61
vaapi_encode_mpeg2_profiles
static const VAAPIEncodeProfile vaapi_encode_mpeg2_profiles[]
Definition: vaapi_encode_mpeg2.c:562
cbs_mpeg2.h
OFFSET
#define OFFSET(x)
Definition: vaapi_encode_mpeg2.c:641
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1794
MPEG2RawGroupOfPicturesHeader::closed_gop
uint8_t closed_gop
Definition: cbs_mpeg2.h:113
MPEG2RawSequenceDisplayExtension::matrix_coefficients
uint8_t matrix_coefficients
Definition: cbs_mpeg2.h:103
MPEG2RawSequenceHeader::horizontal_size_value
uint16_t horizontal_size_value
Definition: cbs_mpeg2.h:62
vaapi_encode_mpeg2_init
static av_cold int vaapi_encode_mpeg2_init(AVCodecContext *avctx)
Definition: vaapi_encode_mpeg2.c:593
MPEG2RawExtensionData::sequence
MPEG2RawSequenceExtension sequence
Definition: cbs_mpeg2.h:182
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:550
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c: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
vaapi_encode_mpeg2_init_picture_params
static int vaapi_encode_mpeg2_init_picture_params(AVCodecContext *avctx, FFHWBaseEncodePicture *pic)
Definition: vaapi_encode_mpeg2.c:420
codec_internal.h
VAAPI_ENCODE_RC_OPTIONS
#define VAAPI_ENCODE_RC_OPTIONS
Definition: vaapi_encode.h:364
MPEG2RawExtensionData::extension_start_code_identifier
uint8_t extension_start_code_identifier
Definition: cbs_mpeg2.h:179
vaapi_encode_mpeg2_class
static const AVClass vaapi_encode_mpeg2_class
Definition: vaapi_encode_mpeg2.c:686
VAAPIEncodeMPEG2Context::current_fragment
CodedBitstreamFragment current_fragment
Definition: vaapi_encode_mpeg2.c:64
CodedBitstreamFragment::data
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:128
vaapi_encode_mpeg2_init_slice_params
static int vaapi_encode_mpeg2_init_slice_params(AVCodecContext *avctx, FFHWBaseEncodePicture *pic, VAAPIEncodeSlice *slice)
Definition: vaapi_encode_mpeg2.c:483
header
static const uint8_t header[24]
Definition: sdr2.c:68
VAAPI_ENCODE_COMMON_OPTIONS
#define VAAPI_ENCODE_COMMON_OPTIONS
Definition: vaapi_encode.h:350
VAAPIEncodePicture::recon_surface
VASurfaceID recon_surface
Definition: vaapi_encode.h:74
MPEG2RawPictureCodingExtension::sub_carrier
uint8_t sub_carrier
Definition: cbs_mpeg2.h:156
VAAPIEncodePicture::output_buffer
VABufferID output_buffer
Definition: vaapi_encode.h:81
vaapi_encode_mpeg2_defaults
static const FFCodecDefault vaapi_encode_mpeg2_defaults[]
Definition: vaapi_encode_mpeg2.c:673
MPEG2RawSequenceHeader
Definition: cbs_mpeg2.h:59
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
MPEG2_START_SEQUENCE_HEADER
@ MPEG2_START_SEQUENCE_HEADER
Definition: cbs_mpeg2.h:33
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:810
vaapi_encode_type_mpeg2
static const VAAPIEncodeType vaapi_encode_type_mpeg2
Definition: vaapi_encode_mpeg2.c:568
code
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
Definition: filter_design.txt:178
MPEG2RawSequenceHeader::sequence_header_code
uint8_t sequence_header_code
Definition: cbs_mpeg2.h:60
VAAPIEncodeMPEG2Context::quant_b
int quant_b
Definition: vaapi_encode_mpeg2.c:42
MPEG2RawSequenceHeader::aspect_ratio_information
uint8_t aspect_ratio_information
Definition: cbs_mpeg2.h:64
VAAPIEncodeMPEG2Context::bit_rate
unsigned int bit_rate
Definition: vaapi_encode_mpeg2.c:44
FFHWBaseEncodePicture::refs
struct FFHWBaseEncodePicture * refs[MAX_REFERENCE_LIST_NUM][MAX_PICTURE_REFERENCES]
Definition: hw_base_encode.h:98
vaapi_encode_mpeg2_write_sequence_header
static int vaapi_encode_mpeg2_write_sequence_header(AVCodecContext *avctx, char *data, size_t *data_len)
Definition: vaapi_encode_mpeg2.c:110
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
vaapi_encode_mpeg2_init_sequence_params
static int vaapi_encode_mpeg2_init_sequence_params(AVCodecContext *avctx)
Definition: vaapi_encode_mpeg2.c:167
profile
int profile
Definition: mxfenc.c:2233
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:643
AVCodecContext::height
int height
Definition: avcodec.h:624
MPEG2RawSequenceDisplayExtension::transfer_characteristics
uint8_t transfer_characteristics
Definition: cbs_mpeg2.h:102
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:700
VAAPIEncodeMPEG2Context::level
int level
Definition: vaapi_encode_mpeg2.c:37
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:409
avcodec.h
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
ff_vaapi_encode_hw_configs
const AVCodecHWConfigInternal *const ff_vaapi_encode_hw_configs[]
Definition: vaapi_encode.c:36
MPEG2RawPictureCodingExtension::burst_amplitude
uint8_t burst_amplitude
Definition: cbs_mpeg2.h:157
ff_vaapi_encode_init
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
Definition: vaapi_encode.c:2091
FFHWBaseEncodeContext::gop_size
int gop_size
Definition: hw_base_encode.h:184
FFHWBaseEncodePicture
Definition: hw_base_encode.h:61
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:80
MPEG2RawExtensionData::picture_coding
MPEG2RawPictureCodingExtension picture_coding
Definition: cbs_mpeg2.h:185
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1650
MPEG2RawPictureCodingExtension::v_axis
uint8_t v_axis
Definition: cbs_mpeg2.h:154
AVCodecContext::i_quant_offset
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:833
AV_PROFILE_MPEG2_MAIN
#define AV_PROFILE_MPEG2_MAIN
Definition: defs.h:104
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:76
MPEG2RawPictureCodingExtension::picture_structure
uint8_t picture_structure
Definition: cbs_mpeg2.h:142
VAAPIEncodeMPEG2Context::sequence_extension
MPEG2RawExtensionData sequence_extension
Definition: vaapi_encode_mpeg2.c:57
VAAPIEncodeMPEG2Context::f_code_vertical
unsigned int f_code_vertical
Definition: vaapi_encode_mpeg2.c:50
MPEG2RawSequenceDisplayExtension::display_vertical_size
uint16_t display_vertical_size
Definition: cbs_mpeg2.h:106
VAAPIEncodeMPEG2Context::sequence_header
MPEG2RawSequenceHeader sequence_header
Definition: vaapi_encode_mpeg2.c:56
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
VAAPIEncodeSlice::block_size
int block_size
Definition: vaapi_encode.h:61
MPEG2RawSequenceHeader::vbv_buffer_size_value
uint16_t vbv_buffer_size_value
Definition: cbs_mpeg2.h:67
ff_cbs_init
av_cold int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:90
vaapi_encode_mpeg2_add_header
static int vaapi_encode_mpeg2_add_header(AVCodecContext *avctx, CodedBitstreamFragment *frag, int type, void *header)
Definition: vaapi_encode_mpeg2.c:94
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
MPEG2RawPictureCodingExtension::intra_dc_precision
uint8_t intra_dc_precision
Definition: cbs_mpeg2.h:141
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
MPEG2RawPictureCodingExtension::f_code
uint8_t f_code[2][2]
Definition: cbs_mpeg2.h:139
MPEG2RawPictureCodingExtension::intra_vlc_format
uint8_t intra_vlc_format
Definition: cbs_mpeg2.h:147
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
FF_HW_PICTURE_TYPE_B
@ FF_HW_PICTURE_TYPE_B
Definition: hw_base_encode.h:42
VAAPIEncodeMPEG2Context::sequence_display_extension
MPEG2RawExtensionData sequence_display_extension
Definition: vaapi_encode_mpeg2.c:58
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
VAAPIEncodeMPEG2Context::quant_p
int quant_p
Definition: vaapi_encode_mpeg2.c:41
HW_BASE_ENCODE_COMMON_OPTIONS
#define HW_BASE_ENCODE_COMMON_OPTIONS
Definition: hw_base_encode.h:239
MPEG2RawGroupOfPicturesHeader::group_start_code
uint8_t group_start_code
Definition: cbs_mpeg2.h:110
FFHWBaseEncodePicture::display_order
int64_t display_order
Definition: hw_base_encode.h:69
MPEG2RawSequenceHeader::bit_rate_value
uint32_t bit_rate_value
Definition: cbs_mpeg2.h:66
FF_HW_PICTURE_TYPE_I
@ FF_HW_PICTURE_TYPE_I
Definition: hw_base_encode.h:40
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
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:648
VAAPIEncodeProfile
Definition: vaapi_encode.h:100
VAAPIEncodeMPEG2Context::frame_rate
AVRational frame_rate
Definition: vaapi_encode_mpeg2.c:47
MPEG2RawPictureCodingExtension::sub_carrier_phase
uint8_t sub_carrier_phase
Definition: cbs_mpeg2.h:158
MPEG2RawPictureCodingExtension::top_field_first
uint8_t top_field_first
Definition: cbs_mpeg2.h:143
MPEG2RawPictureCodingExtension::progressive_frame
uint8_t progressive_frame
Definition: cbs_mpeg2.h:151
MPEG2RawSequenceHeader::load_non_intra_quantiser_matrix
uint8_t load_non_intra_quantiser_matrix
Definition: cbs_mpeg2.h:72