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