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  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
97  int err;
98 
99  err = ff_cbs_insert_unit_content(priv->cbc, frag, -1, type, header, NULL);
100  if (err < 0) {
101  av_log(avctx, AV_LOG_ERROR, "Failed to add header: "
102  "type = %d.\n", type);
103  return err;
104  }
105 
106  return 0;
107 }
108 
110  char *data, size_t *data_len)
111 {
112  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
114  int err;
115 
117  &priv->sequence_header);
118  if (err < 0)
119  goto fail;
120 
122  &priv->sequence_extension);
123  if (err < 0)
124  goto fail;
125 
128  if (err < 0)
129  goto fail;
130 
132  &priv->gop_header);
133  if (err < 0)
134  goto fail;
135 
136  err = vaapi_encode_mpeg2_write_fragment(avctx, data, data_len, frag);
137 fail:
138  ff_cbs_fragment_reset(priv->cbc, frag);
139  return 0;
140 }
141 
143  VAAPIEncodePicture *pic,
144  char *data, size_t *data_len)
145 {
146  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
148  int err;
149 
151  &priv->picture_header);
152  if (err < 0)
153  goto fail;
154 
156  &priv->picture_coding_extension);
157  if (err < 0)
158  goto fail;
159 
160  err = vaapi_encode_mpeg2_write_fragment(avctx, data, data_len, frag);
161 fail:
162  ff_cbs_fragment_reset(priv->cbc, frag);
163  return 0;
164 }
165 
167 {
168  VAAPIEncodeContext *ctx = avctx->priv_data;
169  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
176  VAEncSequenceParameterBufferMPEG2 *vseq = ctx->codec_sequence_params;
177  VAEncPictureParameterBufferMPEG2 *vpic = ctx->codec_picture_params;
178  int code, ext_n, ext_d;
179 
180  memset(sh, 0, sizeof(*sh));
181  memset(se, 0, sizeof(*se));
182  memset(sde, 0, sizeof(*sde));
183  memset(goph, 0, sizeof(*goph));
184  memset(ph, 0, sizeof(*ph));
185  memset(pce, 0, sizeof(*pce));
186 
187 
188  if (ctx->va_bit_rate > 0) {
189  priv->bit_rate = (ctx->va_bit_rate + 399) / 400;
190  } else {
191  // Unknown (not a bitrate-targetting mode), so just use the
192  // highest value.
193  priv->bit_rate = 0x3fffffff;
194  }
195  if (avctx->rc_buffer_size > 0) {
196  priv->vbv_buffer_size = (avctx->rc_buffer_size + (1 << 14) - 1) >> 14;
197  } else {
198  // Unknown, so guess a value from the bitrate.
199  priv->vbv_buffer_size = priv->bit_rate >> 14;
200  }
201 
202  switch (avctx->level) {
203  case 4: // High.
204  case 6: // High 1440.
205  priv->f_code_horizontal = 9;
206  priv->f_code_vertical = 5;
207  break;
208  case 8: // Main.
209  priv->f_code_horizontal = 8;
210  priv->f_code_vertical = 5;
211  break;
212  case 10: // Low.
213  default:
214  priv->f_code_horizontal = 7;
215  priv->f_code_vertical = 4;
216  break;
217  }
218 
219 
220  // Sequence header
221 
223 
224  sh->horizontal_size_value = avctx->width & 0xfff;
225  sh->vertical_size_value = avctx->height & 0xfff;
226 
227  if (avctx->sample_aspect_ratio.num != 0 &&
228  avctx->sample_aspect_ratio.den != 0) {
230  (AVRational) { avctx->width, avctx->height });
231 
232  if (av_cmp_q(avctx->sample_aspect_ratio, (AVRational) { 1, 1 }) == 0) {
233  sh->aspect_ratio_information = 1;
234  } else if (av_cmp_q(dar, (AVRational) { 3, 4 }) == 0) {
235  sh->aspect_ratio_information = 2;
236  } else if (av_cmp_q(dar, (AVRational) { 9, 16 }) == 0) {
237  sh->aspect_ratio_information = 3;
238  } else if (av_cmp_q(dar, (AVRational) { 100, 221 }) == 0) {
239  sh->aspect_ratio_information = 4;
240  } else {
241  av_log(avctx, AV_LOG_WARNING, "Sample aspect ratio %d:%d is not "
242  "representable, signalling square pixels instead.\n",
243  avctx->sample_aspect_ratio.num,
244  avctx->sample_aspect_ratio.den);
245  sh->aspect_ratio_information = 1;
246  }
247  } else {
248  // Unknown - assume square pixels.
249  sh->aspect_ratio_information = 1;
250  }
251 
252  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
253  priv->frame_rate = avctx->framerate;
254  else
255  priv->frame_rate = av_inv_q(avctx->time_base);
257  &code, &ext_n, &ext_d, 0);
258  sh->frame_rate_code = code;
259 
260  sh->bit_rate_value = priv->bit_rate & 0x3ffff;
261  sh->vbv_buffer_size_value = priv->vbv_buffer_size & 0x3ff;
262 
266 
267 
268  // Sequence extension
269 
273 
274  se->profile_and_level_indication = avctx->profile << 4 | avctx->level;
275  se->progressive_sequence = 1;
276  se->chroma_format = 1;
277 
278  se->horizontal_size_extension = avctx->width >> 12;
279  se->vertical_size_extension = avctx->height >> 12;
280 
281  se->bit_rate_extension = priv->bit_rate >> 18;
282  se->vbv_buffer_size_extension = priv->vbv_buffer_size >> 10;
283  se->low_delay = ctx->b_per_p == 0;
284 
285  se->frame_rate_extension_n = ext_n;
286  se->frame_rate_extension_d = ext_d;
287 
288 
289  // Sequence display extension
290 
295 
296  sde->video_format = 5;
297  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
298  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
299  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
300  sde->colour_description = 1;
301  sde->colour_primaries = avctx->color_primaries;
302  sde->transfer_characteristics = avctx->color_trc;
303  sde->matrix_coefficients = avctx->colorspace;
304  } else {
305  sde->colour_description = 0;
306  }
307 
308  sde->display_horizontal_size = avctx->width;
309  sde->display_vertical_size = avctx->height;
310 
311 
312  // GOP header
313 
315 
316  // Marker bit in the middle of time_code.
317  goph->time_code = 1 << 12;
318  goph->closed_gop = 1;
319  goph->broken_link = 0;
320 
321 
322  // Defaults for picture header
323 
325 
326  ph->vbv_delay = 0xffff; // Not currently calculated.
327 
328  ph->full_pel_forward_vector = 0;
329  ph->forward_f_code = 7;
330  ph->full_pel_backward_vector = 0;
331  ph->forward_f_code = 7;
332 
333 
334  // Defaults for picture coding extension
335 
340 
341  pce->intra_dc_precision = 0;
342  pce->picture_structure = 3;
343  pce->top_field_first = 0;
344  pce->frame_pred_frame_dct = 1;
346  pce->q_scale_type = 0;
347  pce->intra_vlc_format = 0;
348  pce->alternate_scan = 0;
349  pce->repeat_first_field = 0;
350  pce->progressive_frame = 1;
351  pce->composite_display_flag = 0;
352 
353 
354 
355  *vseq = (VAEncSequenceParameterBufferMPEG2) {
356  .intra_period = ctx->gop_size,
357  .ip_period = ctx->b_per_p + 1,
358 
359  .picture_width = avctx->width,
360  .picture_height = avctx->height,
361 
362  .bits_per_second = ctx->va_bit_rate,
363  .frame_rate = av_q2d(priv->frame_rate),
364  .aspect_ratio_information = sh->aspect_ratio_information,
365  .vbv_buffer_size = priv->vbv_buffer_size,
366 
367  .sequence_extension.bits = {
368  .profile_and_level_indication = se->profile_and_level_indication,
369  .progressive_sequence = se->progressive_sequence,
370  .chroma_format = se->chroma_format,
371  .low_delay = se->low_delay,
372  .frame_rate_extension_n = se->frame_rate_extension_n,
373  .frame_rate_extension_d = se->frame_rate_extension_d,
374  },
375 
376  .new_gop_header = 1,
377  .gop_header.bits = {
378  .time_code = goph->time_code,
379  .closed_gop = goph->closed_gop,
380  .broken_link = goph->broken_link,
381  },
382  };
383 
384  *vpic = (VAEncPictureParameterBufferMPEG2) {
385  .forward_reference_picture = VA_INVALID_ID,
386  .backward_reference_picture = VA_INVALID_ID,
387  .reconstructed_picture = VA_INVALID_ID,
388  .coded_buf = VA_INVALID_ID,
389 
390  .vbv_delay = 0xffff,
391  .f_code = { { 15, 15 }, { 15, 15 } },
392 
393  .picture_coding_extension.bits = {
394  .intra_dc_precision = pce->intra_dc_precision,
395  .picture_structure = pce->picture_structure,
396  .top_field_first = pce->top_field_first,
397  .frame_pred_frame_dct = pce->frame_pred_frame_dct,
398  .concealment_motion_vectors = pce->concealment_motion_vectors,
399  .q_scale_type = pce->q_scale_type,
400  .intra_vlc_format = pce->intra_vlc_format,
401  .alternate_scan = pce->alternate_scan,
402  .repeat_first_field = pce->repeat_first_field,
403  .progressive_frame = pce->progressive_frame,
404  .composite_display_flag = pce->composite_display_flag,
405  },
406 
407  .composite_display.bits = {
408  .v_axis = pce->v_axis,
409  .field_sequence = pce->field_sequence,
410  .sub_carrier = pce->sub_carrier,
411  .burst_amplitude = pce->burst_amplitude,
412  .sub_carrier_phase = pce->sub_carrier_phase,
413  },
414  };
415 
416  return 0;
417 }
418 
420  VAAPIEncodePicture *pic)
421 {
422  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
425  VAEncPictureParameterBufferMPEG2 *vpic = pic->codec_picture_params;
426 
427  if (pic->type == PICTURE_TYPE_IDR || pic->type == PICTURE_TYPE_I) {
428  ph->temporal_reference = 0;
429  ph->picture_coding_type = 1;
430  priv->last_i_frame = pic->display_order;
431  } else {
432  ph->temporal_reference = pic->display_order - priv->last_i_frame;
433  ph->picture_coding_type = pic->type == PICTURE_TYPE_B ? 3 : 2;
434  }
435 
436  if (pic->type == PICTURE_TYPE_P || pic->type == PICTURE_TYPE_B) {
437  pce->f_code[0][0] = priv->f_code_horizontal;
438  pce->f_code[0][1] = priv->f_code_vertical;
439  } else {
440  pce->f_code[0][0] = 15;
441  pce->f_code[0][1] = 15;
442  }
443  if (pic->type == PICTURE_TYPE_B) {
444  pce->f_code[1][0] = priv->f_code_horizontal;
445  pce->f_code[1][1] = priv->f_code_vertical;
446  } else {
447  pce->f_code[1][0] = 15;
448  pce->f_code[1][1] = 15;
449  }
450 
451  vpic->reconstructed_picture = pic->recon_surface;
452  vpic->coded_buf = pic->output_buffer;
453 
454  switch (pic->type) {
455  case PICTURE_TYPE_IDR:
456  case PICTURE_TYPE_I:
457  vpic->picture_type = VAEncPictureTypeIntra;
458  break;
459  case PICTURE_TYPE_P:
460  vpic->picture_type = VAEncPictureTypePredictive;
461  vpic->forward_reference_picture = pic->refs[0]->recon_surface;
462  break;
463  case PICTURE_TYPE_B:
464  vpic->picture_type = VAEncPictureTypeBidirectional;
465  vpic->forward_reference_picture = pic->refs[0]->recon_surface;
466  vpic->backward_reference_picture = pic->refs[1]->recon_surface;
467  break;
468  default:
469  av_assert0(0 && "invalid picture type");
470  }
471 
472  vpic->temporal_reference = ph->temporal_reference;
473  vpic->f_code[0][0] = pce->f_code[0][0];
474  vpic->f_code[0][1] = pce->f_code[0][1];
475  vpic->f_code[1][0] = pce->f_code[1][0];
476  vpic->f_code[1][1] = pce->f_code[1][1];
477 
478  return 0;
479 }
480 
482  VAAPIEncodePicture *pic,
483  VAAPIEncodeSlice *slice)
484 {
485  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
486  VAEncSliceParameterBufferMPEG2 *vslice = slice->codec_slice_params;
487  int qp;
488 
489  vslice->macroblock_address = slice->block_start;
490  vslice->num_macroblocks = slice->block_size;
491 
492  switch (pic->type) {
493  case PICTURE_TYPE_IDR:
494  case PICTURE_TYPE_I:
495  qp = priv->quant_i;
496  break;
497  case PICTURE_TYPE_P:
498  qp = priv->quant_p;
499  break;
500  case PICTURE_TYPE_B:
501  qp = priv->quant_b;
502  break;
503  default:
504  av_assert0(0 && "invalid picture type");
505  }
506 
507  vslice->quantiser_scale_code = qp;
508  vslice->is_intra_slice = (pic->type == PICTURE_TYPE_IDR ||
509  pic->type == PICTURE_TYPE_I);
510 
511  return 0;
512 }
513 
515 {
516  VAAPIEncodeContext *ctx = avctx->priv_data;
517  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
518  int err;
519 
520  err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_MPEG2VIDEO, avctx);
521  if (err < 0)
522  return err;
523 
524  if (ctx->va_rc_mode == VA_RC_CQP) {
525  priv->quant_p = av_clip(ctx->rc_quality, 1, 31);
526  if (avctx->i_quant_factor > 0.0)
527  priv->quant_i =
528  av_clip((avctx->i_quant_factor * priv->quant_p +
529  avctx->i_quant_offset) + 0.5, 1, 31);
530  else
531  priv->quant_i = priv->quant_p;
532  if (avctx->b_quant_factor > 0.0)
533  priv->quant_b =
534  av_clip((avctx->b_quant_factor * priv->quant_p +
535  avctx->b_quant_offset) + 0.5, 1, 31);
536  else
537  priv->quant_b = priv->quant_p;
538 
539  av_log(avctx, AV_LOG_DEBUG, "Using fixed quantiser "
540  "%d / %d / %d for I- / P- / B-frames.\n",
541  priv->quant_i, priv->quant_p, priv->quant_b);
542 
543  } else {
544  priv->quant_i = 16;
545  priv->quant_p = 16;
546  priv->quant_b = 16;
547  }
548 
549  ctx->slice_block_rows = FFALIGN(avctx->height, 16) / 16;
550  ctx->slice_block_cols = FFALIGN(avctx->width, 16) / 16;
551 
552  ctx->nb_slices = ctx->slice_block_rows;
553  ctx->slice_size = 1;
554 
555  ctx->roi_quant_range = 31;
556 
557  return 0;
558 }
559 
561  { FF_PROFILE_MPEG2_MAIN, 8, 3, 1, 1, VAProfileMPEG2Main },
562  { FF_PROFILE_MPEG2_SIMPLE, 8, 3, 1, 1, VAProfileMPEG2Simple },
564 };
565 
568 
569  .flags = FLAG_B_PICTURES,
570 
571  .configure = &vaapi_encode_mpeg2_configure,
572 
573  .default_quality = 10,
574 
575  .sequence_params_size = sizeof(VAEncSequenceParameterBufferMPEG2),
576  .init_sequence_params = &vaapi_encode_mpeg2_init_sequence_params,
577 
578  .picture_params_size = sizeof(VAEncPictureParameterBufferMPEG2),
579  .init_picture_params = &vaapi_encode_mpeg2_init_picture_params,
580 
581  .slice_params_size = sizeof(VAEncSliceParameterBufferMPEG2),
582  .init_slice_params = &vaapi_encode_mpeg2_init_slice_params,
583 
584  .sequence_header_type = VAEncPackedHeaderSequence,
585  .write_sequence_header = &vaapi_encode_mpeg2_write_sequence_header,
586 
587  .picture_header_type = VAEncPackedHeaderPicture,
588  .write_picture_header = &vaapi_encode_mpeg2_write_picture_header,
589 };
590 
592 {
593  VAAPIEncodeContext *ctx = avctx->priv_data;
594  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
595 
597 
598  if (avctx->profile == FF_PROFILE_UNKNOWN)
599  avctx->profile = priv->profile;
600  if (avctx->level == FF_LEVEL_UNKNOWN)
601  avctx->level = priv->level;
602 
603  // Reject unknown levels (these are required to set f_code for
604  // motion vector encoding).
605  switch (avctx->level) {
606  case 4: // High
607  case 6: // High 1440
608  case 8: // Main
609  case 10: // Low
610  break;
611  default:
612  av_log(avctx, AV_LOG_ERROR, "Unknown MPEG-2 level %d.\n",
613  avctx->level);
614  return AVERROR(EINVAL);
615  }
616 
617  if (avctx->height % 4096 == 0 || avctx->width % 4096 == 0) {
618  av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support picture "
619  "height or width divisible by 4096.\n");
620  return AVERROR(EINVAL);
621  }
622 
623  ctx->desired_packed_headers = VA_ENC_PACKED_HEADER_SEQUENCE |
624  VA_ENC_PACKED_HEADER_PICTURE;
625 
626  ctx->surface_width = FFALIGN(avctx->width, 16);
627  ctx->surface_height = FFALIGN(avctx->height, 16);
628 
629  return ff_vaapi_encode_init(avctx);
630 }
631 
633 {
634  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
635 
637  ff_cbs_close(&priv->cbc);
638 
639  return ff_vaapi_encode_close(avctx);
640 }
641 
642 #define OFFSET(x) offsetof(VAAPIEncodeMPEG2Context, x)
643 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
647 
648  { "profile", "Set profile (in profile_and_level_indication)",
650  { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 7, FLAGS, "profile" },
651 
652 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
653  { .i64 = value }, 0, 0, FLAGS, "profile"
654  { PROFILE("simple", FF_PROFILE_MPEG2_SIMPLE) },
655  { PROFILE("main", FF_PROFILE_MPEG2_MAIN) },
656 #undef PROFILE
657 
658  { "level", "Set level (in profile_and_level_indication)",
660  { .i64 = 4 }, 0, 15, FLAGS, "level" },
661 
662 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
663  { .i64 = value }, 0, 0, FLAGS, "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  .name = "mpeg2_vaapi",
695  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 (VAAPI)"),
696  .type = AVMEDIA_TYPE_VIDEO,
698  .priv_data_size = sizeof(VAAPIEncodeMPEG2Context),
700  .send_frame = &ff_vaapi_encode_send_frame,
701  .receive_packet = &ff_vaapi_encode_receive_packet,
702  .close = &vaapi_encode_mpeg2_close,
703  .priv_class = &vaapi_encode_mpeg2_class,
704  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE,
705  .defaults = vaapi_encode_mpeg2_defaults,
706  .pix_fmts = (const enum AVPixelFormat[]) {
709  },
710  .wrapper_name = "vaapi",
711 };
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:3107
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:2933
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:263
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#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
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: avcodec.h:1080
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:191
int ff_cbs_insert_unit_content(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, AVBufferRef *content_buf)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:666
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:1946
GLint GLenum type
Definition: opengl_enc.c:104
MPEG2RawExtensionData sequence_display_extension
void * codec_sequence_params
Definition: vaapi_encode.h:268
static av_cold int vaapi_encode_mpeg2_init(AVCodecContext *avctx)
int profile
profile
Definition: avcodec.h:2900
AVCodec.
Definition: avcodec.h:3483
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:1879
#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:1690
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:3021
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:1008
#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)
int ff_vaapi_encode_send_frame(AVCodecContext *avctx, const AVFrame *frame)
#define av_cold
Definition: attributes.h:82
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:1836
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
VASurfaceID recon_surface
Definition: vaapi_encode.h:88
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
MPEG2RawPictureCodingExtension picture_coding
Definition: cbs_mpeg2.h:185
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:129
void ff_cbs_fragment_free(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:154
unsigned int va_rc_mode
Definition: vaapi_encode.h:224
AVCodec ff_mpeg2_vaapi_encoder
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:186
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
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: avcodec.h:3490
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:1872
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
unsigned int va_bit_rate
Definition: vaapi_encode.h:226
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:97
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:133
#define fail()
Definition: checkasm.h:121
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2430
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:1740
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2901
const VAAPIEncodeProfile * profiles
Definition: vaapi_encode.h:349
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:2181
int level
level
Definition: avcodec.h:3020
VAAPIEncodeContext common
void * codec_picture_params
Definition: vaapi_encode.h:272
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: avcodec.h:220
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:122
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:284
struct VAAPIEncodePicture * refs[MAX_PICTURE_REFERENCES]
Definition: vaapi_encode.h:110
static int vaapi_encode_mpeg2_init_slice_params(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice)
const struct VAAPIEncodeType * codec
Definition: vaapi_encode.h:173
Libavcodec external API header.
#define VAAPI_ENCODE_RC_OPTIONS
Definition: vaapi_encode.h:444
union MPEG2RawExtensionData::@62 data
MPEG2RawSequenceDisplayExtension sequence_display
Definition: cbs_mpeg2.h:183
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
main external API structure.
Definition: avcodec.h:1567
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
void ff_cbs_fragment_reset(CodedBitstreamContext *ctx, 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:139
Context structure for coded bitstream operations.
Definition: cbs.h:168
#define LEVEL(name, value)
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2195
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2188
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
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:113
uint16_t temporal_reference
Definition: cbs_mpeg2.h:126
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:1849
uint8_t aspect_ratio_information
Definition: cbs_mpeg2.h:64
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
uint8_t picture_coding_type
Definition: cbs_mpeg2.h:127
#define VAAPI_ENCODE_COMMON_OPTIONS
Definition: vaapi_encode.h:426
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:1594
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:2934
void * codec_slice_params
Definition: vaapi_encode.h:61
MPEG2RawGroupOfPicturesHeader gop_header
unsigned int desired_packed_headers
Definition: vaapi_encode.h:195
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:94
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)