FFmpeg: libavcodec/vaapi_encode_mpeg2.c Source File

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/common.h"
24 #include "libavutil/internal.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/pixfmt.h"
27 
28 #include "avcodec.h"
29 #include "internal.h"
30 #include "mpegvideo.h"
31 #include "put_bits.h"
32 #include "vaapi_encode.h"
33 
34  typedef struct VAAPIEncodeMPEG2Context {
35   int mb_width;
36   int mb_height;
37 
38   int quant_i;
39   int quant_p;
40   int quant_b;
41 
42   int64_t last_i_frame;
43 
44   unsigned int bit_rate;
45   unsigned int vbv_buffer_size;
46 } VAAPIEncodeMPEG2Context;
47 
48 
49  #define vseq_var(name) vseq->name, name
50  #define vseqext_field(name) vseq->sequence_extension.bits.name, name
51  #define vgop_field(name) vseq->gop_header.bits.name, name
52  #define vpic_var(name) vpic->name, name
53  #define vpcext_field(name) vpic->picture_coding_extension.bits.name, name
54  #define vcomp_field(name) vpic->composite_display.bits.name, name
55 
56  #define u2(width, value, name) put_bits(&pbc, width, value)
57  #define u(width, ...) u2(width, __VA_ARGS__)
58 
59  static int vaapi_encode_mpeg2_write_sequence_header(AVCodecContext *avctx,
60  char *data, size_t *data_len)
61 {
62  VAAPIEncodeContext *ctx = avctx->priv_data;
63  VAEncSequenceParameterBufferMPEG2 *vseq = ctx->codec_sequence_params;
64  VAAPIEncodeMPEG2Context *priv = ctx->priv_data;
65  PutBitContext pbc;
66 
67  init_put_bits(&pbc, data, 8 * *data_len);
68 
69  u(32, SEQ_START_CODE, sequence_header_code);
70 
71  u(12, vseq->picture_width, horizontal_size_value);
72  u(12, vseq->picture_height, vertical_size_value);
73  u(4, vseq_var(aspect_ratio_information));
74  u(4, 8, frame_rate_code);
75  u(18, priv->bit_rate & 0x3fff, bit_rate_value);
76  u(1, 1, marker_bit);
77  u(10, priv->vbv_buffer_size & 0x3ff, vbv_buffer_size_value);
78  u(1, 0, constrained_parameters_flag);
79  u(1, 0, load_intra_quantiser_matrix);
80  // intra_quantiser_matrix[64]
81  u(1, 0, load_non_intra_quantiser_matrix);
82  // non_intra_quantiser_matrix[64]
83 
84  while (put_bits_count(&pbc) % 8)
85  u(1, 0, zero_bit);
86 
87  u(32, EXT_START_CODE, extension_start_code);
88  u(4, 1, extension_start_code_identifier);
89  u(8, vseqext_field(profile_and_level_indication));
90  u(1, vseqext_field(progressive_sequence));
91  u(2, vseqext_field(chroma_format));
92  u(2, 0, horizontal_size_extension);
93  u(2, 0, vertical_size_extension);
94  u(12, priv->bit_rate >> 18, bit_rate_extension);
95  u(1, 1, marker_bit);
96  u(8, priv->vbv_buffer_size >> 10, vbv_buffer_size_extension);
97  u(1, vseqext_field(low_delay));
98  u(2, vseqext_field(frame_rate_extension_n));
99  u(2, vseqext_field(frame_rate_extension_d));
100 
101  while (put_bits_count(&pbc) % 8)
102  u(1, 0, zero_bit);
103 
104  u(32, GOP_START_CODE, group_start_code);
105  u(25, vgop_field(time_code));
106  u(1, vgop_field(closed_gop));
107  u(1, vgop_field(broken_link));
108 
109  while (put_bits_count(&pbc) % 8)
110  u(1, 0, zero_bit);
111 
112  *data_len = put_bits_count(&pbc);
113  flush_put_bits(&pbc);
114 
115  return 0;
116 }
117 
118  static int vaapi_encode_mpeg2_write_picture_header(AVCodecContext *avctx,
119  VAAPIEncodePicture *pic,
120  char *data, size_t *data_len)
121 {
122  VAEncPictureParameterBufferMPEG2 *vpic = pic->codec_picture_params;
123  int picture_coding_type;
124  PutBitContext pbc;
125 
126  init_put_bits(&pbc, data, 8 * *data_len);
127 
128  u(32, PICTURE_START_CODE, picture_start_code);
129  u(10, vpic_var(temporal_reference));
130 
131  switch (vpic->picture_type) {
132  case VAEncPictureTypeIntra:
133  picture_coding_type = AV_PICTURE_TYPE_I;
134  break;
135  case VAEncPictureTypePredictive:
136  picture_coding_type = AV_PICTURE_TYPE_P;
137  break;
138  case VAEncPictureTypeBidirectional:
139  picture_coding_type = AV_PICTURE_TYPE_B;
140  break;
141  default:
142  av_assert0(0 && "invalid picture_coding_type");
143  }
144  u(3, picture_coding_type, picture_coding_type);
145  u(16, 0xffff, vbv_delay);
146  if (picture_coding_type == 2 || picture_coding_type == 3) {
147  u(1, 0, full_pel_forward_vector);
148  u(3, 7, forward_f_code);
149  }
150  if (picture_coding_type == 3) {
151  u(1, 0, full_pel_backward_vector);
152  u(3, 7, backward_f_code);
153  }
154  u(1, 0, extra_bit_picture);
155 
156  while (put_bits_count(&pbc) % 8)
157  u(1, 0, zero_bit);
158 
159  u(32, EXT_START_CODE, extension_start_code);
160  u(4, 8, extension_start_code_identifier);
161  u(4, vpic_var(f_code[0][0]));
162  u(4, vpic_var(f_code[0][1]));
163  u(4, vpic_var(f_code[1][0]));
164  u(4, vpic_var(f_code[1][1]));
165  u(2, vpcext_field(intra_dc_precision));
166  u(2, vpcext_field(picture_structure));
167  u(1, vpcext_field(top_field_first));
168  u(1, vpcext_field(frame_pred_frame_dct));
169  u(1, vpcext_field(concealment_motion_vectors));
170  u(1, vpcext_field(q_scale_type));
171  u(1, vpcext_field(intra_vlc_format));
172  u(1, vpcext_field(alternate_scan));
173  u(1, vpcext_field(repeat_first_field));
174  u(1, 1, chroma_420_type);
175  u(1, vpcext_field(progressive_frame));
176  u(1, vpcext_field(composite_display_flag));
177  if (vpic->picture_coding_extension.bits.composite_display_flag) {
178  u(1, vcomp_field(v_axis));
179  u(3, vcomp_field(field_sequence));
180  u(1, vcomp_field(sub_carrier));
181  u(7, vcomp_field(burst_amplitude));
182  u(8, vcomp_field(sub_carrier_phase));
183  }
184 
185  while (put_bits_count(&pbc) % 8)
186  u(1, 0, zero_bit);
187 
188  *data_len = put_bits_count(&pbc);
189  flush_put_bits(&pbc);
190 
191  return 0;
192 }
193 
194  static int vaapi_encode_mpeg2_init_sequence_params(AVCodecContext *avctx)
195 {
196  VAAPIEncodeContext *ctx = avctx->priv_data;
197  VAEncSequenceParameterBufferMPEG2 *vseq = ctx->codec_sequence_params;
198  VAEncPictureParameterBufferMPEG2 *vpic = ctx->codec_picture_params;
199  VAAPIEncodeMPEG2Context *priv = ctx->priv_data;
200 
201  vseq->intra_period = avctx->gop_size;
202  vseq->ip_period = ctx->b_per_p + 1;
203 
204  vseq->picture_width = avctx->width;
205  vseq->picture_height = avctx->height;
206 
207  vseq->bits_per_second = avctx->bit_rate;
208  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
209  vseq->frame_rate = (float)avctx->framerate.num / avctx->framerate.den;
210  else
211  vseq->frame_rate = (float)avctx->time_base.den / avctx->time_base.num;
212 
213  vseq->aspect_ratio_information = 1;
214  vseq->vbv_buffer_size = avctx->rc_buffer_size / (16 * 1024);
215 
216  vseq->sequence_extension.bits.profile_and_level_indication =
217  avctx->profile << 4 | avctx->level;
218  vseq->sequence_extension.bits.progressive_sequence = 1;
219  vseq->sequence_extension.bits.chroma_format = 1;
220  vseq->sequence_extension.bits.low_delay = 0;
221  vseq->sequence_extension.bits.frame_rate_extension_n = 0;
222  vseq->sequence_extension.bits.frame_rate_extension_d = 0;
223 
224  vseq->new_gop_header = 0;
225  vseq->gop_header.bits.time_code = 0;
226  vseq->gop_header.bits.closed_gop = 1;
227  vseq->gop_header.bits.broken_link = 0;
228 
229  vpic->forward_reference_picture = VA_INVALID_ID;
230  vpic->backward_reference_picture = VA_INVALID_ID;
231  vpic->reconstructed_picture = VA_INVALID_ID;
232 
233  vpic->coded_buf = VA_INVALID_ID;
234 
235  vpic->temporal_reference = 0;
236  vpic->f_code[0][0] = 15;
237  vpic->f_code[0][1] = 15;
238  vpic->f_code[1][0] = 15;
239  vpic->f_code[1][1] = 15;
240 
241  vpic->picture_coding_extension.bits.intra_dc_precision = 0;
242  vpic->picture_coding_extension.bits.picture_structure = 3;
243  vpic->picture_coding_extension.bits.top_field_first = 0;
244  vpic->picture_coding_extension.bits.frame_pred_frame_dct = 1;
245  vpic->picture_coding_extension.bits.concealment_motion_vectors = 0;
246  vpic->picture_coding_extension.bits.q_scale_type = 0;
247  vpic->picture_coding_extension.bits.intra_vlc_format = 0;
248  vpic->picture_coding_extension.bits.alternate_scan = 0;
249  vpic->picture_coding_extension.bits.repeat_first_field = 0;
250  vpic->picture_coding_extension.bits.progressive_frame = 1;
251  vpic->picture_coding_extension.bits.composite_display_flag = 0;
252 
253  priv->bit_rate = (avctx->bit_rate + 399) / 400;
254  priv->vbv_buffer_size = avctx->rc_buffer_size / (16 * 1024);
255 
256  return 0;
257 }
258 
259  static int vaapi_encode_mpeg2_init_picture_params(AVCodecContext *avctx,
260  VAAPIEncodePicture *pic)
261 {
262  VAAPIEncodeContext *ctx = avctx->priv_data;
263  VAEncPictureParameterBufferMPEG2 *vpic = pic->codec_picture_params;
264  VAAPIEncodeMPEG2Context *priv = ctx->priv_data;
265  int fch, fcv;
266 
267  switch (avctx->level) {
268  case 4: // High.
269  case 6: // High 1440.
270  fch = 9;
271  fcv = 5;
272  break;
273  case 8: // Main.
274  fch = 8;
275  fcv = 5;
276  break;
277  case 10: // Low.
278  default:
279  fch = 7;
280  fcv = 4;
281  break;
282  }
283 
284  switch (pic->type) {
285  case PICTURE_TYPE_IDR:
286  case PICTURE_TYPE_I:
287  vpic->picture_type = VAEncPictureTypeIntra;
288  priv->last_i_frame = pic->display_order;
289  break;
290  case PICTURE_TYPE_P:
291  vpic->picture_type = VAEncPictureTypePredictive;
292  vpic->forward_reference_picture = pic->refs[0]->recon_surface;
293  vpic->f_code[0][0] = fch;
294  vpic->f_code[0][1] = fcv;
295  break;
296  case PICTURE_TYPE_B:
297  vpic->picture_type = VAEncPictureTypeBidirectional;
298  vpic->forward_reference_picture = pic->refs[0]->recon_surface;
299  vpic->backward_reference_picture = pic->refs[1]->recon_surface;
300  vpic->f_code[0][0] = fch;
301  vpic->f_code[0][1] = fcv;
302  vpic->f_code[1][0] = fch;
303  vpic->f_code[1][1] = fcv;
304  break;
305  default:
306  av_assert0(0 && "invalid picture type");
307  }
308 
309  vpic->reconstructed_picture = pic->recon_surface;
310  vpic->coded_buf = pic->output_buffer;
311 
312  vpic->temporal_reference = pic->display_order - priv->last_i_frame;
313 
314  pic->nb_slices = priv->mb_height;
315 
316  return 0;
317 }
318 
319  static int vaapi_encode_mpeg2_init_slice_params(AVCodecContext *avctx,
320  VAAPIEncodePicture *pic,
321  VAAPIEncodeSlice *slice)
322 {
323  VAAPIEncodeContext *ctx = avctx->priv_data;
324  VAEncSliceParameterBufferMPEG2 *vslice = slice->codec_slice_params;
325  VAAPIEncodeMPEG2Context *priv = ctx->priv_data;
326  int qp;
327 
328  vslice->macroblock_address = priv->mb_width * slice->index;
329  vslice->num_macroblocks = priv->mb_width;
330 
331  switch (pic->type) {
332  case PICTURE_TYPE_IDR:
333  case PICTURE_TYPE_I:
334  qp = priv->quant_i;
335  break;
336  case PICTURE_TYPE_P:
337  qp = priv->quant_p;
338  break;
339  case PICTURE_TYPE_B:
340  qp = priv->quant_b;
341  break;
342  default:
343  av_assert0(0 && "invalid picture type");
344  }
345 
346  vslice->quantiser_scale_code = qp;
347  vslice->is_intra_slice = (pic->type == PICTURE_TYPE_IDR ||
348  pic->type == PICTURE_TYPE_I);
349 
350  return 0;
351 }
352 
353  static av_cold int vaapi_encode_mpeg2_configure(AVCodecContext *avctx)
354 {
355  VAAPIEncodeContext *ctx = avctx->priv_data;
356  VAAPIEncodeMPEG2Context *priv = ctx->priv_data;
357 
358  priv->mb_width = FFALIGN(avctx->width, 16) / 16;
359  priv->mb_height = FFALIGN(avctx->height, 16) / 16;
360 
361  if (ctx->va_rc_mode == VA_RC_CQP) {
362  priv->quant_p = av_clip(avctx->global_quality, 1, 31);
363  if (avctx->i_quant_factor > 0.0)
364  priv->quant_i = av_clip((avctx->global_quality *
365  avctx->i_quant_factor +
366  avctx->i_quant_offset) + 0.5,
367  1, 31);
368  else
369  priv->quant_i = priv->quant_p;
370  if (avctx->b_quant_factor > 0.0)
371  priv->quant_b = av_clip((avctx->global_quality *
372  avctx->b_quant_factor +
373  avctx->b_quant_offset) + 0.5,
374  1, 31);
375  else
376  priv->quant_b = priv->quant_p;
377 
378  av_log(avctx, AV_LOG_DEBUG, "Using fixed quantiser "
379  "%d / %d / %d for I- / P- / B-frames.\n",
380  priv->quant_i, priv->quant_p, priv->quant_b);
381 
382  } else {
383  av_assert0(0 && "Invalid RC mode.");
384  }
385 
386  return 0;
387 }
388 
389  static const VAAPIEncodeType vaapi_encode_type_mpeg2 = {
390  .priv_data_size = sizeof(VAAPIEncodeMPEG2Context),
391 
392  .configure = &vaapi_encode_mpeg2_configure,
393 
394  .sequence_params_size = sizeof(VAEncSequenceParameterBufferMPEG2),
395  .init_sequence_params = &vaapi_encode_mpeg2_init_sequence_params,
396 
397  .picture_params_size = sizeof(VAEncPictureParameterBufferMPEG2),
398  .init_picture_params = &vaapi_encode_mpeg2_init_picture_params,
399 
400  .slice_params_size = sizeof(VAEncSliceParameterBufferMPEG2),
401  .init_slice_params = &vaapi_encode_mpeg2_init_slice_params,
402 
403  .sequence_header_type = VAEncPackedHeaderSequence,
404  .write_sequence_header = &vaapi_encode_mpeg2_write_sequence_header,
405 
406  .picture_header_type = VAEncPackedHeaderPicture,
407  .write_picture_header = &vaapi_encode_mpeg2_write_picture_header,
408 };
409 
410  static av_cold int vaapi_encode_mpeg2_init(AVCodecContext *avctx)
411 {
412  VAAPIEncodeContext *ctx = avctx->priv_data;
413 
414  ctx->codec = &vaapi_encode_type_mpeg2;
415 
416  switch (avctx->profile) {
417  case FF_PROFILE_MPEG2_SIMPLE:
418  ctx->va_profile = VAProfileMPEG2Simple;
419  break;
420  case FF_PROFILE_MPEG2_MAIN:
421  ctx->va_profile = VAProfileMPEG2Main;
422  break;
423  default:
424  av_log(avctx, AV_LOG_ERROR, "Unknown MPEG-2 profile %d.\n",
425  avctx->profile);
426  return AVERROR(EINVAL);
427  }
428 
429  ctx->va_entrypoint = VAEntrypointEncSlice;
430  ctx->va_rt_format = VA_RT_FORMAT_YUV420;
431  ctx->va_rc_mode = VA_RC_CQP;
432 
433  ctx->va_packed_headers = VA_ENC_PACKED_HEADER_SEQUENCE |
434  VA_ENC_PACKED_HEADER_PICTURE;
435 
436  ctx->surface_width = FFALIGN(avctx->width, 16);
437  ctx->surface_height = FFALIGN(avctx->height, 16);
438 
439  return ff_vaapi_encode_init(avctx);
440 }
441 
442  static const AVCodecDefault vaapi_encode_mpeg2_defaults[] = {
443  { "profile", "4" },
444  { "level", "4" },
445  { "bf", "1" },
446  { "g", "120" },
447  { "i_qfactor", "1" },
448  { "i_qoffset", "0" },
449  { "b_qfactor", "6/5" },
450  { "b_qoffset", "0" },
451  { "global_quality", "10" },
452  { NULL },
453 };
454 
455  AVCodec ff_mpeg2_vaapi_encoder = {
456  .name = "mpeg2_vaapi",
457  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 (VAAPI)"),
458  .type = AVMEDIA_TYPE_VIDEO,
459  .id = AV_CODEC_ID_MPEG2VIDEO,
460  .priv_data_size = sizeof(VAAPIEncodeContext),
461  .init = &vaapi_encode_mpeg2_init,
462  .encode2 = &ff_vaapi_encode2,
463  .close = &ff_vaapi_encode_close,
464  .capabilities = AV_CODEC_CAP_DELAY,
465  .defaults = vaapi_encode_mpeg2_defaults,
466  .pix_fmts = (const enum AVPixelFormat[]) {
467  AV_PIX_FMT_VAAPI,
468  AV_PIX_FMT_NONE,
469  },
470 };
vaapi_encode_mpeg2_configure
static av_cold int vaapi_encode_mpeg2_configure(AVCodecContext *avctx)
Definition: vaapi_encode_mpeg2.c:353
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:3460
VAAPIEncodeContext::va_profile
VAProfile va_profile
Definition: vaapi_encode.h:96
FF_PROFILE_MPEG2_MAIN
#define FF_PROFILE_MPEG2_MAIN
Definition: avcodec.h:3299
vcomp_field
#define vcomp_field(name)
Definition: vaapi_encode_mpeg2.c:54
VAAPIEncodeContext::va_entrypoint
VAEntrypoint va_entrypoint
Definition: vaapi_encode.h:98
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1826
ff_vaapi_encode_init
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
Definition: vaapi_encode.c:1358
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
ff_vaapi_encode_close
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
Definition: vaapi_encode.c:1553
AVRational::num
int num
Numerator.
Definition: rational.h:59
VAAPIEncodeType::priv_data_size
size_t priv_data_size
Definition: vaapi_encode.h:218
mpegvideo.h
mpegvideo header.
VAAPIEncodeContext::codec_sequence_params
void * codec_sequence_params
Definition: vaapi_encode.h:168
vaapi_encode_mpeg2_init
static av_cold int vaapi_encode_mpeg2_init(AVCodecContext *avctx)
Definition: vaapi_encode_mpeg2.c:410
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:3266
AVCodec
AVCodec.
Definition: avcodec.h:3739
VAAPIEncodeMPEG2Context::vbv_buffer_size
unsigned int vbv_buffer_size
Definition: vaapi_encode_mpeg2.c:45
AVCodecContext::i_quant_offset
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:2105
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:1898
VAAPIEncodeContext::va_packed_headers
unsigned int va_packed_headers
Definition: vaapi_encode.h:105
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: avcodec.h:1027
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
vaapi_encode_mpeg2_write_picture_header
static int vaapi_encode_mpeg2_write_picture_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, char *data, size_t *data_len)
Definition: vaapi_encode_mpeg2.c:118
av_cold
#define av_cold
Definition: attributes.h:82
opt.h
AVOptions.
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:2056
PICTURE_TYPE_I
Definition: vaapi_encode.h:44
VAAPIEncodePicture::recon_surface
VASurfaceID recon_surface
Definition: vaapi_encode.h:71
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
VAAPIEncodeContext::va_rc_mode
unsigned int va_rc_mode
Definition: vaapi_encode.h:102
ff_mpeg2_vaapi_encoder
AVCodec ff_mpeg2_vaapi_encoder
Definition: vaapi_encode_mpeg2.c:455
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
vpcext_field
#define vpcext_field(name)
Definition: vaapi_encode_mpeg2.c:53
AVERROR
#define AVERROR(e)
Definition: error.h:43
vaapi_encode_mpeg2_init_picture_params
static int vaapi_encode_mpeg2_init_picture_params(AVCodecContext *avctx, VAAPIEncodePicture *pic)
Definition: vaapi_encode_mpeg2.c:259
vpic_var
#define vpic_var(name)
Definition: vaapi_encode_mpeg2.c:52
ff_vaapi_encode2
int ff_vaapi_encode2(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *input_image, int *got_packet)
Definition: vaapi_encode.c:851
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:179
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
vaapi_encode_mpeg2_defaults
static const AVCodecDefault vaapi_encode_mpeg2_defaults[]
Definition: vaapi_encode_mpeg2.c:442
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3746
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:2098
VAAPIEncodePicture::codec_picture_params
void * codec_picture_params
Definition: vaapi_encode.h:80
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2739
PICTURE_TYPE_P
Definition: vaapi_encode.h:45
internal.h
common internal API header
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
vaapi_encode_mpeg2_init_sequence_params
static int vaapi_encode_mpeg2_init_sequence_params(AVCodecContext *avctx)
Definition: vaapi_encode_mpeg2.c:194
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1948
GOP_START_CODE
#define GOP_START_CODE
Definition: mpegvideo.h:68
ctx
AVFormatContext * ctx
Definition: movenc.c:48
VAAPIEncodeContext::va_rt_format
unsigned int va_rt_format
Definition: vaapi_encode.h:100
AVCodecContext::level
int level
level
Definition: avcodec.h:3364
VAAPIEncodeContext::codec_picture_params
void * codec_picture_params
Definition: vaapi_encode.h:172
PICTURE_TYPE_B
Definition: vaapi_encode.h:46
EXT_START_CODE
#define EXT_START_CODE
Definition: cavs.h:33
vseqext_field
#define vseqext_field(name)
Definition: vaapi_encode_mpeg2.c:50
AVCodecContext::height
int height
Definition: avcodec.h:1948
AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:219
VAAPIEncodePicture::refs
struct VAAPIEncodePicture * refs[MAX_PICTURE_REFERENCES]
Definition: vaapi_encode.h:83
vseq_var
#define vseq_var(name)
Definition: vaapi_encode_mpeg2.c:49
vaapi_encode_mpeg2_init_slice_params
static int vaapi_encode_mpeg2_init_slice_params(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice)
Definition: vaapi_encode_mpeg2.c:319
VAAPIEncodeContext::codec
const struct VAAPIEncodeType * codec
Definition: vaapi_encode.h:93
avcodec.h
Libavcodec external API header.
AVCodecContext
main external API structure.
Definition: avcodec.h:1761
vaapi_encode.h
vaapi_encode_type_mpeg2
static const VAAPIEncodeType vaapi_encode_type_mpeg2
Definition: vaapi_encode_mpeg2.c:389
u
#define u(width,...)
Definition: vaapi_encode_mpeg2.c:57
AVCodecContext::b_quant_offset
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:2075
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
PICTURE_TYPE_IDR
Definition: vaapi_encode.h:43
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1842
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1974
internal.h
common internal api header.
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
common.h
common internal and external API header
AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1803
pixfmt.h
pixel format definitions
SEQ_START_CODE
#define SEQ_START_CODE
Definition: mpegvideo.h:67
FF_PROFILE_MPEG2_SIMPLE
#define FF_PROFILE_MPEG2_SIMPLE
Definition: avcodec.h:3300
VAAPIEncodeSlice::codec_slice_params
void * codec_slice_params
Definition: vaapi_encode.h:52
vgop_field
#define vgop_field(name)
Definition: vaapi_encode_mpeg2.c:51
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
PICTURE_START_CODE
#define PICTURE_START_CODE
Definition: mpegvideo.h:69
defaults
static const AVCodecDefault defaults[]
Definition: dcaenc.c:1275
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:59
VAAPIEncodePicture::output_buffer
VABufferID output_buffer
Definition: vaapi_encode.h:77
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
VAAPIEncodePicture::display_order
int64_t display_order
Definition: vaapi_encode.h:58
AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
put_bits.h
bitstream writer API
Generated on Fri Jan 12 2018 01:47:51 for FFmpeg by   doxygen 1.8.6

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