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 
46  0x10, 0x0E, 0x00, 0x80, 0x81, 0x00, 0x80,
47  0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
48 };
49 
50 static uint8_t mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
51 static uint8_t fcode_tab[MAX_MV * 2 + 1];
52 
53 static uint8_t uni_mpeg1_ac_vlc_len[64 * 64 * 2];
54 static uint8_t uni_mpeg2_ac_vlc_len[64 * 64 * 2];
55 
56 /* simple include everything table for dc, first byte is bits
57  * number next 3 are code */
58 static uint32_t mpeg1_lum_dc_uni[512];
59 static uint32_t mpeg1_chr_dc_uni[512];
60 
61 static uint8_t mpeg1_index_run[2][64];
62 static int8_t mpeg1_max_level[2][64];
63 
64 #define A53_MAX_CC_COUNT 0x1f
65 
66 static av_cold void init_uni_ac_vlc(RLTable *rl, uint8_t *uni_ac_vlc_len)
67 {
68  int i;
69 
70  for (i = 0; i < 128; i++) {
71  int level = i - 64;
72  int run;
73  if (!level)
74  continue;
75  for (run = 0; run < 64; run++) {
76  int len, code;
77  int alevel = FFABS(level);
78 
79  if (alevel > rl->max_level[0][run])
80  code = 111; /* rl->n */
81  else
82  code = rl->index_run[0][run] + alevel - 1;
83 
84  if (code < 111) { /* rl->n */
85  /* length of VLC and sign */
86  len = rl->table_vlc[code][1] + 1;
87  } else {
88  len = rl->table_vlc[111 /* rl->n */][1] + 6;
89 
90  if (alevel < 128)
91  len += 8;
92  else
93  len += 16;
94  }
95 
96  uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
97  }
98  }
99 }
100 
102 {
103  int i;
104  AVRational bestq = (AVRational) {0, 0};
105  AVRational ext;
106  AVRational target = av_inv_q(s->avctx->time_base);
107 
108  for (i = 1; i < 14; i++) {
110  i >= 9)
111  break;
112 
113  for (ext.num=1; ext.num <= 4; ext.num++) {
114  for (ext.den=1; ext.den <= 32; ext.den++) {
116 
117  if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO && (ext.den!=1 || ext.num!=1))
118  continue;
119  if (av_gcd(ext.den, ext.num) != 1)
120  continue;
121 
122  if ( bestq.num==0
123  || av_nearer_q(target, bestq, q) < 0
124  || ext.num==1 && ext.den==1 && av_nearer_q(target, bestq, q) == 0) {
125  bestq = q;
126  s->frame_rate_index = i;
127  s->mpeg2_frame_rate_ext.num = ext.num;
128  s->mpeg2_frame_rate_ext.den = ext.den;
129  }
130  }
131  }
132  }
133 
134  if (av_cmp_q(target, bestq))
135  return -1;
136  else
137  return 0;
138 }
139 
141 {
142  MpegEncContext *s = avctx->priv_data;
143 
144  if (ff_mpv_encode_init(avctx) < 0)
145  return -1;
146 
147  if (find_frame_rate_index(s) < 0) {
149  av_log(avctx, AV_LOG_ERROR, "MPEG-1/2 does not support %d/%d fps\n",
150  avctx->time_base.den, avctx->time_base.num);
151  return -1;
152  } else {
153  av_log(avctx, AV_LOG_INFO,
154  "MPEG-1/2 does not support %d/%d fps, there may be AV sync issues\n",
155  avctx->time_base.den, avctx->time_base.num);
156  }
157  }
158 
159  if (avctx->profile == FF_PROFILE_UNKNOWN) {
160  if (avctx->level != FF_LEVEL_UNKNOWN) {
161  av_log(avctx, AV_LOG_ERROR, "Set profile and level\n");
162  return -1;
163  }
164  /* Main or 4:2:2 */
165  avctx->profile = s->chroma_format == CHROMA_420 ? 4 : 0;
166  }
167 
168  if (avctx->level == FF_LEVEL_UNKNOWN) {
169  if (avctx->profile == 0) { /* 4:2:2 */
170  if (avctx->width <= 720 && avctx->height <= 608)
171  avctx->level = 5; /* Main */
172  else
173  avctx->level = 2; /* High */
174  } else {
175  if (avctx->profile != 1 && s->chroma_format != CHROMA_420) {
176  av_log(avctx, AV_LOG_ERROR,
177  "Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n");
178  return -1;
179  }
180  if (avctx->width <= 720 && avctx->height <= 576)
181  avctx->level = 8; /* Main */
182  else if (avctx->width <= 1440)
183  avctx->level = 6; /* High 1440 */
184  else
185  avctx->level = 4; /* High */
186  }
187  }
188 
189  if ((avctx->width & 0xFFF) == 0 && (avctx->height & 0xFFF) == 1) {
190  av_log(avctx, AV_LOG_ERROR, "Width / Height is invalid for MPEG2\n");
191  return AVERROR(EINVAL);
192  }
193 
195  if ((avctx->width & 0xFFF) == 0 || (avctx->height & 0xFFF) == 0) {
196  av_log(avctx, AV_LOG_ERROR, "Width or Height are not allowed to be multiples of 4096\n"
197  "add '-strict %d' if you want to use them anyway.\n", FF_COMPLIANCE_UNOFFICIAL);
198  return AVERROR(EINVAL);
199  }
200  }
201 
203  if (s->drop_frame_timecode)
205  if (s->drop_frame_timecode && s->frame_rate_index != 4) {
206  av_log(avctx, AV_LOG_ERROR,
207  "Drop frame time code only allowed with 1001/30000 fps\n");
208  return -1;
209  }
210 
211 #if FF_API_PRIVATE_OPT
213  if (avctx->timecode_frame_start)
216 #endif
217 
218  if (s->tc_opt_str) {
220  int ret = av_timecode_init_from_string(&s->tc, rate, s->tc_opt_str, s);
221  if (ret < 0)
222  return ret;
224  s->timecode_frame_start = s->tc.start;
225  } else {
226  s->timecode_frame_start = 0; // default is -1
227  }
228 
229  return 0;
230 }
231 
232 static void put_header(MpegEncContext *s, int header)
233 {
235  put_bits(&s->pb, 16, header >> 16);
236  put_sbits(&s->pb, 16, header);
237 }
238 
239 /* put sequence header if needed */
241 {
242  unsigned int vbv_buffer_size, fps, v;
243  int i, constraint_parameter_flag;
244  uint64_t time_code;
245  int64_t best_aspect_error = INT64_MAX;
246  AVRational aspect_ratio = s->avctx->sample_aspect_ratio;
247 
248  if (aspect_ratio.num == 0 || aspect_ratio.den == 0)
249  aspect_ratio = (AVRational){1,1}; // pixel aspect 1.1 (VGA)
250 
251  if (s->current_picture.f->key_frame) {
253 
254  /* MPEG-1 header repeated every GOP */
256 
257  put_sbits(&s->pb, 12, s->width & 0xFFF);
258  put_sbits(&s->pb, 12, s->height & 0xFFF);
259 
260  for (i = 1; i < 15; i++) {
261  int64_t error = aspect_ratio.num * (1LL<<32) / aspect_ratio.den;
262  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || i <= 1)
263  error -= (1LL<<32) / ff_mpeg1_aspect[i];
264  else
265  error -= (1LL<<32)*ff_mpeg2_aspect[i].num * s->height / s->width / ff_mpeg2_aspect[i].den;
266 
267  error = FFABS(error);
268 
269  if (error - 2 <= best_aspect_error) {
270  best_aspect_error = error;
271  s->aspect_ratio_info = i;
272  }
273  }
274 
275  put_bits(&s->pb, 4, s->aspect_ratio_info);
276  put_bits(&s->pb, 4, s->frame_rate_index);
277 
278  if (s->avctx->rc_max_rate) {
279  v = (s->avctx->rc_max_rate + 399) / 400;
280  if (v > 0x3ffff && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
281  v = 0x3ffff;
282  } else {
283  v = 0x3FFFF;
284  }
285 
286  if (s->avctx->rc_buffer_size)
287  vbv_buffer_size = s->avctx->rc_buffer_size;
288  else
289  /* VBV calculation: Scaled so that a VCD has the proper
290  * VBV size of 40 kilobytes */
291  vbv_buffer_size = ((20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
292  vbv_buffer_size = (vbv_buffer_size + 16383) / 16384;
293 
294  put_sbits(&s->pb, 18, v);
295  put_bits(&s->pb, 1, 1); // marker
296  put_sbits(&s->pb, 10, vbv_buffer_size);
297 
298  constraint_parameter_flag =
299  s->width <= 768 &&
300  s->height <= 576 &&
301  s->mb_width * s->mb_height <= 396 &&
302  s->mb_width * s->mb_height * framerate.num <= 396 * 25 * framerate.den &&
303  framerate.num <= framerate.den * 30 &&
304  s->avctx->me_range &&
305  s->avctx->me_range < 128 &&
306  vbv_buffer_size <= 20 &&
307  v <= 1856000 / 400 &&
309 
310  put_bits(&s->pb, 1, constraint_parameter_flag);
311 
314 
315  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
316  AVFrameSideData *side_data;
317  int width = s->width;
318  int height = s->height;
319  int use_seq_disp_ext;
320 
322  put_bits(&s->pb, 4, 1); // seq ext
323 
324  put_bits(&s->pb, 1, s->avctx->profile == 0); // escx 1 for 4:2:2 profile
325 
326  put_bits(&s->pb, 3, s->avctx->profile); // profile
327  put_bits(&s->pb, 4, s->avctx->level); // level
328 
329  put_bits(&s->pb, 1, s->progressive_sequence);
330  put_bits(&s->pb, 2, s->chroma_format);
331  put_bits(&s->pb, 2, s->width >> 12);
332  put_bits(&s->pb, 2, s->height >> 12);
333  put_bits(&s->pb, 12, v >> 18); // bitrate ext
334  put_bits(&s->pb, 1, 1); // marker
335  put_bits(&s->pb, 8, vbv_buffer_size >> 10); // vbv buffer ext
336  put_bits(&s->pb, 1, s->low_delay);
337  put_bits(&s->pb, 2, s->mpeg2_frame_rate_ext.num-1); // frame_rate_ext_n
338  put_bits(&s->pb, 5, s->mpeg2_frame_rate_ext.den-1); // frame_rate_ext_d
339 
341  if (side_data) {
342  AVPanScan *pan_scan = (AVPanScan *)side_data->data;
343  if (pan_scan->width && pan_scan->height) {
344  width = pan_scan->width >> 4;
345  height = pan_scan->height >> 4;
346  }
347  }
348 
349  use_seq_disp_ext = (width != s->width ||
350  height != s->height ||
355 
356  if (s->seq_disp_ext == 1 || (s->seq_disp_ext == -1 && use_seq_disp_ext)) {
358  put_bits(&s->pb, 4, 2); // sequence display extension
359  put_bits(&s->pb, 3, s->video_format); // video_format
360  put_bits(&s->pb, 1, 1); // colour_description
361  put_bits(&s->pb, 8, s->avctx->color_primaries); // colour_primaries
362  put_bits(&s->pb, 8, s->avctx->color_trc); // transfer_characteristics
363  put_bits(&s->pb, 8, s->avctx->colorspace); // matrix_coefficients
364  put_bits(&s->pb, 14, width); // display_horizontal_size
365  put_bits(&s->pb, 1, 1); // marker_bit
366  put_bits(&s->pb, 14, height); // display_vertical_size
367  put_bits(&s->pb, 3, 0); // remaining 3 bits are zero padding
368  }
369  }
370 
372  put_bits(&s->pb, 1, s->drop_frame_timecode); // drop frame flag
373  /* time code: we must convert from the real frame rate to a
374  * fake MPEG frame rate in case of low frame rate */
375  fps = (framerate.num + framerate.den / 2) / framerate.den;
376  time_code = s->current_picture_ptr->f->coded_picture_number +
378 
380 
382  if (s->drop_frame_timecode)
383  time_code = av_timecode_adjust_ntsc_framenum2(time_code, fps);
384 
385  put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
386  put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
387  put_bits(&s->pb, 1, 1);
388  put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
389  put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
391  put_bits(&s->pb, 1, 0); // broken link
392  }
393 }
394 
395 static inline void encode_mb_skip_run(MpegEncContext *s, int run)
396 {
397  while (run >= 33) {
398  put_bits(&s->pb, 11, 0x008);
399  run -= 33;
400  }
402  ff_mpeg12_mbAddrIncrTable[run][0]);
403 }
404 
406 {
407  put_bits(&s->pb, 5, s->qscale);
408 }
409 
411 {
412  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->height > 2800) {
413  put_header(s, SLICE_MIN_START_CODE + (s->mb_y & 127));
414  /* slice_vertical_position_extension */
415  put_bits(&s->pb, 3, s->mb_y >> 7);
416  } else {
418  }
419  put_qscale(s);
420  /* slice extra information */
421  put_bits(&s->pb, 1, 0);
422 }
423 
425 {
426  AVFrameSideData *side_data;
428 
429  /* MPEG-1 picture header */
431  /* temporal reference */
432 
433  // RAL: s->picture_number instead of s->fake_picture_number
434  put_bits(&s->pb, 10,
435  (s->picture_number - s->gop_picture_number) & 0x3ff);
436  put_bits(&s->pb, 3, s->pict_type);
437 
438  s->vbv_delay_ptr = s->pb.buf + put_bits_count(&s->pb) / 8;
439  put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
440 
441  // RAL: Forward f_code also needed for B-frames
442  if (s->pict_type == AV_PICTURE_TYPE_P ||
444  put_bits(&s->pb, 1, 0); /* half pel coordinates */
446  put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
447  else
448  put_bits(&s->pb, 3, 7); /* forward_f_code */
449  }
450 
451  // RAL: Backward f_code necessary for B-frames
452  if (s->pict_type == AV_PICTURE_TYPE_B) {
453  put_bits(&s->pb, 1, 0); /* half pel coordinates */
455  put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
456  else
457  put_bits(&s->pb, 3, 7); /* backward_f_code */
458  }
459 
460  put_bits(&s->pb, 1, 0); /* extra bit picture */
461 
462  s->frame_pred_frame_dct = 1;
463  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
465  put_bits(&s->pb, 4, 8); /* pic ext */
466  if (s->pict_type == AV_PICTURE_TYPE_P ||
468  put_bits(&s->pb, 4, s->f_code);
469  put_bits(&s->pb, 4, s->f_code);
470  } else {
471  put_bits(&s->pb, 8, 255);
472  }
473  if (s->pict_type == AV_PICTURE_TYPE_B) {
474  put_bits(&s->pb, 4, s->b_code);
475  put_bits(&s->pb, 4, s->b_code);
476  } else {
477  put_bits(&s->pb, 8, 255);
478  }
479  put_bits(&s->pb, 2, s->intra_dc_precision);
480 
482  put_bits(&s->pb, 2, s->picture_structure);
483  if (s->progressive_sequence)
484  put_bits(&s->pb, 1, 0); /* no repeat */
485  else
487  /* XXX: optimize the generation of this flag with entropy measures */
489 
490  put_bits(&s->pb, 1, s->frame_pred_frame_dct);
492  put_bits(&s->pb, 1, s->q_scale_type);
493  put_bits(&s->pb, 1, s->intra_vlc_format);
494  put_bits(&s->pb, 1, s->alternate_scan);
495  put_bits(&s->pb, 1, s->repeat_first_field);
497  /* chroma_420_type */
498  put_bits(&s->pb, 1, s->chroma_format ==
499  CHROMA_420 ? s->progressive_frame : 0);
500  put_bits(&s->pb, 1, s->progressive_frame);
501  put_bits(&s->pb, 1, 0); /* composite_display_flag */
502  }
503  if (s->scan_offset) {
504  int i;
505 
507  for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
509  }
512  if (side_data) {
513  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
514  uint8_t fpa_type;
515 
516  switch (stereo->type) {
518  fpa_type = 0x03;
519  break;
521  fpa_type = 0x04;
522  break;
523  case AV_STEREO3D_2D:
524  fpa_type = 0x08;
525  break;
527  fpa_type = 0x23;
528  break;
529  default:
530  fpa_type = 0;
531  break;
532  }
533 
534  if (fpa_type != 0) {
536  put_bits(&s->pb, 8, 'J'); // S3D_video_format_signaling_identifier
537  put_bits(&s->pb, 8, 'P');
538  put_bits(&s->pb, 8, '3');
539  put_bits(&s->pb, 8, 'D');
540  put_bits(&s->pb, 8, 0x03); // S3D_video_format_length
541 
542  put_bits(&s->pb, 1, 1); // reserved_bit
543  put_bits(&s->pb, 7, fpa_type); // S3D_video_format_type
544  put_bits(&s->pb, 8, 0x04); // reserved_data[0]
545  put_bits(&s->pb, 8, 0xFF); // reserved_data[1]
546  }
547  }
548 
549  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->a53_cc) {
552  if (side_data) {
553  if (side_data->size <= A53_MAX_CC_COUNT * 3 && side_data->size % 3 == 0) {
554  int i = 0;
555 
557 
558  put_bits(&s->pb, 8, 'G'); // user_identifier
559  put_bits(&s->pb, 8, 'A');
560  put_bits(&s->pb, 8, '9');
561  put_bits(&s->pb, 8, '4');
562  put_bits(&s->pb, 8, 3); // user_data_type_code
563  put_bits(&s->pb, 8,
564  (side_data->size / 3 & A53_MAX_CC_COUNT) | 0x40); // flags, cc_count
565  put_bits(&s->pb, 8, 0xff); // em_data
566 
567  for (i = 0; i < side_data->size; i++)
568  put_bits(&s->pb, 8, side_data->data[i]);
569 
570  put_bits(&s->pb, 8, 0xff); // marker_bits
571  } else {
573  "Warning Closed Caption size (%d) can not exceed 93 bytes "
574  "and must be a multiple of 3\n", side_data->size);
575  }
576  }
577  }
578 
579  s->mb_y = 0;
581 }
582 
583 static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
584  int has_mv, int field_motion)
585 {
586  put_bits(&s->pb, n, bits);
587  if (!s->frame_pred_frame_dct) {
588  if (has_mv)
589  /* motion_type: frame/field */
590  put_bits(&s->pb, 2, 2 - field_motion);
591  put_bits(&s->pb, 1, s->interlaced_dct);
592  }
593 }
594 
595 // RAL: Parameter added: f_or_b_code
596 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
597 {
598  if (val == 0) {
599  /* zero vector */
600  put_bits(&s->pb,
603  } else {
604  int code, sign, bits;
605  int bit_size = f_or_b_code - 1;
606  int range = 1 << bit_size;
607  /* modulo encoding */
608  val = sign_extend(val, 5 + bit_size);
609 
610  if (val >= 0) {
611  val--;
612  code = (val >> bit_size) + 1;
613  bits = val & (range - 1);
614  sign = 0;
615  } else {
616  val = -val;
617  val--;
618  code = (val >> bit_size) + 1;
619  bits = val & (range - 1);
620  sign = 1;
621  }
622 
623  av_assert2(code > 0 && code <= 16);
624 
625  put_bits(&s->pb,
628 
629  put_bits(&s->pb, 1, sign);
630  if (bit_size > 0)
631  put_bits(&s->pb, bit_size, bits);
632  }
633 }
634 
635 static inline void encode_dc(MpegEncContext *s, int diff, int component)
636 {
637  unsigned int diff_u = diff + 255;
638  if (diff_u >= 511) {
639  int index;
640 
641  if (diff < 0) {
642  index = av_log2_16bit(-2 * diff);
643  diff--;
644  } else {
645  index = av_log2_16bit(2 * diff);
646  }
647  if (component == 0)
648  put_bits(&s->pb,
649  ff_mpeg12_vlc_dc_lum_bits[index] + index,
650  (ff_mpeg12_vlc_dc_lum_code[index] << index) +
651  av_mod_uintp2(diff, index));
652  else
653  put_bits(&s->pb,
654  ff_mpeg12_vlc_dc_chroma_bits[index] + index,
655  (ff_mpeg12_vlc_dc_chroma_code[index] << index) +
656  av_mod_uintp2(diff, index));
657  } else {
658  if (component == 0)
659  put_bits(&s->pb,
660  mpeg1_lum_dc_uni[diff + 255] & 0xFF,
661  mpeg1_lum_dc_uni[diff + 255] >> 8);
662  else
663  put_bits(&s->pb,
664  mpeg1_chr_dc_uni[diff + 255] & 0xFF,
665  mpeg1_chr_dc_uni[diff + 255] >> 8);
666  }
667 }
668 
669 static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n)
670 {
671  int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
672  int code, component;
673  const uint16_t (*table_vlc)[2] = ff_rl_mpeg1.table_vlc;
674 
675  last_index = s->block_last_index[n];
676 
677  /* DC coef */
678  if (s->mb_intra) {
679  component = (n <= 3 ? 0 : (n & 1) + 1);
680  dc = block[0]; /* overflow is impossible */
681  diff = dc - s->last_dc[component];
682  encode_dc(s, diff, component);
683  s->last_dc[component] = dc;
684  i = 1;
685  if (s->intra_vlc_format)
686  table_vlc = ff_rl_mpeg2.table_vlc;
687  } else {
688  /* encode the first coefficient: needs to be done here because
689  * it is handled slightly differently */
690  level = block[0];
691  if (abs(level) == 1) {
692  code = ((uint32_t)level >> 31); /* the sign bit */
693  put_bits(&s->pb, 2, code | 0x02);
694  i = 1;
695  } else {
696  i = 0;
697  last_non_zero = -1;
698  goto next_coef;
699  }
700  }
701 
702  /* now quantify & encode AC coefs */
703  last_non_zero = i - 1;
704 
705  for (; i <= last_index; i++) {
706  j = s->intra_scantable.permutated[i];
707  level = block[j];
708 
709 next_coef:
710  /* encode using VLC */
711  if (level != 0) {
712  run = i - last_non_zero - 1;
713 
714  alevel = level;
715  MASK_ABS(sign, alevel);
716  sign &= 1;
717 
718  if (alevel <= mpeg1_max_level[0][run]) {
719  code = mpeg1_index_run[0][run] + alevel - 1;
720  /* store the VLC & sign at once */
721  put_bits(&s->pb, table_vlc[code][1] + 1,
722  (table_vlc[code][0] << 1) + sign);
723  } else {
724  /* escape seems to be pretty rare <5% so I do not optimize it */
725  put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]);
726  /* escape: only clip in this case */
727  put_bits(&s->pb, 6, run);
728  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
729  if (alevel < 128) {
730  put_sbits(&s->pb, 8, level);
731  } else {
732  if (level < 0)
733  put_bits(&s->pb, 16, 0x8001 + level + 255);
734  else
735  put_sbits(&s->pb, 16, level);
736  }
737  } else {
738  put_sbits(&s->pb, 12, level);
739  }
740  }
741  last_non_zero = i;
742  }
743  }
744  /* end of block */
745  put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
746 }
747 
749  int16_t block[8][64],
750  int motion_x, int motion_y,
751  int mb_block_count)
752 {
753  int i, cbp;
754  const int mb_x = s->mb_x;
755  const int mb_y = s->mb_y;
756  const int first_mb = mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
757 
758  /* compute cbp */
759  cbp = 0;
760  for (i = 0; i < mb_block_count; i++)
761  if (s->block_last_index[i] >= 0)
762  cbp |= 1 << (mb_block_count - 1 - i);
763 
764  if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 &&
765  (mb_x != s->mb_width - 1 ||
766  (mb_y != s->end_mb_y - 1 && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)) &&
767  ((s->pict_type == AV_PICTURE_TYPE_P && (motion_x | motion_y) == 0) ||
768  (s->pict_type == AV_PICTURE_TYPE_B && s->mv_dir == s->last_mv_dir &&
769  (((s->mv_dir & MV_DIR_FORWARD)
770  ? ((s->mv[0][0][0] - s->last_mv[0][0][0]) |
771  (s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
772  ((s->mv_dir & MV_DIR_BACKWARD)
773  ? ((s->mv[1][0][0] - s->last_mv[1][0][0]) |
774  (s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
775  s->mb_skip_run++;
776  s->qscale -= s->dquant;
777  s->skip_count++;
778  s->misc_bits++;
779  s->last_bits++;
780  if (s->pict_type == AV_PICTURE_TYPE_P) {
781  s->last_mv[0][0][0] =
782  s->last_mv[0][0][1] =
783  s->last_mv[0][1][0] =
784  s->last_mv[0][1][1] = 0;
785  }
786  } else {
787  if (first_mb) {
788  av_assert0(s->mb_skip_run == 0);
789  encode_mb_skip_run(s, s->mb_x);
790  } else {
792  }
793 
794  if (s->pict_type == AV_PICTURE_TYPE_I) {
795  if (s->dquant && cbp) {
796  /* macroblock_type: macroblock_quant = 1 */
797  put_mb_modes(s, 2, 1, 0, 0);
798  put_qscale(s);
799  } else {
800  /* macroblock_type: macroblock_quant = 0 */
801  put_mb_modes(s, 1, 1, 0, 0);
802  s->qscale -= s->dquant;
803  }
804  s->misc_bits += get_bits_diff(s);
805  s->i_count++;
806  } else if (s->mb_intra) {
807  if (s->dquant && cbp) {
808  put_mb_modes(s, 6, 0x01, 0, 0);
809  put_qscale(s);
810  } else {
811  put_mb_modes(s, 5, 0x03, 0, 0);
812  s->qscale -= s->dquant;
813  }
814  s->misc_bits += get_bits_diff(s);
815  s->i_count++;
816  memset(s->last_mv, 0, sizeof(s->last_mv));
817  } else if (s->pict_type == AV_PICTURE_TYPE_P) {
818  if (s->mv_type == MV_TYPE_16X16) {
819  if (cbp != 0) {
820  if ((motion_x | motion_y) == 0) {
821  if (s->dquant) {
822  /* macroblock_pattern & quant */
823  put_mb_modes(s, 5, 1, 0, 0);
824  put_qscale(s);
825  } else {
826  /* macroblock_pattern only */
827  put_mb_modes(s, 2, 1, 0, 0);
828  }
829  s->misc_bits += get_bits_diff(s);
830  } else {
831  if (s->dquant) {
832  put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */
833  put_qscale(s);
834  } else {
835  put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */
836  }
837  s->misc_bits += get_bits_diff(s);
838  // RAL: f_code parameter added
840  motion_x - s->last_mv[0][0][0],
841  s->f_code);
842  // RAL: f_code parameter added
844  motion_y - s->last_mv[0][0][1],
845  s->f_code);
846  s->mv_bits += get_bits_diff(s);
847  }
848  } else {
849  put_bits(&s->pb, 3, 1); /* motion only */
850  if (!s->frame_pred_frame_dct)
851  put_bits(&s->pb, 2, 2); /* motion_type: frame */
852  s->misc_bits += get_bits_diff(s);
853  // RAL: f_code parameter added
855  motion_x - s->last_mv[0][0][0],
856  s->f_code);
857  // RAL: f_code parameter added
859  motion_y - s->last_mv[0][0][1],
860  s->f_code);
861  s->qscale -= s->dquant;
862  s->mv_bits += get_bits_diff(s);
863  }
864  s->last_mv[0][1][0] = s->last_mv[0][0][0] = motion_x;
865  s->last_mv[0][1][1] = s->last_mv[0][0][1] = motion_y;
866  } else {
868 
869  if (cbp) {
870  if (s->dquant) {
871  put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
872  put_qscale(s);
873  } else {
874  put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
875  }
876  } else {
877  put_bits(&s->pb, 3, 1); /* motion only */
878  put_bits(&s->pb, 2, 1); /* motion_type: field */
879  s->qscale -= s->dquant;
880  }
881  s->misc_bits += get_bits_diff(s);
882  for (i = 0; i < 2; i++) {
883  put_bits(&s->pb, 1, s->field_select[0][i]);
885  s->mv[0][i][0] - s->last_mv[0][i][0],
886  s->f_code);
888  s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
889  s->f_code);
890  s->last_mv[0][i][0] = s->mv[0][i][0];
891  s->last_mv[0][i][1] = 2 * s->mv[0][i][1];
892  }
893  s->mv_bits += get_bits_diff(s);
894  }
895  if (cbp) {
896  if (s->chroma_y_shift) {
897  put_bits(&s->pb,
898  ff_mpeg12_mbPatTable[cbp][1],
899  ff_mpeg12_mbPatTable[cbp][0]);
900  } else {
901  put_bits(&s->pb,
902  ff_mpeg12_mbPatTable[cbp >> 2][1],
903  ff_mpeg12_mbPatTable[cbp >> 2][0]);
904  put_sbits(&s->pb, 2, cbp);
905  }
906  }
907  s->f_count++;
908  } else {
909  if (s->mv_type == MV_TYPE_16X16) {
910  if (cbp) { // With coded bloc pattern
911  if (s->dquant) {
912  if (s->mv_dir == MV_DIR_FORWARD)
913  put_mb_modes(s, 6, 3, 1, 0);
914  else
915  put_mb_modes(s, 8 - s->mv_dir, 2, 1, 0);
916  put_qscale(s);
917  } else {
918  put_mb_modes(s, 5 - s->mv_dir, 3, 1, 0);
919  }
920  } else { // No coded bloc pattern
921  put_bits(&s->pb, 5 - s->mv_dir, 2);
922  if (!s->frame_pred_frame_dct)
923  put_bits(&s->pb, 2, 2); /* motion_type: frame */
924  s->qscale -= s->dquant;
925  }
926  s->misc_bits += get_bits_diff(s);
927  if (s->mv_dir & MV_DIR_FORWARD) {
929  s->mv[0][0][0] - s->last_mv[0][0][0],
930  s->f_code);
932  s->mv[0][0][1] - s->last_mv[0][0][1],
933  s->f_code);
934  s->last_mv[0][0][0] =
935  s->last_mv[0][1][0] = s->mv[0][0][0];
936  s->last_mv[0][0][1] =
937  s->last_mv[0][1][1] = s->mv[0][0][1];
938  s->f_count++;
939  }
940  if (s->mv_dir & MV_DIR_BACKWARD) {
942  s->mv[1][0][0] - s->last_mv[1][0][0],
943  s->b_code);
945  s->mv[1][0][1] - s->last_mv[1][0][1],
946  s->b_code);
947  s->last_mv[1][0][0] =
948  s->last_mv[1][1][0] = s->mv[1][0][0];
949  s->last_mv[1][0][1] =
950  s->last_mv[1][1][1] = s->mv[1][0][1];
951  s->b_count++;
952  }
953  } else {
956  if (cbp) { // With coded bloc pattern
957  if (s->dquant) {
958  if (s->mv_dir == MV_DIR_FORWARD)
959  put_mb_modes(s, 6, 3, 1, 1);
960  else
961  put_mb_modes(s, 8 - s->mv_dir, 2, 1, 1);
962  put_qscale(s);
963  } else {
964  put_mb_modes(s, 5 - s->mv_dir, 3, 1, 1);
965  }
966  } else { // No coded bloc pattern
967  put_bits(&s->pb, 5 - s->mv_dir, 2);
968  put_bits(&s->pb, 2, 1); /* motion_type: field */
969  s->qscale -= s->dquant;
970  }
971  s->misc_bits += get_bits_diff(s);
972  if (s->mv_dir & MV_DIR_FORWARD) {
973  for (i = 0; i < 2; i++) {
974  put_bits(&s->pb, 1, s->field_select[0][i]);
976  s->mv[0][i][0] - s->last_mv[0][i][0],
977  s->f_code);
979  s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
980  s->f_code);
981  s->last_mv[0][i][0] = s->mv[0][i][0];
982  s->last_mv[0][i][1] = s->mv[0][i][1] * 2;
983  }
984  s->f_count++;
985  }
986  if (s->mv_dir & MV_DIR_BACKWARD) {
987  for (i = 0; i < 2; i++) {
988  put_bits(&s->pb, 1, s->field_select[1][i]);
990  s->mv[1][i][0] - s->last_mv[1][i][0],
991  s->b_code);
993  s->mv[1][i][1] - (s->last_mv[1][i][1] >> 1),
994  s->b_code);
995  s->last_mv[1][i][0] = s->mv[1][i][0];
996  s->last_mv[1][i][1] = s->mv[1][i][1] * 2;
997  }
998  s->b_count++;
999  }
1000  }
1001  s->mv_bits += get_bits_diff(s);
1002  if (cbp) {
1003  if (s->chroma_y_shift) {
1004  put_bits(&s->pb,
1005  ff_mpeg12_mbPatTable[cbp][1],
1006  ff_mpeg12_mbPatTable[cbp][0]);
1007  } else {
1008  put_bits(&s->pb,
1009  ff_mpeg12_mbPatTable[cbp >> 2][1],
1010  ff_mpeg12_mbPatTable[cbp >> 2][0]);
1011  put_sbits(&s->pb, 2, cbp);
1012  }
1013  }
1014  }
1015  for (i = 0; i < mb_block_count; i++)
1016  if (cbp & (1 << (mb_block_count - 1 - i)))
1017  mpeg1_encode_block(s, block[i], i);
1018  s->mb_skip_run = 0;
1019  if (s->mb_intra)
1020  s->i_tex_bits += get_bits_diff(s);
1021  else
1022  s->p_tex_bits += get_bits_diff(s);
1023  }
1024 }
1025 
1027  int motion_x, int motion_y)
1028 {
1029  if (s->chroma_format == CHROMA_420)
1030  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6);
1031  else
1032  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8);
1033 }
1034 
1036 {
1037  static int done = 0;
1038 
1040 
1041  if (!done) {
1042  int f_code;
1043  int mv;
1044  int i;
1045 
1046  done = 1;
1049 
1050  for (i = 0; i < 64; i++) {
1053  }
1054 
1056  if (s->intra_vlc_format)
1058 
1059  /* build unified dc encoding tables */
1060  for (i = -255; i < 256; i++) {
1061  int adiff, index;
1062  int bits, code;
1063  int diff = i;
1064 
1065  adiff = FFABS(diff);
1066  if (diff < 0)
1067  diff--;
1068  index = av_log2(2 * adiff);
1069 
1071  code = (ff_mpeg12_vlc_dc_lum_code[index] << index) +
1072  av_mod_uintp2(diff, index);
1073  mpeg1_lum_dc_uni[i + 255] = bits + (code << 8);
1074 
1077  av_mod_uintp2(diff, index);
1078  mpeg1_chr_dc_uni[i + 255] = bits + (code << 8);
1079  }
1080 
1081  for (f_code = 1; f_code <= MAX_FCODE; f_code++)
1082  for (mv = -MAX_DMV; mv <= MAX_DMV; mv++) {
1083  int len;
1084 
1085  if (mv == 0) {
1086  len = ff_mpeg12_mbMotionVectorTable[0][1];
1087  } else {
1088  int val, bit_size, code;
1089 
1090  bit_size = f_code - 1;
1091 
1092  val = mv;
1093  if (val < 0)
1094  val = -val;
1095  val--;
1096  code = (val >> bit_size) + 1;
1097  if (code < 17)
1099  1 + bit_size;
1100  else
1101  len = ff_mpeg12_mbMotionVectorTable[16][1] +
1102  2 + bit_size;
1103  }
1104 
1105  mv_penalty[f_code][mv + MAX_DMV] = len;
1106  }
1107 
1108 
1109  for (f_code = MAX_FCODE; f_code > 0; f_code--)
1110  for (mv = -(8 << f_code); mv < (8 << f_code); mv++)
1111  fcode_tab[mv + MAX_MV] = f_code;
1112  }
1113  s->me.mv_penalty = mv_penalty;
1114  s->fcode_tab = fcode_tab;
1115  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1116  s->min_qcoeff = -255;
1117  s->max_qcoeff = 255;
1118  } else {
1119  s->min_qcoeff = -2047;
1120  s->max_qcoeff = 2047;
1121  }
1122  if (s->intra_vlc_format) {
1123  s->intra_ac_vlc_length =
1125  } else {
1126  s->intra_ac_vlc_length =
1128  }
1129  s->inter_ac_vlc_length =
1131 }
1132 
1133 #define OFFSET(x) offsetof(MpegEncContext, x)
1134 #define VE AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
1135 #define COMMON_OPTS \
1136  { "gop_timecode", "MPEG GOP Timecode in hh:mm:ss[:;.]ff format. Overrides timecode_frame_start.", \
1137  OFFSET(tc_opt_str), AV_OPT_TYPE_STRING, {.str=NULL}, CHAR_MIN, CHAR_MAX, VE },\
1138  { "intra_vlc", "Use MPEG-2 intra VLC table.", \
1139  OFFSET(intra_vlc_format), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1140  { "drop_frame_timecode", "Timecode is in drop frame format.", \
1141  OFFSET(drop_frame_timecode), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1142  { "scan_offset", "Reserve space for SVCD scan offset user data.", \
1143  OFFSET(scan_offset), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1144  { "timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", \
1145  OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = -1 }, -1, INT64_MAX, VE}, \
1146 
1147 static const AVOption mpeg1_options[] = {
1148  COMMON_OPTS
1150  { NULL },
1151 };
1152 
1153 static const AVOption mpeg2_options[] = {
1154  COMMON_OPTS
1155  { "non_linear_quant", "Use nonlinear quantizer.", OFFSET(q_scale_type), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1156  { "alternate_scan", "Enable alternate scantable.", OFFSET(alternate_scan), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1157  { "seq_disp_ext", "Write sequence_display_extension blocks.", OFFSET(seq_disp_ext), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "seq_disp_ext" },
1158  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, VE, "seq_disp_ext" },
1159  { "never", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, VE, "seq_disp_ext" },
1160  { "always", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, VE, "seq_disp_ext" },
1161  { "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" },
1162  { "component", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_COMPONENT }, 0, 0, VE, "video_format" },
1163  { "pal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_PAL }, 0, 0, VE, "video_format" },
1164  { "ntsc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_NTSC }, 0, 0, VE, "video_format" },
1165  { "secam", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_SECAM }, 0, 0, VE, "video_format" },
1166  { "mac", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_MAC }, 0, 0, VE, "video_format" },
1167  { "unspecified", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_UNSPECIFIED}, 0, 0, VE, "video_format" },
1169  { NULL },
1170 };
1171 
1172 #define mpeg12_class(x) \
1173 static const AVClass mpeg ## x ## _class = { \
1174  .class_name = "mpeg" # x "video encoder", \
1175  .item_name = av_default_item_name, \
1176  .option = mpeg ## x ## _options, \
1177  .version = LIBAVUTIL_VERSION_INT, \
1178 };
1179 
1181 mpeg12_class(2)
1182 
1184  .name = "mpeg1video",
1185  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
1186  .type = AVMEDIA_TYPE_VIDEO,
1187  .id = AV_CODEC_ID_MPEG1VIDEO,
1188  .priv_data_size = sizeof(MpegEncContext),
1189  .init = encode_init,
1190  .encode2 = ff_mpv_encode_picture,
1191  .close = ff_mpv_encode_end,
1192  .supported_framerates = ff_mpeg12_frame_rate_tab + 1,
1193  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
1194  AV_PIX_FMT_NONE },
1196  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1197  .priv_class = &mpeg1_class,
1198 };
1199 
1201  .name = "mpeg2video",
1202  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
1203  .type = AVMEDIA_TYPE_VIDEO,
1204  .id = AV_CODEC_ID_MPEG2VIDEO,
1205  .priv_data_size = sizeof(MpegEncContext),
1206  .init = encode_init,
1207  .encode2 = ff_mpv_encode_picture,
1208  .close = ff_mpv_encode_end,
1209  .supported_framerates = ff_mpeg2_frame_rate_tab,
1210  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
1212  AV_PIX_FMT_NONE },
1214  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1215  .priv_class = &mpeg2_class,
1216 };
#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:2636
av_cold void ff_mpeg1_encode_init(MpegEncContext *s)
Definition: mpeg12enc.c:1035
static uint8_t uni_mpeg1_ac_vlc_len[64 *64 *2]
Definition: mpeg12enc.c:53
#define MASK_ABS(mask, level)
Definition: mathops.h:155
#define NULL
Definition: coverity.c:32
AVCodec ff_mpeg2video_encoder
Definition: mpeg12enc.c:1200
const char const char void * val
Definition: avisynth_c.h:863
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
AVOption.
Definition: opt.h:246
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:101
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:182
#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:1116
#define FF_MPV_COMMON_OPTS
Definition: mpegvideo.h:614
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:1947
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:206
uint8_t * intra_ac_vlc_length
Definition: mpegvideo.h:311
#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:2901
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
AVCodec.
Definition: avcodec.h:3492
#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:1691
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:734
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:3022
#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:1009
#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:194
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:82
#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:58
AVOptions.
static void encode_mb_skip_run(MpegEncContext *s, int run)
Definition: mpeg12enc.c:395
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:2039
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:1147
static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12enc.c:669
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:201
#define height
static int8_t mpeg1_max_level[2][64]
Definition: mpeg12enc.c:62
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:2635
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:752
int intra_only
if true, only intra pictures are generated
Definition: mpegvideo.h:102
#define MAX_DMV
Definition: motion_est.h:37
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:583
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:186
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:635
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1648
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: avcodec.h:3499
uint8_t bits
Definition: vp3data.h:202
int width
width and height in 1/16 pel
Definition: avcodec.h:1115
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:406
attribute_deprecated int64_t timecode_frame_start
Definition: avcodec.h:2530
static void mpeg1_encode_sequence_header(MpegEncContext *s)
Definition: mpeg12enc.c:240
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
Definition: mpeg12enc.c:596
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
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:2431
uint8_t * intra_ac_vlc_last_length
Definition: mpegvideo.h:312
#define mpeg12_class(x)
Definition: mpeg12enc.c:1172
int intra_vlc_format
Definition: mpegvideo.h:470
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:51
#define width
int width
picture width / height.
Definition: avcodec.h:1741
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:2902
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:2182
static uint8_t uni_mpeg2_ac_vlc_len[64 *64 *2]
Definition: mpeg12enc.c:54
#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:3021
#define VE
Definition: mpeg12enc.c:1134
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:86
MotionEstContext me
Definition: mpegvideo.h:282
int n
Definition: avisynth_c.h:760
#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:66
static void put_header(MpegEncContext *s, int header)
Definition: mpeg12enc.c:232
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
static void error(const char *err)
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
if(ret)
static const uint8_t svcd_scan_offset_placeholder[]
Definition: mpeg12enc.c:45
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1044
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:939
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:409
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
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:64
#define abs(x)
Definition: cuda_runtime.h:35
main external API structure.
Definition: avcodec.h:1568
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:748
uint8_t * data
Definition: frame.h:203
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:61
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:2068
static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
Definition: mpeg12enc.c:50
int index
Definition: gxfenc.c:89
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2196
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2189
struct AVFrame * f
Definition: mpegpicture.h:46
#define COMMON_OPTS
Definition: mpeg12enc.c:1135
uint8_t * index_run[2]
encoding only
Definition: rl.h:45
#define OFFSET(x)
Definition: mpeg12enc.c:1133
void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: mpeg12enc.c:424
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:2077
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:1026
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:1102
uint8_t level
Definition: svq3.c:207
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:140
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:405
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:59
static const AVOption mpeg2_options[]
Definition: mpeg12enc.c:1153
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:1595
void ff_mpeg1_encode_slice_header(MpegEncContext *s)
Definition: mpeg12enc.c:410
#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:447
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:373
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1655
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:39
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:921
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
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2631
Predicted.
Definition: avutil.h:275
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2446
const AVRational ff_mpeg12_frame_rate_tab[]