FFmpeg
mpeg12enc.c
Go to the documentation of this file.
1 /*
2  * MPEG-1/2 encoder
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * MPEG-1/2 encoder
26  */
27 
28 #include <stdint.h>
29 
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/log.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/timecode.h"
35 #include "libavutil/stereo3d.h"
36 
37 #include "avcodec.h"
38 #include "bytestream.h"
39 #include "mathops.h"
40 #include "mpeg12.h"
41 #include "mpeg12data.h"
42 #include "mpegutils.h"
43 #include "mpegvideo.h"
44 #include "profiles.h"
45 
47  0x10, 0x0E, 0x00, 0x80, 0x81, 0x00, 0x80,
48  0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
49 };
50 
51 static uint8_t mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
52 static uint8_t fcode_tab[MAX_MV * 2 + 1];
53 
54 static uint8_t uni_mpeg1_ac_vlc_len[64 * 64 * 2];
55 static uint8_t uni_mpeg2_ac_vlc_len[64 * 64 * 2];
56 
57 /* simple include everything table for dc, first byte is bits
58  * number next 3 are code */
59 static uint32_t mpeg1_lum_dc_uni[512];
60 static uint32_t mpeg1_chr_dc_uni[512];
61 
62 static uint8_t mpeg1_index_run[2][64];
63 static int8_t mpeg1_max_level[2][64];
64 
65 #define A53_MAX_CC_COUNT 0x1f
66 
67 static av_cold void init_uni_ac_vlc(RLTable *rl, uint8_t *uni_ac_vlc_len)
68 {
69  int i;
70 
71  for (i = 0; i < 128; i++) {
72  int level = i - 64;
73  int run;
74  if (!level)
75  continue;
76  for (run = 0; run < 64; run++) {
77  int len, code;
78  int alevel = FFABS(level);
79 
80  if (alevel > rl->max_level[0][run])
81  code = 111; /* rl->n */
82  else
83  code = rl->index_run[0][run] + alevel - 1;
84 
85  if (code < 111) { /* rl->n */
86  /* length of VLC and sign */
87  len = rl->table_vlc[code][1] + 1;
88  } else {
89  len = rl->table_vlc[111 /* rl->n */][1] + 6;
90 
91  if (alevel < 128)
92  len += 8;
93  else
94  len += 16;
95  }
96 
97  uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
98  }
99  }
100 }
101 
103 {
104  int i;
105  AVRational bestq = (AVRational) {0, 0};
106  AVRational ext;
107  AVRational target = av_inv_q(s->avctx->time_base);
108 
109  for (i = 1; i < 14; i++) {
111  i >= 9)
112  break;
113 
114  for (ext.num=1; ext.num <= 4; ext.num++) {
115  for (ext.den=1; ext.den <= 32; ext.den++) {
117 
118  if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO && (ext.den!=1 || ext.num!=1))
119  continue;
120  if (av_gcd(ext.den, ext.num) != 1)
121  continue;
122 
123  if ( bestq.num==0
124  || av_nearer_q(target, bestq, q) < 0
125  || ext.num==1 && ext.den==1 && av_nearer_q(target, bestq, q) == 0) {
126  bestq = q;
127  s->frame_rate_index = i;
128  s->mpeg2_frame_rate_ext.num = ext.num;
129  s->mpeg2_frame_rate_ext.den = ext.den;
130  }
131  }
132  }
133  }
134 
135  if (av_cmp_q(target, bestq))
136  return -1;
137  else
138  return 0;
139 }
140 
142 {
143  int ret;
144  MpegEncContext *s = avctx->priv_data;
145 
146  if ((ret = ff_mpv_encode_init(avctx)) < 0)
147  return ret;
148 
149  if (find_frame_rate_index(s) < 0) {
151  av_log(avctx, AV_LOG_ERROR, "MPEG-1/2 does not support %d/%d fps\n",
152  avctx->time_base.den, avctx->time_base.num);
153  return AVERROR(EINVAL);
154  } else {
155  av_log(avctx, AV_LOG_INFO,
156  "MPEG-1/2 does not support %d/%d fps, there may be AV sync issues\n",
157  avctx->time_base.den, avctx->time_base.num);
158  }
159  }
160 
161  if (avctx->profile == FF_PROFILE_UNKNOWN) {
162  if (avctx->level != FF_LEVEL_UNKNOWN) {
163  av_log(avctx, AV_LOG_ERROR, "Set profile and level\n");
164  return AVERROR(EINVAL);
165  }
166  /* Main or 4:2:2 */
168  }
169 
170  if (avctx->level == FF_LEVEL_UNKNOWN) {
171  if (avctx->profile == FF_PROFILE_MPEG2_422) { /* 4:2:2 */
172  if (avctx->width <= 720 && avctx->height <= 608)
173  avctx->level = 5; /* Main */
174  else
175  avctx->level = 2; /* High */
176  } else {
177  if (avctx->profile != FF_PROFILE_MPEG2_HIGH && s->chroma_format != CHROMA_420) {
178  av_log(avctx, AV_LOG_ERROR,
179  "Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n");
180  return AVERROR(EINVAL);
181  }
182  if (avctx->width <= 720 && avctx->height <= 576)
183  avctx->level = 8; /* Main */
184  else if (avctx->width <= 1440)
185  avctx->level = 6; /* High 1440 */
186  else
187  avctx->level = 4; /* High */
188  }
189  }
190 
191  if ((avctx->width & 0xFFF) == 0 && (avctx->height & 0xFFF) == 1) {
192  av_log(avctx, AV_LOG_ERROR, "Width / Height is invalid for MPEG2\n");
193  return AVERROR(EINVAL);
194  }
195 
197  if ((avctx->width & 0xFFF) == 0 || (avctx->height & 0xFFF) == 0) {
198  av_log(avctx, AV_LOG_ERROR, "Width or Height are not allowed to be multiples of 4096\n"
199  "add '-strict %d' if you want to use them anyway.\n", FF_COMPLIANCE_UNOFFICIAL);
200  return AVERROR(EINVAL);
201  }
202  }
203 
205  if (s->drop_frame_timecode)
207  if (s->drop_frame_timecode && s->frame_rate_index != 4) {
208  av_log(avctx, AV_LOG_ERROR,
209  "Drop frame time code only allowed with 1001/30000 fps\n");
210  return AVERROR(EINVAL);
211  }
212 
213 #if FF_API_PRIVATE_OPT
215  if (avctx->timecode_frame_start)
218 #endif
219 
220  if (s->tc_opt_str) {
222  int ret = av_timecode_init_from_string(&s->tc, rate, s->tc_opt_str, s);
223  if (ret < 0)
224  return ret;
226  s->timecode_frame_start = s->tc.start;
227  } else {
228  s->timecode_frame_start = 0; // default is -1
229  }
230 
231  return 0;
232 }
233 
234 static void put_header(MpegEncContext *s, int header)
235 {
237  put_bits(&s->pb, 16, header >> 16);
238  put_sbits(&s->pb, 16, header);
239 }
240 
241 /* put sequence header if needed */
243 {
244  unsigned int vbv_buffer_size, fps, v;
245  int i, constraint_parameter_flag;
246  uint64_t time_code;
247  int64_t best_aspect_error = INT64_MAX;
248  AVRational aspect_ratio = s->avctx->sample_aspect_ratio;
249 
250  if (aspect_ratio.num == 0 || aspect_ratio.den == 0)
251  aspect_ratio = (AVRational){1,1}; // pixel aspect 1.1 (VGA)
252 
253  if (s->current_picture.f->key_frame) {
255 
256  /* MPEG-1 header repeated every GOP */
258 
259  put_sbits(&s->pb, 12, s->width & 0xFFF);
260  put_sbits(&s->pb, 12, s->height & 0xFFF);
261 
262  for (i = 1; i < 15; i++) {
263  int64_t error = aspect_ratio.num * (1LL<<32) / aspect_ratio.den;
264  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || i <= 1)
265  error -= (1LL<<32) / ff_mpeg1_aspect[i];
266  else
267  error -= (1LL<<32)*ff_mpeg2_aspect[i].num * s->height / s->width / ff_mpeg2_aspect[i].den;
268 
269  error = FFABS(error);
270 
271  if (error - 2 <= best_aspect_error) {
272  best_aspect_error = error;
273  s->aspect_ratio_info = i;
274  }
275  }
276 
277  put_bits(&s->pb, 4, s->aspect_ratio_info);
278  put_bits(&s->pb, 4, s->frame_rate_index);
279 
280  if (s->avctx->rc_max_rate) {
281  v = (s->avctx->rc_max_rate + 399) / 400;
282  if (v > 0x3ffff && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
283  v = 0x3ffff;
284  } else {
285  v = 0x3FFFF;
286  }
287 
288  if (s->avctx->rc_buffer_size)
289  vbv_buffer_size = s->avctx->rc_buffer_size;
290  else
291  /* VBV calculation: Scaled so that a VCD has the proper
292  * VBV size of 40 kilobytes */
293  vbv_buffer_size = ((20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
294  vbv_buffer_size = (vbv_buffer_size + 16383) / 16384;
295 
296  put_sbits(&s->pb, 18, v);
297  put_bits(&s->pb, 1, 1); // marker
298  put_sbits(&s->pb, 10, vbv_buffer_size);
299 
300  constraint_parameter_flag =
301  s->width <= 768 &&
302  s->height <= 576 &&
303  s->mb_width * s->mb_height <= 396 &&
304  s->mb_width * s->mb_height * framerate.num <= 396 * 25 * framerate.den &&
305  framerate.num <= framerate.den * 30 &&
306  s->avctx->me_range &&
307  s->avctx->me_range < 128 &&
308  vbv_buffer_size <= 20 &&
309  v <= 1856000 / 400 &&
311 
312  put_bits(&s->pb, 1, constraint_parameter_flag);
313 
316 
317  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
318  AVFrameSideData *side_data;
319  int width = s->width;
320  int height = s->height;
321  int use_seq_disp_ext;
322 
324  put_bits(&s->pb, 4, 1); // seq ext
325 
326  put_bits(&s->pb, 1, s->avctx->profile == FF_PROFILE_MPEG2_422); // escx 1 for 4:2:2 profile
327 
328  put_bits(&s->pb, 3, s->avctx->profile); // profile
329  put_bits(&s->pb, 4, s->avctx->level); // level
330 
331  put_bits(&s->pb, 1, s->progressive_sequence);
332  put_bits(&s->pb, 2, s->chroma_format);
333  put_bits(&s->pb, 2, s->width >> 12);
334  put_bits(&s->pb, 2, s->height >> 12);
335  put_bits(&s->pb, 12, v >> 18); // bitrate ext
336  put_bits(&s->pb, 1, 1); // marker
337  put_bits(&s->pb, 8, vbv_buffer_size >> 10); // vbv buffer ext
338  put_bits(&s->pb, 1, s->low_delay);
339  put_bits(&s->pb, 2, s->mpeg2_frame_rate_ext.num-1); // frame_rate_ext_n
340  put_bits(&s->pb, 5, s->mpeg2_frame_rate_ext.den-1); // frame_rate_ext_d
341 
343  if (side_data) {
344  AVPanScan *pan_scan = (AVPanScan *)side_data->data;
345  if (pan_scan->width && pan_scan->height) {
346  width = pan_scan->width >> 4;
347  height = pan_scan->height >> 4;
348  }
349  }
350 
351  use_seq_disp_ext = (width != s->width ||
352  height != s->height ||
357 
358  if (s->seq_disp_ext == 1 || (s->seq_disp_ext == -1 && use_seq_disp_ext)) {
360  put_bits(&s->pb, 4, 2); // sequence display extension
361  put_bits(&s->pb, 3, s->video_format); // video_format
362  put_bits(&s->pb, 1, 1); // colour_description
363  put_bits(&s->pb, 8, s->avctx->color_primaries); // colour_primaries
364  put_bits(&s->pb, 8, s->avctx->color_trc); // transfer_characteristics
365  put_bits(&s->pb, 8, s->avctx->colorspace); // matrix_coefficients
366  put_bits(&s->pb, 14, width); // display_horizontal_size
367  put_bits(&s->pb, 1, 1); // marker_bit
368  put_bits(&s->pb, 14, height); // display_vertical_size
369  put_bits(&s->pb, 3, 0); // remaining 3 bits are zero padding
370  }
371  }
372 
374  put_bits(&s->pb, 1, s->drop_frame_timecode); // drop frame flag
375  /* time code: we must convert from the real frame rate to a
376  * fake MPEG frame rate in case of low frame rate */
377  fps = (framerate.num + framerate.den / 2) / framerate.den;
378  time_code = s->current_picture_ptr->f->coded_picture_number +
380 
382 
384  if (s->drop_frame_timecode)
385  time_code = av_timecode_adjust_ntsc_framenum2(time_code, fps);
386 
387  put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
388  put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
389  put_bits(&s->pb, 1, 1);
390  put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
391  put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
393  put_bits(&s->pb, 1, 0); // broken link
394  }
395 }
396 
397 static inline void encode_mb_skip_run(MpegEncContext *s, int run)
398 {
399  while (run >= 33) {
400  put_bits(&s->pb, 11, 0x008);
401  run -= 33;
402  }
404  ff_mpeg12_mbAddrIncrTable[run][0]);
405 }
406 
408 {
409  put_bits(&s->pb, 5, s->qscale);
410 }
411 
413 {
414  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->height > 2800) {
415  put_header(s, SLICE_MIN_START_CODE + (s->mb_y & 127));
416  /* slice_vertical_position_extension */
417  put_bits(&s->pb, 3, s->mb_y >> 7);
418  } else {
420  }
421  put_qscale(s);
422  /* slice extra information */
423  put_bits(&s->pb, 1, 0);
424 }
425 
427 {
428  AVFrameSideData *side_data;
430 
431  /* MPEG-1 picture header */
433  /* temporal reference */
434 
435  // RAL: s->picture_number instead of s->fake_picture_number
436  put_bits(&s->pb, 10,
437  (s->picture_number - s->gop_picture_number) & 0x3ff);
438  put_bits(&s->pb, 3, s->pict_type);
439 
440  s->vbv_delay_ptr = s->pb.buf + put_bits_count(&s->pb) / 8;
441  put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
442 
443  // RAL: Forward f_code also needed for B-frames
444  if (s->pict_type == AV_PICTURE_TYPE_P ||
446  put_bits(&s->pb, 1, 0); /* half pel coordinates */
448  put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
449  else
450  put_bits(&s->pb, 3, 7); /* forward_f_code */
451  }
452 
453  // RAL: Backward f_code necessary for B-frames
454  if (s->pict_type == AV_PICTURE_TYPE_B) {
455  put_bits(&s->pb, 1, 0); /* half pel coordinates */
457  put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
458  else
459  put_bits(&s->pb, 3, 7); /* backward_f_code */
460  }
461 
462  put_bits(&s->pb, 1, 0); /* extra bit picture */
463 
464  s->frame_pred_frame_dct = 1;
465  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
467  put_bits(&s->pb, 4, 8); /* pic ext */
468  if (s->pict_type == AV_PICTURE_TYPE_P ||
470  put_bits(&s->pb, 4, s->f_code);
471  put_bits(&s->pb, 4, s->f_code);
472  } else {
473  put_bits(&s->pb, 8, 255);
474  }
475  if (s->pict_type == AV_PICTURE_TYPE_B) {
476  put_bits(&s->pb, 4, s->b_code);
477  put_bits(&s->pb, 4, s->b_code);
478  } else {
479  put_bits(&s->pb, 8, 255);
480  }
481  put_bits(&s->pb, 2, s->intra_dc_precision);
482 
484  put_bits(&s->pb, 2, s->picture_structure);
485  if (s->progressive_sequence)
486  put_bits(&s->pb, 1, 0); /* no repeat */
487  else
489  /* XXX: optimize the generation of this flag with entropy measures */
491 
492  put_bits(&s->pb, 1, s->frame_pred_frame_dct);
494  put_bits(&s->pb, 1, s->q_scale_type);
495  put_bits(&s->pb, 1, s->intra_vlc_format);
496  put_bits(&s->pb, 1, s->alternate_scan);
497  put_bits(&s->pb, 1, s->repeat_first_field);
499  /* chroma_420_type */
500  put_bits(&s->pb, 1, s->chroma_format ==
501  CHROMA_420 ? s->progressive_frame : 0);
502  put_bits(&s->pb, 1, s->progressive_frame);
503  put_bits(&s->pb, 1, 0); /* composite_display_flag */
504  }
505  if (s->scan_offset) {
506  int i;
507 
509  for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
511  }
514  if (side_data) {
515  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
516  uint8_t fpa_type;
517 
518  switch (stereo->type) {
520  fpa_type = 0x03;
521  break;
523  fpa_type = 0x04;
524  break;
525  case AV_STEREO3D_2D:
526  fpa_type = 0x08;
527  break;
529  fpa_type = 0x23;
530  break;
531  default:
532  fpa_type = 0;
533  break;
534  }
535 
536  if (fpa_type != 0) {
538  put_bits(&s->pb, 8, 'J'); // S3D_video_format_signaling_identifier
539  put_bits(&s->pb, 8, 'P');
540  put_bits(&s->pb, 8, '3');
541  put_bits(&s->pb, 8, 'D');
542  put_bits(&s->pb, 8, 0x03); // S3D_video_format_length
543 
544  put_bits(&s->pb, 1, 1); // reserved_bit
545  put_bits(&s->pb, 7, fpa_type); // S3D_video_format_type
546  put_bits(&s->pb, 8, 0x04); // reserved_data[0]
547  put_bits(&s->pb, 8, 0xFF); // reserved_data[1]
548  }
549  }
550 
551  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->a53_cc) {
554  if (side_data) {
555  if (side_data->size <= A53_MAX_CC_COUNT * 3 && side_data->size % 3 == 0) {
556  int i = 0;
557 
559 
560  put_bits(&s->pb, 8, 'G'); // user_identifier
561  put_bits(&s->pb, 8, 'A');
562  put_bits(&s->pb, 8, '9');
563  put_bits(&s->pb, 8, '4');
564  put_bits(&s->pb, 8, 3); // user_data_type_code
565  put_bits(&s->pb, 8,
566  (side_data->size / 3 & A53_MAX_CC_COUNT) | 0x40); // flags, cc_count
567  put_bits(&s->pb, 8, 0xff); // em_data
568 
569  for (i = 0; i < side_data->size; i++)
570  put_bits(&s->pb, 8, side_data->data[i]);
571 
572  put_bits(&s->pb, 8, 0xff); // marker_bits
573  } else {
575  "Warning Closed Caption size (%d) can not exceed 93 bytes "
576  "and must be a multiple of 3\n", side_data->size);
577  }
578  }
579  }
580 
581  s->mb_y = 0;
583 }
584 
585 static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
586  int has_mv, int field_motion)
587 {
588  put_bits(&s->pb, n, bits);
589  if (!s->frame_pred_frame_dct) {
590  if (has_mv)
591  /* motion_type: frame/field */
592  put_bits(&s->pb, 2, 2 - field_motion);
593  put_bits(&s->pb, 1, s->interlaced_dct);
594  }
595 }
596 
597 // RAL: Parameter added: f_or_b_code
598 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
599 {
600  if (val == 0) {
601  /* zero vector */
602  put_bits(&s->pb,
605  } else {
606  int code, sign, bits;
607  int bit_size = f_or_b_code - 1;
608  int range = 1 << bit_size;
609  /* modulo encoding */
610  val = sign_extend(val, 5 + bit_size);
611 
612  if (val >= 0) {
613  val--;
614  code = (val >> bit_size) + 1;
615  bits = val & (range - 1);
616  sign = 0;
617  } else {
618  val = -val;
619  val--;
620  code = (val >> bit_size) + 1;
621  bits = val & (range - 1);
622  sign = 1;
623  }
624 
625  av_assert2(code > 0 && code <= 16);
626 
627  put_bits(&s->pb,
630 
631  put_bits(&s->pb, 1, sign);
632  if (bit_size > 0)
633  put_bits(&s->pb, bit_size, bits);
634  }
635 }
636 
637 static inline void encode_dc(MpegEncContext *s, int diff, int component)
638 {
639  unsigned int diff_u = diff + 255;
640  if (diff_u >= 511) {
641  int index;
642 
643  if (diff < 0) {
644  index = av_log2_16bit(-2 * diff);
645  diff--;
646  } else {
647  index = av_log2_16bit(2 * diff);
648  }
649  if (component == 0)
650  put_bits(&s->pb,
651  ff_mpeg12_vlc_dc_lum_bits[index] + index,
652  (ff_mpeg12_vlc_dc_lum_code[index] << index) +
653  av_mod_uintp2(diff, index));
654  else
655  put_bits(&s->pb,
656  ff_mpeg12_vlc_dc_chroma_bits[index] + index,
657  (ff_mpeg12_vlc_dc_chroma_code[index] << index) +
658  av_mod_uintp2(diff, index));
659  } else {
660  if (component == 0)
661  put_bits(&s->pb,
662  mpeg1_lum_dc_uni[diff + 255] & 0xFF,
663  mpeg1_lum_dc_uni[diff + 255] >> 8);
664  else
665  put_bits(&s->pb,
666  mpeg1_chr_dc_uni[diff + 255] & 0xFF,
667  mpeg1_chr_dc_uni[diff + 255] >> 8);
668  }
669 }
670 
671 static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n)
672 {
673  int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
674  int code, component;
675  const uint16_t (*table_vlc)[2] = ff_rl_mpeg1.table_vlc;
676 
677  last_index = s->block_last_index[n];
678 
679  /* DC coef */
680  if (s->mb_intra) {
681  component = (n <= 3 ? 0 : (n & 1) + 1);
682  dc = block[0]; /* overflow is impossible */
683  diff = dc - s->last_dc[component];
684  encode_dc(s, diff, component);
685  s->last_dc[component] = dc;
686  i = 1;
687  if (s->intra_vlc_format)
688  table_vlc = ff_rl_mpeg2.table_vlc;
689  } else {
690  /* encode the first coefficient: needs to be done here because
691  * it is handled slightly differently */
692  level = block[0];
693  if (abs(level) == 1) {
694  code = ((uint32_t)level >> 31); /* the sign bit */
695  put_bits(&s->pb, 2, code | 0x02);
696  i = 1;
697  } else {
698  i = 0;
699  last_non_zero = -1;
700  goto next_coef;
701  }
702  }
703 
704  /* now quantify & encode AC coefs */
705  last_non_zero = i - 1;
706 
707  for (; i <= last_index; i++) {
708  j = s->intra_scantable.permutated[i];
709  level = block[j];
710 
711 next_coef:
712  /* encode using VLC */
713  if (level != 0) {
714  run = i - last_non_zero - 1;
715 
716  alevel = level;
717  MASK_ABS(sign, alevel);
718  sign &= 1;
719 
720  if (alevel <= mpeg1_max_level[0][run]) {
721  code = mpeg1_index_run[0][run] + alevel - 1;
722  /* store the VLC & sign at once */
723  put_bits(&s->pb, table_vlc[code][1] + 1,
724  (table_vlc[code][0] << 1) + sign);
725  } else {
726  /* escape seems to be pretty rare <5% so I do not optimize it */
727  put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]);
728  /* escape: only clip in this case */
729  put_bits(&s->pb, 6, run);
730  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
731  if (alevel < 128) {
732  put_sbits(&s->pb, 8, level);
733  } else {
734  if (level < 0)
735  put_bits(&s->pb, 16, 0x8001 + level + 255);
736  else
737  put_sbits(&s->pb, 16, level);
738  }
739  } else {
740  put_sbits(&s->pb, 12, level);
741  }
742  }
743  last_non_zero = i;
744  }
745  }
746  /* end of block */
747  put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
748 }
749 
751  int16_t block[8][64],
752  int motion_x, int motion_y,
753  int mb_block_count)
754 {
755  int i, cbp;
756  const int mb_x = s->mb_x;
757  const int mb_y = s->mb_y;
758  const int first_mb = mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
759 
760  /* compute cbp */
761  cbp = 0;
762  for (i = 0; i < mb_block_count; i++)
763  if (s->block_last_index[i] >= 0)
764  cbp |= 1 << (mb_block_count - 1 - i);
765 
766  if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 &&
767  (mb_x != s->mb_width - 1 ||
768  (mb_y != s->end_mb_y - 1 && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)) &&
769  ((s->pict_type == AV_PICTURE_TYPE_P && (motion_x | motion_y) == 0) ||
770  (s->pict_type == AV_PICTURE_TYPE_B && s->mv_dir == s->last_mv_dir &&
771  (((s->mv_dir & MV_DIR_FORWARD)
772  ? ((s->mv[0][0][0] - s->last_mv[0][0][0]) |
773  (s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
774  ((s->mv_dir & MV_DIR_BACKWARD)
775  ? ((s->mv[1][0][0] - s->last_mv[1][0][0]) |
776  (s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
777  s->mb_skip_run++;
778  s->qscale -= s->dquant;
779  s->skip_count++;
780  s->misc_bits++;
781  s->last_bits++;
782  if (s->pict_type == AV_PICTURE_TYPE_P) {
783  s->last_mv[0][0][0] =
784  s->last_mv[0][0][1] =
785  s->last_mv[0][1][0] =
786  s->last_mv[0][1][1] = 0;
787  }
788  } else {
789  if (first_mb) {
790  av_assert0(s->mb_skip_run == 0);
791  encode_mb_skip_run(s, s->mb_x);
792  } else {
794  }
795 
796  if (s->pict_type == AV_PICTURE_TYPE_I) {
797  if (s->dquant && cbp) {
798  /* macroblock_type: macroblock_quant = 1 */
799  put_mb_modes(s, 2, 1, 0, 0);
800  put_qscale(s);
801  } else {
802  /* macroblock_type: macroblock_quant = 0 */
803  put_mb_modes(s, 1, 1, 0, 0);
804  s->qscale -= s->dquant;
805  }
806  s->misc_bits += get_bits_diff(s);
807  s->i_count++;
808  } else if (s->mb_intra) {
809  if (s->dquant && cbp) {
810  put_mb_modes(s, 6, 0x01, 0, 0);
811  put_qscale(s);
812  } else {
813  put_mb_modes(s, 5, 0x03, 0, 0);
814  s->qscale -= s->dquant;
815  }
816  s->misc_bits += get_bits_diff(s);
817  s->i_count++;
818  memset(s->last_mv, 0, sizeof(s->last_mv));
819  } else if (s->pict_type == AV_PICTURE_TYPE_P) {
820  if (s->mv_type == MV_TYPE_16X16) {
821  if (cbp != 0) {
822  if ((motion_x | motion_y) == 0) {
823  if (s->dquant) {
824  /* macroblock_pattern & quant */
825  put_mb_modes(s, 5, 1, 0, 0);
826  put_qscale(s);
827  } else {
828  /* macroblock_pattern only */
829  put_mb_modes(s, 2, 1, 0, 0);
830  }
831  s->misc_bits += get_bits_diff(s);
832  } else {
833  if (s->dquant) {
834  put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */
835  put_qscale(s);
836  } else {
837  put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */
838  }
839  s->misc_bits += get_bits_diff(s);
840  // RAL: f_code parameter added
842  motion_x - s->last_mv[0][0][0],
843  s->f_code);
844  // RAL: f_code parameter added
846  motion_y - s->last_mv[0][0][1],
847  s->f_code);
848  s->mv_bits += get_bits_diff(s);
849  }
850  } else {
851  put_bits(&s->pb, 3, 1); /* motion only */
852  if (!s->frame_pred_frame_dct)
853  put_bits(&s->pb, 2, 2); /* motion_type: frame */
854  s->misc_bits += get_bits_diff(s);
855  // RAL: f_code parameter added
857  motion_x - s->last_mv[0][0][0],
858  s->f_code);
859  // RAL: f_code parameter added
861  motion_y - s->last_mv[0][0][1],
862  s->f_code);
863  s->qscale -= s->dquant;
864  s->mv_bits += get_bits_diff(s);
865  }
866  s->last_mv[0][1][0] = s->last_mv[0][0][0] = motion_x;
867  s->last_mv[0][1][1] = s->last_mv[0][0][1] = motion_y;
868  } else {
870 
871  if (cbp) {
872  if (s->dquant) {
873  put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
874  put_qscale(s);
875  } else {
876  put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
877  }
878  } else {
879  put_bits(&s->pb, 3, 1); /* motion only */
880  put_bits(&s->pb, 2, 1); /* motion_type: field */
881  s->qscale -= s->dquant;
882  }
883  s->misc_bits += get_bits_diff(s);
884  for (i = 0; i < 2; i++) {
885  put_bits(&s->pb, 1, s->field_select[0][i]);
887  s->mv[0][i][0] - s->last_mv[0][i][0],
888  s->f_code);
890  s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
891  s->f_code);
892  s->last_mv[0][i][0] = s->mv[0][i][0];
893  s->last_mv[0][i][1] = 2 * s->mv[0][i][1];
894  }
895  s->mv_bits += get_bits_diff(s);
896  }
897  if (cbp) {
898  if (s->chroma_y_shift) {
899  put_bits(&s->pb,
900  ff_mpeg12_mbPatTable[cbp][1],
901  ff_mpeg12_mbPatTable[cbp][0]);
902  } else {
903  put_bits(&s->pb,
904  ff_mpeg12_mbPatTable[cbp >> 2][1],
905  ff_mpeg12_mbPatTable[cbp >> 2][0]);
906  put_sbits(&s->pb, 2, cbp);
907  }
908  }
909  s->f_count++;
910  } else {
911  if (s->mv_type == MV_TYPE_16X16) {
912  if (cbp) { // With coded bloc pattern
913  if (s->dquant) {
914  if (s->mv_dir == MV_DIR_FORWARD)
915  put_mb_modes(s, 6, 3, 1, 0);
916  else
917  put_mb_modes(s, 8 - s->mv_dir, 2, 1, 0);
918  put_qscale(s);
919  } else {
920  put_mb_modes(s, 5 - s->mv_dir, 3, 1, 0);
921  }
922  } else { // No coded bloc pattern
923  put_bits(&s->pb, 5 - s->mv_dir, 2);
924  if (!s->frame_pred_frame_dct)
925  put_bits(&s->pb, 2, 2); /* motion_type: frame */
926  s->qscale -= s->dquant;
927  }
928  s->misc_bits += get_bits_diff(s);
929  if (s->mv_dir & MV_DIR_FORWARD) {
931  s->mv[0][0][0] - s->last_mv[0][0][0],
932  s->f_code);
934  s->mv[0][0][1] - s->last_mv[0][0][1],
935  s->f_code);
936  s->last_mv[0][0][0] =
937  s->last_mv[0][1][0] = s->mv[0][0][0];
938  s->last_mv[0][0][1] =
939  s->last_mv[0][1][1] = s->mv[0][0][1];
940  s->f_count++;
941  }
942  if (s->mv_dir & MV_DIR_BACKWARD) {
944  s->mv[1][0][0] - s->last_mv[1][0][0],
945  s->b_code);
947  s->mv[1][0][1] - s->last_mv[1][0][1],
948  s->b_code);
949  s->last_mv[1][0][0] =
950  s->last_mv[1][1][0] = s->mv[1][0][0];
951  s->last_mv[1][0][1] =
952  s->last_mv[1][1][1] = s->mv[1][0][1];
953  s->b_count++;
954  }
955  } else {
958  if (cbp) { // With coded bloc pattern
959  if (s->dquant) {
960  if (s->mv_dir == MV_DIR_FORWARD)
961  put_mb_modes(s, 6, 3, 1, 1);
962  else
963  put_mb_modes(s, 8 - s->mv_dir, 2, 1, 1);
964  put_qscale(s);
965  } else {
966  put_mb_modes(s, 5 - s->mv_dir, 3, 1, 1);
967  }
968  } else { // No coded bloc pattern
969  put_bits(&s->pb, 5 - s->mv_dir, 2);
970  put_bits(&s->pb, 2, 1); /* motion_type: field */
971  s->qscale -= s->dquant;
972  }
973  s->misc_bits += get_bits_diff(s);
974  if (s->mv_dir & MV_DIR_FORWARD) {
975  for (i = 0; i < 2; i++) {
976  put_bits(&s->pb, 1, s->field_select[0][i]);
978  s->mv[0][i][0] - s->last_mv[0][i][0],
979  s->f_code);
981  s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
982  s->f_code);
983  s->last_mv[0][i][0] = s->mv[0][i][0];
984  s->last_mv[0][i][1] = s->mv[0][i][1] * 2;
985  }
986  s->f_count++;
987  }
988  if (s->mv_dir & MV_DIR_BACKWARD) {
989  for (i = 0; i < 2; i++) {
990  put_bits(&s->pb, 1, s->field_select[1][i]);
992  s->mv[1][i][0] - s->last_mv[1][i][0],
993  s->b_code);
995  s->mv[1][i][1] - (s->last_mv[1][i][1] >> 1),
996  s->b_code);
997  s->last_mv[1][i][0] = s->mv[1][i][0];
998  s->last_mv[1][i][1] = s->mv[1][i][1] * 2;
999  }
1000  s->b_count++;
1001  }
1002  }
1003  s->mv_bits += get_bits_diff(s);
1004  if (cbp) {
1005  if (s->chroma_y_shift) {
1006  put_bits(&s->pb,
1007  ff_mpeg12_mbPatTable[cbp][1],
1008  ff_mpeg12_mbPatTable[cbp][0]);
1009  } else {
1010  put_bits(&s->pb,
1011  ff_mpeg12_mbPatTable[cbp >> 2][1],
1012  ff_mpeg12_mbPatTable[cbp >> 2][0]);
1013  put_sbits(&s->pb, 2, cbp);
1014  }
1015  }
1016  }
1017  for (i = 0; i < mb_block_count; i++)
1018  if (cbp & (1 << (mb_block_count - 1 - i)))
1019  mpeg1_encode_block(s, block[i], i);
1020  s->mb_skip_run = 0;
1021  if (s->mb_intra)
1022  s->i_tex_bits += get_bits_diff(s);
1023  else
1024  s->p_tex_bits += get_bits_diff(s);
1025  }
1026 }
1027 
1029  int motion_x, int motion_y)
1030 {
1031  if (s->chroma_format == CHROMA_420)
1032  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6);
1033  else
1034  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8);
1035 }
1036 
1038 {
1039  static int done = 0;
1040 
1042 
1043  if (!done) {
1044  int f_code;
1045  int mv;
1046  int i;
1047 
1048  done = 1;
1051 
1052  for (i = 0; i < 64; i++) {
1055  }
1056 
1058  if (s->intra_vlc_format)
1060 
1061  /* build unified dc encoding tables */
1062  for (i = -255; i < 256; i++) {
1063  int adiff, index;
1064  int bits, code;
1065  int diff = i;
1066 
1067  adiff = FFABS(diff);
1068  if (diff < 0)
1069  diff--;
1070  index = av_log2(2 * adiff);
1071 
1073  code = (ff_mpeg12_vlc_dc_lum_code[index] << index) +
1074  av_mod_uintp2(diff, index);
1075  mpeg1_lum_dc_uni[i + 255] = bits + (code << 8);
1076 
1079  av_mod_uintp2(diff, index);
1080  mpeg1_chr_dc_uni[i + 255] = bits + (code << 8);
1081  }
1082 
1083  for (f_code = 1; f_code <= MAX_FCODE; f_code++)
1084  for (mv = -MAX_DMV; mv <= MAX_DMV; mv++) {
1085  int len;
1086 
1087  if (mv == 0) {
1088  len = ff_mpeg12_mbMotionVectorTable[0][1];
1089  } else {
1090  int val, bit_size, code;
1091 
1092  bit_size = f_code - 1;
1093 
1094  val = mv;
1095  if (val < 0)
1096  val = -val;
1097  val--;
1098  code = (val >> bit_size) + 1;
1099  if (code < 17)
1101  1 + bit_size;
1102  else
1103  len = ff_mpeg12_mbMotionVectorTable[16][1] +
1104  2 + bit_size;
1105  }
1106 
1107  mv_penalty[f_code][mv + MAX_DMV] = len;
1108  }
1109 
1110 
1111  for (f_code = MAX_FCODE; f_code > 0; f_code--)
1112  for (mv = -(8 << f_code); mv < (8 << f_code); mv++)
1113  fcode_tab[mv + MAX_MV] = f_code;
1114  }
1115  s->me.mv_penalty = mv_penalty;
1116  s->fcode_tab = fcode_tab;
1117  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1118  s->min_qcoeff = -255;
1119  s->max_qcoeff = 255;
1120  } else {
1121  s->min_qcoeff = -2047;
1122  s->max_qcoeff = 2047;
1123  }
1124  if (s->intra_vlc_format) {
1125  s->intra_ac_vlc_length =
1127  } else {
1128  s->intra_ac_vlc_length =
1130  }
1131  s->inter_ac_vlc_length =
1133 }
1134 
1135 #define OFFSET(x) offsetof(MpegEncContext, x)
1136 #define VE AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
1137 #define COMMON_OPTS \
1138  { "gop_timecode", "MPEG GOP Timecode in hh:mm:ss[:;.]ff format. Overrides timecode_frame_start.", \
1139  OFFSET(tc_opt_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE },\
1140  { "intra_vlc", "Use MPEG-2 intra VLC table.", \
1141  OFFSET(intra_vlc_format), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1142  { "drop_frame_timecode", "Timecode is in drop frame format.", \
1143  OFFSET(drop_frame_timecode), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1144  { "scan_offset", "Reserve space for SVCD scan offset user data.", \
1145  OFFSET(scan_offset), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1146  { "timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", \
1147  OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = -1 }, -1, INT64_MAX, VE}, \
1148 
1149 static const AVOption mpeg1_options[] = {
1150  COMMON_OPTS
1152  { NULL },
1153 };
1154 
1155 static const AVOption mpeg2_options[] = {
1156  COMMON_OPTS
1157  { "non_linear_quant", "Use nonlinear quantizer.", OFFSET(q_scale_type), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1158  { "alternate_scan", "Enable alternate scantable.", OFFSET(alternate_scan), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1159  { "seq_disp_ext", "Write sequence_display_extension blocks.", OFFSET(seq_disp_ext), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "seq_disp_ext" },
1160  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, VE, "seq_disp_ext" },
1161  { "never", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, VE, "seq_disp_ext" },
1162  { "always", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, VE, "seq_disp_ext" },
1163  { "video_format", "Video_format in the sequence_display_extension indicating the source of the video.", OFFSET(video_format), AV_OPT_TYPE_INT, { .i64 = VIDEO_FORMAT_UNSPECIFIED }, 0, 7, VE, "video_format" },
1164  { "component", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_COMPONENT }, 0, 0, VE, "video_format" },
1165  { "pal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_PAL }, 0, 0, VE, "video_format" },
1166  { "ntsc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_NTSC }, 0, 0, VE, "video_format" },
1167  { "secam", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_SECAM }, 0, 0, VE, "video_format" },
1168  { "mac", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_MAC }, 0, 0, VE, "video_format" },
1169  { "unspecified", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_UNSPECIFIED}, 0, 0, VE, "video_format" },
1172  { NULL },
1173 };
1174 
1175 #define mpeg12_class(x) \
1176 static const AVClass mpeg ## x ## _class = { \
1177  .class_name = "mpeg" # x "video encoder", \
1178  .item_name = av_default_item_name, \
1179  .option = mpeg ## x ## _options, \
1180  .version = LIBAVUTIL_VERSION_INT, \
1181 };
1182 
1184 mpeg12_class(2)
1185 
1187  .name = "mpeg1video",
1188  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
1189  .type = AVMEDIA_TYPE_VIDEO,
1190  .id = AV_CODEC_ID_MPEG1VIDEO,
1191  .priv_data_size = sizeof(MpegEncContext),
1192  .init = encode_init,
1193  .encode2 = ff_mpv_encode_picture,
1194  .close = ff_mpv_encode_end,
1195  .supported_framerates = ff_mpeg12_frame_rate_tab + 1,
1196  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
1197  AV_PIX_FMT_NONE },
1199  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1200  .priv_class = &mpeg1_class,
1201 };
1202 
1204  .name = "mpeg2video",
1205  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
1206  .type = AVMEDIA_TYPE_VIDEO,
1207  .id = AV_CODEC_ID_MPEG2VIDEO,
1208  .priv_data_size = sizeof(MpegEncContext),
1209  .init = encode_init,
1210  .encode2 = ff_mpv_encode_picture,
1211  .close = ff_mpv_encode_end,
1212  .supported_framerates = ff_mpeg2_frame_rate_tab,
1213  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
1215  AV_PIX_FMT_NONE },
1217  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1218  .priv_class = &mpeg2_class,
1219 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1594
av_cold void ff_mpeg1_encode_init(MpegEncContext *s)
Definition: mpeg12enc.c:1037
static uint8_t uni_mpeg1_ac_vlc_len[64 *64 *2]
Definition: mpeg12enc.c:54
#define MASK_ABS(mask, level)
Definition: mathops.h:155
#define NULL
Definition: coverity.c:32
AVCodec ff_mpeg2video_encoder
Definition: mpeg12enc.c:1203
int64_t timecode_frame_start
GOP timecode frame start number, in non drop frame format.
Definition: mpegvideo.h:463
int aspect_ratio_info
Definition: mpegvideo.h:402
int picture_number
Definition: mpegvideo.h:127
const AVRational ff_mpeg2_frame_rate_tab[]
Definition: mpeg12data.c:308
#define FF_PROFILE_MPEG2_MAIN
Definition: avcodec.h:1892
AVOption.
Definition: opt.h:248
uint8_t * fcode_tab
smallest fcode needed for each MV
Definition: mpegvideo.h:279
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:269
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG-1 & B-frame MPEG-4
Definition: mpegvideo.h:278
static int find_frame_rate_index(MpegEncContext *s)
Definition: mpeg12enc.c:102
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:240
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define VIDEO_FORMAT_COMPONENT
Definition: mpegvideo.h:474
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:154
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define MAX_MV
Definition: motion_est.h:35
int height
Definition: avcodec.h:433
#define FF_MPV_COMMON_OPTS
Definition: mpegvideo.h:616
int num
Numerator.
Definition: rational.h:59
const unsigned char ff_mpeg12_vlc_dc_lum_bits[12]
Definition: mpeg12data.c:55
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:117
enum AVCodecID codec_id
Definition: mpegvideo.h:112
int av_log2(unsigned v)
Definition: intmath.c:26
void avpriv_align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: bitstream.c:48
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:905
int scan_offset
reserve space for SVCD scan offset user data.
Definition: mpegvideo.h:494
int min_qcoeff
minimum encodable coefficient
Definition: mpegvideo.h:308
mpegvideo header.
uint8_t permutated[64]
Definition: idctdsp.h:33
const uint16_t ff_mpeg12_vlc_dc_lum_code[12]
Definition: mpeg12data.c:52
Views are next to each other.
Definition: stereo3d.h:67
uint8_t run
Definition: svq3.c:208
uint8_t * intra_ac_vlc_length
Definition: mpegvideo.h:311
static void error(const char *err)
#define UNI_AC_ENC_INDEX(run, level)
Definition: mpegvideo.h:318
#define SLICE_MIN_START_CODE
Definition: mpegvideo.h:71
int profile
profile
Definition: avcodec.h:1859
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
AVCodec.
Definition: codec.h:190
#define MAX_FCODE
Definition: mpegutils.h:48
int framerate
Definition: h264_levels.c:65
uint8_t(* mv_penalty)[MAX_DMV *2+1]
bit amount needed to encode a MV
Definition: motion_est.h:93
int qscale
QP.
Definition: mpegvideo.h:204
RLTable.
Definition: rl.h:39
int field_select[2][2]
Definition: mpegvideo.h:277
Macro definitions for various function/variable attributes.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:649
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:739
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1983
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:75
#define VIDEO_FORMAT_NTSC
Definition: mpegvideo.h:476
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx)
Parse timecode representation (hh:mm:ss[:;.
Definition: timecode.c:226
AVRational mpeg2_frame_rate_ext
Definition: mpegvideo.h:218
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:88
#define VIDEO_FORMAT_PAL
Definition: mpegvideo.h:475
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
static uint32_t mpeg1_lum_dc_uni[512]
Definition: mpeg12enc.c:59
AVOptions.
static void encode_mb_skip_run(MpegEncContext *s, int run)
Definition: mpeg12enc.c:397
RLTable ff_rl_mpeg2
Definition: mpeg12data.c:174
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:176
int me_range
maximum motion estimation search range in subpel units If 0 then no limit.
Definition: avcodec.h:997
timecode is drop frame
Definition: timecode.h:36
const float ff_mpeg1_aspect[16]
Definition: mpeg12data.c:374
int misc_bits
cbp, mb_type
Definition: mpegvideo.h:352
static const AVOption mpeg1_options[]
Definition: mpeg12enc.c:1149
static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12enc.c:671
int interlaced_dct
Definition: mpegvideo.h:491
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:180
#define CHROMA_420
Definition: mpegvideo.h:483
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:52
#define VIDEO_FORMAT_UNSPECIFIED
Definition: mpegvideo.h:479
AVCodec ff_mpeg1video_encoder
int intra_dc_precision
Definition: mpegvideo.h:464
int repeat_first_field
Definition: mpegvideo.h:480
Structure to hold side data for an AVFrame.
Definition: frame.h:214
#define height
static int8_t mpeg1_max_level[2][64]
Definition: mpeg12enc.c:63
int start
timecode frame start (first base frame number)
Definition: timecode.h:42
int8_t * max_level[2]
encoding & decoding
Definition: rl.h:46
#define VIDEO_FORMAT_SECAM
Definition: mpegvideo.h:477
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:55
static const uint8_t header[24]
Definition: sdr2.c:67
int max_qcoeff
maximum encodable coefficient
Definition: mpegvideo.h:309
int dquant
qscale difference to prev qscale
Definition: mpegvideo.h:210
int gop_picture_number
index of the first picture of a GOP based on fake_pic_num & MPEG-1 specific
Definition: mpegvideo.h:451
#define av_log(a,...)
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1593
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:755
int intra_only
if true, only intra pictures are generated
Definition: mpegvideo.h:102
#define MAX_DMV
Definition: motion_est.h:37
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:185
static void put_mb_modes(MpegEncContext *s, int n, int bits, int has_mv, int field_motion)
Definition: mpeg12enc.c:585
uint8_t * inter_ac_vlc_last_length
Definition: mpegvideo.h:316
int chroma_y_shift
Definition: mpegvideo.h:487
int strict_std_compliance
strictly follow the std (MPEG-4, ...)
Definition: mpegvideo.h:118
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
#define VIDEO_FORMAT_MAC
Definition: mpegvideo.h:478
const uint16_t ff_mpeg12_vlc_dc_chroma_code[12]
Definition: mpeg12data.c:59
static void encode_dc(MpegEncContext *s, int diff, int component)
Definition: mpeg12enc.c:637
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
uint8_t * buf
Definition: put_bits.h:38
simple assert() macros that are a bit more flexible than ISO C assert().
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
const char * name
Name of the codec implementation.
Definition: codec.h:197
uint8_t bits
Definition: vp3data.h:202
int width
width and height in 1/16 pel
Definition: avcodec.h:432
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:406
attribute_deprecated int64_t timecode_frame_start
Definition: avcodec.h:1488
static void mpeg1_encode_sequence_header(MpegEncContext *s)
Definition: mpeg12enc.c:242
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
Definition: mpeg12enc.c:598
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:67
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
int resync_mb_x
x position of last resync marker
Definition: mpegvideo.h:356
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1389
uint8_t * intra_ac_vlc_last_length
Definition: mpegvideo.h:312
#define mpeg12_class(x)
Definition: mpeg12enc.c:1175
int intra_vlc_format
Definition: mpegvideo.h:470
#define FF_PROFILE_MPEG2_HIGH
Definition: avcodec.h:1889
int progressive_frame
Definition: mpegvideo.h:489
uint8_t * vbv_delay_ptr
pointer to vbv_delay in the bitstream
Definition: mpegvideo.h:453
const uint16_t(* table_vlc)[2]
Definition: rl.h:42
static uint8_t fcode_tab[MAX_MV *2+1]
Definition: mpeg12enc.c:52
#define width
int width
picture width / height.
Definition: avcodec.h:699
const unsigned char ff_mpeg12_vlc_dc_chroma_bits[12]
Definition: mpeg12data.c:62
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:184
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1860
RLTable ff_rl_mpeg1
Definition: mpeg12data.c:166
int alternate_scan
Definition: mpegvideo.h:471
#define GOP_START_CODE
Definition: mpegvideo.h:69
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1140
#define FF_PROFILE_MPEG2_422
Definition: avcodec.h:1888
static uint8_t uni_mpeg2_ac_vlc_len[64 *64 *2]
Definition: mpeg12enc.c:55
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int level
level
Definition: avcodec.h:1982
#define VE
Definition: mpeg12enc.c:1136
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:86
MotionEstContext me
Definition: mpegvideo.h:282
#define EXT_START_CODE
Definition: cavs.h:33
static av_cold void init_uni_ac_vlc(RLTable *rl, uint8_t *uni_ac_vlc_len)
Definition: mpeg12enc.c:67
static void put_header(MpegEncContext *s, int header)
Definition: mpeg12enc.c:234
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
if(ret)
static const uint8_t svcd_scan_offset_placeholder[]
Definition: mpeg12enc.c:46
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:110
static const int8_t mv[256][2]
Definition: 4xm.c:77
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
int frame_pred_frame_dct
Definition: mpegvideo.h:465
#define AV_CODEC_FLAG2_DROP_FRAME_TIMECODE
timecode is in drop frame format.
Definition: avcodec.h:361
int av_timecode_adjust_ntsc_framenum2(int framenum, int fps)
Adjust frame number for NTSC drop frame time code.
Definition: timecode.c:34
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:263
int coded_picture_number
picture number in bitstream order
Definition: frame.h:422
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
int concealment_motion_vectors
Definition: mpegvideo.h:467
Libavcodec external API header.
Views are on top of each other.
Definition: stereo3d.h:79
char * tc_opt_str
timecode option string
Definition: mpegvideo.h:500
Timecode helpers header.
#define A53_MAX_CC_COUNT
Definition: mpeg12enc.c:65
#define abs(x)
Definition: cuda_runtime.h:35
main external API structure.
Definition: avcodec.h:526
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff)*mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
ScanTable intra_scantable
Definition: mpegvideo.h:91
#define USER_START_CODE
Definition: cavs.h:34
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:100
MPEG-1/2 tables.
static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s, int16_t block[8][64], int motion_x, int motion_y, int mb_block_count)
Definition: mpeg12enc.c:750
uint8_t * data
Definition: frame.h:216
av_cold int ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:39
int ff_mpv_encode_init(AVCodecContext *avctx)
uint8_t * inter_ac_vlc_length
Definition: mpegvideo.h:315
static uint8_t mpeg1_index_run[2][64]
Definition: mpeg12enc.c:62
int progressive_sequence
Definition: mpegvideo.h:456
uint16_t * intra_matrix
custom intra quantization matrix Must be allocated with the av_malloc() family of functions...
Definition: avcodec.h:1026
static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
Definition: mpeg12enc.c:51
#define FF_MPEG2_PROFILE_OPTS
Definition: profiles.h:46
int index
Definition: gxfenc.c:89
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
struct AVFrame * f
Definition: mpegpicture.h:46
#define COMMON_OPTS
Definition: mpeg12enc.c:1137
uint8_t * index_run[2]
encoding only
Definition: rl.h:45
#define OFFSET(x)
Definition: mpeg12enc.c:1135
void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: mpeg12enc.c:426
int f_code
forward MV resolution
Definition: mpegvideo.h:238
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
uint16_t * inter_matrix
custom inter quantization matrix Must be allocated with the av_malloc() family of functions...
Definition: avcodec.h:1035
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:212
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
av_cold void ff_mpeg12_common_init(MpegEncContext *s)
Definition: mpeg12.c:107
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
int last_mv_dir
last mv_dir, used for B-frame encoding
Definition: mpegvideo.h:452
void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64], int motion_x, int motion_y)
Definition: mpeg12enc.c:1028
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
Pan Scan area.
Definition: avcodec.h:419
uint8_t level
Definition: svq3.c:209
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
Definition: mpegvideo.h:276
static av_cold int encode_init(AVCodecContext *avctx)
Definition: mpeg12enc.c:141
MpegEncContext.
Definition: mpegvideo.h:81
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
PutBitContext pb
bit output
Definition: mpegvideo.h:151
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
const AVRational ff_mpeg2_aspect[16]
Definition: mpeg12data.c:395
static av_always_inline void put_qscale(MpegEncContext *s)
Definition: mpeg12enc.c:407
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
static uint32_t mpeg1_chr_dc_uni[512]
Definition: mpeg12enc.c:60
static const AVOption mpeg2_options[]
Definition: mpeg12enc.c:1155
uint8_t ff_mpeg12_static_rl_table_store[2][2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: mpeg12.c:44
int av_nearer_q(AVRational q, AVRational q1, AVRational q2)
Find which of the two rationals is closer to another rational.
Definition: rational.c:127
Bi-dir predicted.
Definition: avutil.h:276
Stereoscopic video.
const uint8_t ff_mpeg12_mbPatTable[64][2]
Definition: mpeg12data.c:221
int den
Denominator.
Definition: rational.h:60
int ff_mpv_encode_end(AVCodecContext *avctx)
void * priv_data
Definition: avcodec.h:553
void ff_mpeg1_encode_slice_header(MpegEncContext *s)
Definition: mpeg12enc.c:412
#define PICT_FRAME
Definition: mpegutils.h:39
int last_bits
temp var used for calculating the above vars
Definition: mpegvideo.h:353
int frame_rate_index
Definition: mpegvideo.h:217
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int picture_structure
Definition: mpegvideo.h:461
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:460
int len
#define SEQ_START_CODE
Definition: mpegvideo.h:68
int drop_frame_timecode
timecode is in drop frame format.
Definition: mpegvideo.h:493
int resync_mb_y
y position of last resync marker
Definition: mpegvideo.h:357
const uint8_t ff_mpeg12_mbAddrIncrTable[36][2]
Definition: mpeg12data.c:182
int64_t bit_rate
wanted bit rate
Definition: mpegvideo.h:103
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:386
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:613
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
const uint8_t ff_mpeg12_mbMotionVectorTable[17][2]
Definition: mpeg12data.c:288
#define PICTURE_START_CODE
Definition: mpegvideo.h:70
#define av_always_inline
Definition: attributes.h:45
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:343
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
int b_code
backward MV resolution for B-frames (MPEG-4)
Definition: mpegvideo.h:239
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
AVTimecode tc
timecode context
Definition: mpegvideo.h:501
uint32_t flags
flags such as drop frame, +24 hours support, ...
Definition: timecode.h:43
Stereoscopic 3d metadata.
Definition: frame.h:63
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1589
int i
Definition: input.c:406
Predicted.
Definition: avutil.h:275
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1404
const AVRational ff_mpeg12_frame_rate_tab[]