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  return 0;
556 }
557 
559  { FF_PROFILE_MPEG2_MAIN, 8, 3, 1, 1, VAProfileMPEG2Main },
560  { FF_PROFILE_MPEG2_SIMPLE, 8, 3, 1, 1, VAProfileMPEG2Simple },
562 };
563 
566 
567  .flags = FLAG_B_PICTURES,
568 
569  .configure = &vaapi_encode_mpeg2_configure,
570 
571  .default_quality = 10,
572 
573  .sequence_params_size = sizeof(VAEncSequenceParameterBufferMPEG2),
574  .init_sequence_params = &vaapi_encode_mpeg2_init_sequence_params,
575 
576  .picture_params_size = sizeof(VAEncPictureParameterBufferMPEG2),
577  .init_picture_params = &vaapi_encode_mpeg2_init_picture_params,
578 
579  .slice_params_size = sizeof(VAEncSliceParameterBufferMPEG2),
580  .init_slice_params = &vaapi_encode_mpeg2_init_slice_params,
581 
582  .sequence_header_type = VAEncPackedHeaderSequence,
583  .write_sequence_header = &vaapi_encode_mpeg2_write_sequence_header,
584 
585  .picture_header_type = VAEncPackedHeaderPicture,
586  .write_picture_header = &vaapi_encode_mpeg2_write_picture_header,
587 };
588 
590 {
591  VAAPIEncodeContext *ctx = avctx->priv_data;
592  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
593 
595 
596  if (avctx->profile == FF_PROFILE_UNKNOWN)
597  avctx->profile = priv->profile;
598  if (avctx->level == FF_LEVEL_UNKNOWN)
599  avctx->level = priv->level;
600 
601  // Reject unknown levels (these are required to set f_code for
602  // motion vector encoding).
603  switch (avctx->level) {
604  case 4: // High
605  case 6: // High 1440
606  case 8: // Main
607  case 10: // Low
608  break;
609  default:
610  av_log(avctx, AV_LOG_ERROR, "Unknown MPEG-2 level %d.\n",
611  avctx->level);
612  return AVERROR(EINVAL);
613  }
614 
615  if (avctx->height % 4096 == 0 || avctx->width % 4096 == 0) {
616  av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support picture "
617  "height or width divisible by 4096.\n");
618  return AVERROR(EINVAL);
619  }
620 
621  ctx->desired_packed_headers = VA_ENC_PACKED_HEADER_SEQUENCE |
622  VA_ENC_PACKED_HEADER_PICTURE;
623 
624  ctx->surface_width = FFALIGN(avctx->width, 16);
625  ctx->surface_height = FFALIGN(avctx->height, 16);
626 
627  return ff_vaapi_encode_init(avctx);
628 }
629 
631 {
632  VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
633 
635  ff_cbs_close(&priv->cbc);
636 
637  return ff_vaapi_encode_close(avctx);
638 }
639 
640 #define OFFSET(x) offsetof(VAAPIEncodeMPEG2Context, x)
641 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
645 
646  { "profile", "Set profile (in profile_and_level_indication)",
648  { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 7, FLAGS, "profile" },
649 
650 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
651  { .i64 = value }, 0, 0, FLAGS, "profile"
652  { PROFILE("simple", FF_PROFILE_MPEG2_SIMPLE) },
653  { PROFILE("main", FF_PROFILE_MPEG2_MAIN) },
654 #undef PROFILE
655 
656  { "level", "Set level (in profile_and_level_indication)",
658  { .i64 = 4 }, 0, 15, FLAGS, "level" },
659 
660 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
661  { .i64 = value }, 0, 0, FLAGS, "level"
662  { LEVEL("low", 10) },
663  { LEVEL("main", 8) },
664  { LEVEL("high_1440", 6) },
665  { LEVEL("high", 4) },
666 #undef LEVEL
667 
668  { NULL },
669 };
670 
672  { "b", "0" },
673  { "bf", "1" },
674  { "g", "120" },
675  { "i_qfactor", "1" },
676  { "i_qoffset", "0" },
677  { "b_qfactor", "6/5" },
678  { "b_qoffset", "0" },
679  { "qmin", "-1" },
680  { "qmax", "-1" },
681  { NULL },
682 };
683 
685  .class_name = "mpeg2_vaapi",
686  .item_name = av_default_item_name,
687  .option = vaapi_encode_mpeg2_options,
688  .version = LIBAVUTIL_VERSION_INT,
689 };
690 
692  .name = "mpeg2_vaapi",
693  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 (VAAPI)"),
694  .type = AVMEDIA_TYPE_VIDEO,
696  .priv_data_size = sizeof(VAAPIEncodeMPEG2Context),
698  .send_frame = &ff_vaapi_encode_send_frame,
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  .defaults = vaapi_encode_mpeg2_defaults,
704  .pix_fmts = (const enum AVPixelFormat[]) {
707  },
708  .wrapper_name = "vaapi",
709 };
static av_cold int vaapi_encode_mpeg2_configure(AVCodecContext *avctx)
MPEG2RawExtensionData sequence_extension
uint8_t full_pel_backward_vector
Definition: cbs_mpeg2.h:126
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3101
uint8_t load_non_intra_quantiser_matrix
Definition: cbs_mpeg2.h:72
uint8_t picture_start_code
Definition: cbs_mpeg2.h:118
uint8_t extension_start_code_identifier
Definition: cbs_mpeg2.h:173
#define FF_PROFILE_MPEG2_MAIN
Definition: avcodec.h:2927
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:176
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: avcodec.h:1078
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:1944
GLint GLenum type
Definition: opengl_enc.c:104
MPEG2RawExtensionData sequence_display_extension
void * codec_sequence_params
Definition: vaapi_encode.h:261
static av_cold int vaapi_encode_mpeg2_init(AVCodecContext *avctx)
int profile
profile
Definition: avcodec.h:2894
AVCodec.
Definition: avcodec.h:3477
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:1877
#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:1688
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:3015
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:1006
#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)
Definition: vaapi_encode.c:954
#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:1834
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
VASurfaceID recon_surface
Definition: vaapi_encode.h:81
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:179
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:217
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:3484
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:1870
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
unsigned int va_bit_rate
Definition: vaapi_encode.h:219
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:90
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:120
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2424
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:1738
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2895
const VAAPIEncodeProfile * profiles
Definition: vaapi_encode.h:331
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:2175
int level
level
Definition: avcodec.h:3014
VAAPIEncodeContext common
void * codec_picture_params
Definition: vaapi_encode.h:265
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:103
static int vaapi_encode_mpeg2_init_slice_params(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice)
const struct VAAPIEncodeType * codec
Definition: vaapi_encode.h:166
Libavcodec external API header.
#define VAAPI_ENCODE_RC_OPTIONS
Definition: vaapi_encode.h:426
union MPEG2RawExtensionData::@62 data
MPEG2RawSequenceDisplayExtension sequence_display
Definition: cbs_mpeg2.h:177
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
main external API structure.
Definition: avcodec.h:1565
uint8_t full_pel_forward_vector
Definition: cbs_mpeg2.h:124
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:2189
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2182
MPEG2RawExtensionData picture_coding_extension
static const VAAPIEncodeType vaapi_encode_type_mpeg2
uint8_t extension_start_code
Definition: cbs_mpeg2.h:172
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:120
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:1847
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:121
#define VAAPI_ENCODE_COMMON_OPTIONS
Definition: vaapi_encode.h:408
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:1592
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:2928
void * codec_slice_params
Definition: vaapi_encode.h:61
MPEG2RawGroupOfPicturesHeader gop_header
unsigned int desired_packed_headers
Definition: vaapi_encode.h:188
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:87
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)