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 #define A53_MAX_CC_COUNT 0x1f
66 #endif /* CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER */
67 
68 av_cold void ff_mpeg1_init_uni_ac_vlc(const RLTable *rl, uint8_t *uni_ac_vlc_len)
69 {
70  int i;
71 
72  for (i = 0; i < 128; i++) {
73  int level = i - 64;
74  int run;
75  if (!level)
76  continue;
77  for (run = 0; run < 64; run++) {
78  int len, code;
79  int alevel = FFABS(level);
80 
81  if (alevel > rl->max_level[0][run])
82  code = 111; /* rl->n */
83  else
84  code = rl->index_run[0][run] + alevel - 1;
85 
86  if (code < 111) { /* rl->n */
87  /* length of VLC and sign */
88  len = rl->table_vlc[code][1] + 1;
89  } else {
90  len = rl->table_vlc[111 /* rl->n */][1] + 6;
91 
92  if (alevel < 128)
93  len += 8;
94  else
95  len += 16;
96  }
97 
98  uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
99  }
100  }
101 }
102 
103 #if CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER
104 static int find_frame_rate_index(MpegEncContext *s)
105 {
106  int i;
107  AVRational bestq = (AVRational) {0, 0};
108  AVRational ext;
109  AVRational target = av_inv_q(s->avctx->time_base);
110 
111  for (i = 1; i < 14; i++) {
113  i >= 9)
114  break;
115 
116  for (ext.num=1; ext.num <= 4; ext.num++) {
117  for (ext.den=1; ext.den <= 32; ext.den++) {
119 
120  if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO && (ext.den!=1 || ext.num!=1))
121  continue;
122  if (av_gcd(ext.den, ext.num) != 1)
123  continue;
124 
125  if ( bestq.num==0
126  || av_nearer_q(target, bestq, q) < 0
127  || ext.num==1 && ext.den==1 && av_nearer_q(target, bestq, q) == 0) {
128  bestq = q;
129  s->frame_rate_index = i;
130  s->mpeg2_frame_rate_ext.num = ext.num;
131  s->mpeg2_frame_rate_ext.den = ext.den;
132  }
133  }
134  }
135  }
136 
137  if (av_cmp_q(target, bestq))
138  return -1;
139  else
140  return 0;
141 }
142 
143 static av_cold int encode_init(AVCodecContext *avctx)
144 {
145  int ret;
146  MpegEncContext *s = avctx->priv_data;
147  int max_size = avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 16383 : 4095;
148 
149  if (avctx->width > max_size || avctx->height > max_size) {
150  av_log(avctx, AV_LOG_ERROR, "%s does not support resolutions above %dx%d\n",
151  CONFIG_SMALL ? avctx->codec->name : avctx->codec->long_name,
152  max_size, max_size);
153  return AVERROR(EINVAL);
154  }
155  if ((avctx->width & 0xFFF) == 0 && (avctx->height & 0xFFF) == 1) {
156  av_log(avctx, AV_LOG_ERROR, "Width / Height is invalid for MPEG2\n");
157  return AVERROR(EINVAL);
158  }
159 
161  if ((avctx->width & 0xFFF) == 0 || (avctx->height & 0xFFF) == 0) {
162  av_log(avctx, AV_LOG_ERROR, "Width or Height are not allowed to be multiples of 4096\n"
163  "add '-strict %d' if you want to use them anyway.\n", FF_COMPLIANCE_UNOFFICIAL);
164  return AVERROR(EINVAL);
165  }
166  }
167 
168  if (avctx->profile == FF_PROFILE_UNKNOWN) {
169  if (avctx->level != FF_LEVEL_UNKNOWN) {
170  av_log(avctx, AV_LOG_ERROR, "Set profile and level\n");
171  return AVERROR(EINVAL);
172  }
173  /* Main or 4:2:2 */
176  }
177  if (avctx->level == FF_LEVEL_UNKNOWN) {
178  if (avctx->profile == FF_PROFILE_MPEG2_422) { /* 4:2:2 */
179  if (avctx->width <= 720 && avctx->height <= 608)
180  avctx->level = 5; /* Main */
181  else
182  avctx->level = 2; /* High */
183  } else {
184  if (avctx->profile != FF_PROFILE_MPEG2_HIGH &&
185  avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
186  av_log(avctx, AV_LOG_ERROR,
187  "Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n");
188  return AVERROR(EINVAL);
189  }
190  if (avctx->width <= 720 && avctx->height <= 576)
191  avctx->level = 8; /* Main */
192  else if (avctx->width <= 1440)
193  avctx->level = 6; /* High 1440 */
194  else
195  avctx->level = 4; /* High */
196  }
197  }
198 
199  if ((ret = ff_mpv_encode_init(avctx)) < 0)
200  return ret;
201 
202  if (find_frame_rate_index(s) < 0) {
204  av_log(avctx, AV_LOG_ERROR, "MPEG-1/2 does not support %d/%d fps\n",
205  avctx->time_base.den, avctx->time_base.num);
206  return AVERROR(EINVAL);
207  } else {
208  av_log(avctx, AV_LOG_INFO,
209  "MPEG-1/2 does not support %d/%d fps, there may be AV sync issues\n",
210  avctx->time_base.den, avctx->time_base.num);
211  }
212  }
213 
215  if (s->drop_frame_timecode)
217  if (s->drop_frame_timecode && s->frame_rate_index != 4) {
218  av_log(avctx, AV_LOG_ERROR,
219  "Drop frame time code only allowed with 1001/30000 fps\n");
220  return AVERROR(EINVAL);
221  }
222 
223 #if FF_API_PRIVATE_OPT
225  if (avctx->timecode_frame_start)
228 #endif
229 
230  if (s->tc_opt_str) {
232  int ret = av_timecode_init_from_string(&s->tc, rate, s->tc_opt_str, s);
233  if (ret < 0)
234  return ret;
236  s->timecode_frame_start = s->tc.start;
237  } else {
238  s->timecode_frame_start = 0; // default is -1
239  }
240 
241  return 0;
242 }
243 
244 static void put_header(MpegEncContext *s, int header)
245 {
246  align_put_bits(&s->pb);
247  put_bits(&s->pb, 16, header >> 16);
248  put_sbits(&s->pb, 16, header);
249 }
250 
251 /* put sequence header if needed */
252 static void mpeg1_encode_sequence_header(MpegEncContext *s)
253 {
254  unsigned int vbv_buffer_size, fps, v;
255  int i, constraint_parameter_flag;
256  uint64_t time_code;
257  int64_t best_aspect_error = INT64_MAX;
258  AVRational aspect_ratio = s->avctx->sample_aspect_ratio;
259 
260  if (aspect_ratio.num == 0 || aspect_ratio.den == 0)
261  aspect_ratio = (AVRational){1,1}; // pixel aspect 1.1 (VGA)
262 
263  if (s->current_picture.f->key_frame) {
265 
266  /* MPEG-1 header repeated every GOP */
268 
269  put_sbits(&s->pb, 12, s->width & 0xFFF);
270  put_sbits(&s->pb, 12, s->height & 0xFFF);
271 
272  for (i = 1; i < 15; i++) {
273  int64_t error = aspect_ratio.num * (1LL<<32) / aspect_ratio.den;
274  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || i <= 1)
275  error -= (1LL<<32) / ff_mpeg1_aspect[i];
276  else
277  error -= (1LL<<32)*ff_mpeg2_aspect[i].num * s->height / s->width / ff_mpeg2_aspect[i].den;
278 
279  error = FFABS(error);
280 
281  if (error - 2 <= best_aspect_error) {
282  best_aspect_error = error;
283  s->aspect_ratio_info = i;
284  }
285  }
286 
287  put_bits(&s->pb, 4, s->aspect_ratio_info);
288  put_bits(&s->pb, 4, s->frame_rate_index);
289 
290  if (s->avctx->rc_max_rate) {
291  v = (s->avctx->rc_max_rate + 399) / 400;
292  if (v > 0x3ffff && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
293  v = 0x3ffff;
294  } else {
295  v = 0x3FFFF;
296  }
297 
298  if (s->avctx->rc_buffer_size)
299  vbv_buffer_size = s->avctx->rc_buffer_size;
300  else
301  /* VBV calculation: Scaled so that a VCD has the proper
302  * VBV size of 40 kilobytes */
303  vbv_buffer_size = ((20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
304  vbv_buffer_size = (vbv_buffer_size + 16383) / 16384;
305 
306  put_sbits(&s->pb, 18, v);
307  put_bits(&s->pb, 1, 1); // marker
308  put_sbits(&s->pb, 10, vbv_buffer_size);
309 
310  constraint_parameter_flag =
311  s->width <= 768 &&
312  s->height <= 576 &&
313  s->mb_width * s->mb_height <= 396 &&
314  s->mb_width * s->mb_height * framerate.num <= 396 * 25 * framerate.den &&
315  framerate.num <= framerate.den * 30 &&
316  s->avctx->me_range &&
317  s->avctx->me_range < 128 &&
318  vbv_buffer_size <= 20 &&
319  v <= 1856000 / 400 &&
321 
322  put_bits(&s->pb, 1, constraint_parameter_flag);
323 
326 
327  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
328  AVFrameSideData *side_data;
329  int width = s->width;
330  int height = s->height;
331  int use_seq_disp_ext;
332 
334  put_bits(&s->pb, 4, 1); // seq ext
335 
336  put_bits(&s->pb, 1, s->avctx->profile == FF_PROFILE_MPEG2_422); // escx 1 for 4:2:2 profile
337 
338  put_bits(&s->pb, 3, s->avctx->profile); // profile
339  put_bits(&s->pb, 4, s->avctx->level); // level
340 
341  put_bits(&s->pb, 1, s->progressive_sequence);
342  put_bits(&s->pb, 2, s->chroma_format);
343  put_bits(&s->pb, 2, s->width >> 12);
344  put_bits(&s->pb, 2, s->height >> 12);
345  put_bits(&s->pb, 12, v >> 18); // bitrate ext
346  put_bits(&s->pb, 1, 1); // marker
347  put_bits(&s->pb, 8, vbv_buffer_size >> 10); // vbv buffer ext
348  put_bits(&s->pb, 1, s->low_delay);
349  put_bits(&s->pb, 2, s->mpeg2_frame_rate_ext.num-1); // frame_rate_ext_n
350  put_bits(&s->pb, 5, s->mpeg2_frame_rate_ext.den-1); // frame_rate_ext_d
351 
353  if (side_data) {
354  AVPanScan *pan_scan = (AVPanScan *)side_data->data;
355  if (pan_scan->width && pan_scan->height) {
356  width = pan_scan->width >> 4;
357  height = pan_scan->height >> 4;
358  }
359  }
360 
361  use_seq_disp_ext = (width != s->width ||
362  height != s->height ||
367 
368  if (s->seq_disp_ext == 1 || (s->seq_disp_ext == -1 && use_seq_disp_ext)) {
370  put_bits(&s->pb, 4, 2); // sequence display extension
371  put_bits(&s->pb, 3, s->video_format); // video_format
372  put_bits(&s->pb, 1, 1); // colour_description
373  put_bits(&s->pb, 8, s->avctx->color_primaries); // colour_primaries
374  put_bits(&s->pb, 8, s->avctx->color_trc); // transfer_characteristics
375  put_bits(&s->pb, 8, s->avctx->colorspace); // matrix_coefficients
376  put_bits(&s->pb, 14, width); // display_horizontal_size
377  put_bits(&s->pb, 1, 1); // marker_bit
378  put_bits(&s->pb, 14, height); // display_vertical_size
379  put_bits(&s->pb, 3, 0); // remaining 3 bits are zero padding
380  }
381  }
382 
384  put_bits(&s->pb, 1, s->drop_frame_timecode); // drop frame flag
385  /* time code: we must convert from the real frame rate to a
386  * fake MPEG frame rate in case of low frame rate */
387  fps = (framerate.num + framerate.den / 2) / framerate.den;
388  time_code = s->current_picture_ptr->f->coded_picture_number +
390 
392 
394  if (s->drop_frame_timecode)
395  time_code = av_timecode_adjust_ntsc_framenum2(time_code, fps);
396 
397  put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
398  put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
399  put_bits(&s->pb, 1, 1);
400  put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
401  put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
403  put_bits(&s->pb, 1, 0); // broken link
404  }
405 }
406 
407 static inline void encode_mb_skip_run(MpegEncContext *s, int run)
408 {
409  while (run >= 33) {
410  put_bits(&s->pb, 11, 0x008);
411  run -= 33;
412  }
414  ff_mpeg12_mbAddrIncrTable[run][0]);
415 }
416 
417 static av_always_inline void put_qscale(MpegEncContext *s)
418 {
419  put_bits(&s->pb, 5, s->qscale);
420 }
421 
423 {
424  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->height > 2800) {
425  put_header(s, SLICE_MIN_START_CODE + (s->mb_y & 127));
426  /* slice_vertical_position_extension */
427  put_bits(&s->pb, 3, s->mb_y >> 7);
428  } else {
430  }
431  put_qscale(s);
432  /* slice extra information */
433  put_bits(&s->pb, 1, 0);
434 }
435 
436 void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
437 {
438  AVFrameSideData *side_data;
439  mpeg1_encode_sequence_header(s);
440 
441  /* MPEG-1 picture header */
443  /* temporal reference */
444 
445  // RAL: s->picture_number instead of s->fake_picture_number
446  put_bits(&s->pb, 10,
447  (s->picture_number - s->gop_picture_number) & 0x3ff);
448  put_bits(&s->pb, 3, s->pict_type);
449 
450  s->vbv_delay_ptr = s->pb.buf + put_bytes_count(&s->pb, 0);
451  put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
452 
453  // RAL: Forward f_code also needed for B-frames
454  if (s->pict_type == AV_PICTURE_TYPE_P ||
456  put_bits(&s->pb, 1, 0); /* half pel coordinates */
458  put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
459  else
460  put_bits(&s->pb, 3, 7); /* forward_f_code */
461  }
462 
463  // RAL: Backward f_code necessary for B-frames
464  if (s->pict_type == AV_PICTURE_TYPE_B) {
465  put_bits(&s->pb, 1, 0); /* half pel coordinates */
467  put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
468  else
469  put_bits(&s->pb, 3, 7); /* backward_f_code */
470  }
471 
472  put_bits(&s->pb, 1, 0); /* extra bit picture */
473 
474  s->frame_pred_frame_dct = 1;
475  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
477  put_bits(&s->pb, 4, 8); /* pic ext */
478  if (s->pict_type == AV_PICTURE_TYPE_P ||
480  put_bits(&s->pb, 4, s->f_code);
481  put_bits(&s->pb, 4, s->f_code);
482  } else {
483  put_bits(&s->pb, 8, 255);
484  }
485  if (s->pict_type == AV_PICTURE_TYPE_B) {
486  put_bits(&s->pb, 4, s->b_code);
487  put_bits(&s->pb, 4, s->b_code);
488  } else {
489  put_bits(&s->pb, 8, 255);
490  }
491  put_bits(&s->pb, 2, s->intra_dc_precision);
492 
494  put_bits(&s->pb, 2, s->picture_structure);
495  if (s->progressive_sequence)
496  put_bits(&s->pb, 1, 0); /* no repeat */
497  else
499  /* XXX: optimize the generation of this flag with entropy measures */
501 
502  put_bits(&s->pb, 1, s->frame_pred_frame_dct);
504  put_bits(&s->pb, 1, s->q_scale_type);
505  put_bits(&s->pb, 1, s->intra_vlc_format);
506  put_bits(&s->pb, 1, s->alternate_scan);
507  put_bits(&s->pb, 1, s->repeat_first_field);
509  /* chroma_420_type */
510  put_bits(&s->pb, 1, s->chroma_format ==
511  CHROMA_420 ? s->progressive_frame : 0);
512  put_bits(&s->pb, 1, s->progressive_frame);
513  put_bits(&s->pb, 1, 0); /* composite_display_flag */
514  }
515  if (s->scan_offset) {
516  int i;
517 
519  for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
520  put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
521  }
524  if (side_data) {
525  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
526  uint8_t fpa_type;
527 
528  switch (stereo->type) {
530  fpa_type = 0x03;
531  break;
533  fpa_type = 0x04;
534  break;
535  case AV_STEREO3D_2D:
536  fpa_type = 0x08;
537  break;
539  fpa_type = 0x23;
540  break;
541  default:
542  fpa_type = 0;
543  break;
544  }
545 
546  if (fpa_type != 0) {
548  put_bits(&s->pb, 8, 'J'); // S3D_video_format_signaling_identifier
549  put_bits(&s->pb, 8, 'P');
550  put_bits(&s->pb, 8, '3');
551  put_bits(&s->pb, 8, 'D');
552  put_bits(&s->pb, 8, 0x03); // S3D_video_format_length
553 
554  put_bits(&s->pb, 1, 1); // reserved_bit
555  put_bits(&s->pb, 7, fpa_type); // S3D_video_format_type
556  put_bits(&s->pb, 8, 0x04); // reserved_data[0]
557  put_bits(&s->pb, 8, 0xFF); // reserved_data[1]
558  }
559  }
560 
561  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->a53_cc) {
564  if (side_data) {
565  if (side_data->size <= A53_MAX_CC_COUNT * 3 && side_data->size % 3 == 0) {
566  int i = 0;
567 
569 
570  put_bits(&s->pb, 8, 'G'); // user_identifier
571  put_bits(&s->pb, 8, 'A');
572  put_bits(&s->pb, 8, '9');
573  put_bits(&s->pb, 8, '4');
574  put_bits(&s->pb, 8, 3); // user_data_type_code
575  put_bits(&s->pb, 8,
576  (side_data->size / 3 & A53_MAX_CC_COUNT) | 0x40); // flags, cc_count
577  put_bits(&s->pb, 8, 0xff); // em_data
578 
579  for (i = 0; i < side_data->size; i++)
580  put_bits(&s->pb, 8, side_data->data[i]);
581 
582  put_bits(&s->pb, 8, 0xff); // marker_bits
583  } else {
585  "Warning Closed Caption size (%d) can not exceed 93 bytes "
586  "and must be a multiple of 3\n", side_data->size);
587  }
588  }
589  }
590 
591  s->mb_y = 0;
593 }
594 
595 static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
596  int has_mv, int field_motion)
597 {
598  put_bits(&s->pb, n, bits);
599  if (!s->frame_pred_frame_dct) {
600  if (has_mv)
601  /* motion_type: frame/field */
602  put_bits(&s->pb, 2, 2 - field_motion);
603  put_bits(&s->pb, 1, s->interlaced_dct);
604  }
605 }
606 
607 // RAL: Parameter added: f_or_b_code
608 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
609 {
610  if (val == 0) {
611  /* zero vector */
612  put_bits(&s->pb,
615  } else {
616  int code, sign, bits;
617  int bit_size = f_or_b_code - 1;
618  int range = 1 << bit_size;
619  /* modulo encoding */
620  val = sign_extend(val, 5 + bit_size);
621 
622  if (val >= 0) {
623  val--;
624  code = (val >> bit_size) + 1;
625  bits = val & (range - 1);
626  sign = 0;
627  } else {
628  val = -val;
629  val--;
630  code = (val >> bit_size) + 1;
631  bits = val & (range - 1);
632  sign = 1;
633  }
634 
635  av_assert2(code > 0 && code <= 16);
636 
637  put_bits(&s->pb,
640 
641  put_bits(&s->pb, 1, sign);
642  if (bit_size > 0)
643  put_bits(&s->pb, bit_size, bits);
644  }
645 }
646 
647 static inline void encode_dc(MpegEncContext *s, int diff, int component)
648 {
649  unsigned int diff_u = diff + 255;
650  if (diff_u >= 511) {
651  int index;
652 
653  if (diff < 0) {
654  index = av_log2_16bit(-2 * diff);
655  diff--;
656  } else {
657  index = av_log2_16bit(2 * diff);
658  }
659  if (component == 0)
660  put_bits(&s->pb,
661  ff_mpeg12_vlc_dc_lum_bits[index] + index,
662  (ff_mpeg12_vlc_dc_lum_code[index] << index) +
663  av_mod_uintp2(diff, index));
664  else
665  put_bits(&s->pb,
666  ff_mpeg12_vlc_dc_chroma_bits[index] + index,
667  (ff_mpeg12_vlc_dc_chroma_code[index] << index) +
668  av_mod_uintp2(diff, index));
669  } else {
670  if (component == 0)
671  put_bits(&s->pb,
672  mpeg1_lum_dc_uni[diff + 255] & 0xFF,
673  mpeg1_lum_dc_uni[diff + 255] >> 8);
674  else
675  put_bits(&s->pb,
676  mpeg1_chr_dc_uni[diff + 255] & 0xFF,
677  mpeg1_chr_dc_uni[diff + 255] >> 8);
678  }
679 }
680 
681 static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n)
682 {
683  int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
684  int code, component;
685  const uint16_t (*table_vlc)[2] = ff_rl_mpeg1.table_vlc;
686 
687  last_index = s->block_last_index[n];
688 
689  /* DC coef */
690  if (s->mb_intra) {
691  component = (n <= 3 ? 0 : (n & 1) + 1);
692  dc = block[0]; /* overflow is impossible */
693  diff = dc - s->last_dc[component];
694  encode_dc(s, diff, component);
695  s->last_dc[component] = dc;
696  i = 1;
697  if (s->intra_vlc_format)
698  table_vlc = ff_rl_mpeg2.table_vlc;
699  } else {
700  /* encode the first coefficient: needs to be done here because
701  * it is handled slightly differently */
702  level = block[0];
703  if (abs(level) == 1) {
704  code = ((uint32_t)level >> 31); /* the sign bit */
705  put_bits(&s->pb, 2, code | 0x02);
706  i = 1;
707  } else {
708  i = 0;
709  last_non_zero = -1;
710  goto next_coef;
711  }
712  }
713 
714  /* now quantify & encode AC coefs */
715  last_non_zero = i - 1;
716 
717  for (; i <= last_index; i++) {
718  j = s->intra_scantable.permutated[i];
719  level = block[j];
720 
721 next_coef:
722  /* encode using VLC */
723  if (level != 0) {
724  run = i - last_non_zero - 1;
725 
726  alevel = level;
727  MASK_ABS(sign, alevel);
728  sign &= 1;
729 
730  if (alevel <= ff_rl_mpeg1.max_level[0][run]) {
731  code = ff_rl_mpeg1.index_run[0][run] + alevel - 1;
732  /* store the VLC & sign at once */
733  put_bits(&s->pb, table_vlc[code][1] + 1,
734  (table_vlc[code][0] << 1) + sign);
735  } else {
736  /* escape seems to be pretty rare <5% so I do not optimize it */
737  put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]);
738  /* escape: only clip in this case */
739  put_bits(&s->pb, 6, run);
740  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
741  if (alevel < 128) {
742  put_sbits(&s->pb, 8, level);
743  } else {
744  if (level < 0)
745  put_bits(&s->pb, 16, 0x8001 + level + 255);
746  else
747  put_sbits(&s->pb, 16, level);
748  }
749  } else {
750  put_sbits(&s->pb, 12, level);
751  }
752  }
753  last_non_zero = i;
754  }
755  }
756  /* end of block */
757  put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
758 }
759 
760 static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s,
761  int16_t block[8][64],
762  int motion_x, int motion_y,
763  int mb_block_count)
764 {
765  int i, cbp;
766  const int mb_x = s->mb_x;
767  const int mb_y = s->mb_y;
768  const int first_mb = mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
769 
770  /* compute cbp */
771  cbp = 0;
772  for (i = 0; i < mb_block_count; i++)
773  if (s->block_last_index[i] >= 0)
774  cbp |= 1 << (mb_block_count - 1 - i);
775 
776  if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 &&
777  (mb_x != s->mb_width - 1 ||
778  (mb_y != s->end_mb_y - 1 && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)) &&
779  ((s->pict_type == AV_PICTURE_TYPE_P && (motion_x | motion_y) == 0) ||
780  (s->pict_type == AV_PICTURE_TYPE_B && s->mv_dir == s->last_mv_dir &&
781  (((s->mv_dir & MV_DIR_FORWARD)
782  ? ((s->mv[0][0][0] - s->last_mv[0][0][0]) |
783  (s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
784  ((s->mv_dir & MV_DIR_BACKWARD)
785  ? ((s->mv[1][0][0] - s->last_mv[1][0][0]) |
786  (s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
787  s->mb_skip_run++;
788  s->qscale -= s->dquant;
789  s->skip_count++;
790  s->misc_bits++;
791  s->last_bits++;
792  if (s->pict_type == AV_PICTURE_TYPE_P) {
793  s->last_mv[0][0][0] =
794  s->last_mv[0][0][1] =
795  s->last_mv[0][1][0] =
796  s->last_mv[0][1][1] = 0;
797  }
798  } else {
799  if (first_mb) {
800  av_assert0(s->mb_skip_run == 0);
801  encode_mb_skip_run(s, s->mb_x);
802  } else {
803  encode_mb_skip_run(s, s->mb_skip_run);
804  }
805 
806  if (s->pict_type == AV_PICTURE_TYPE_I) {
807  if (s->dquant && cbp) {
808  /* macroblock_type: macroblock_quant = 1 */
809  put_mb_modes(s, 2, 1, 0, 0);
810  put_qscale(s);
811  } else {
812  /* macroblock_type: macroblock_quant = 0 */
813  put_mb_modes(s, 1, 1, 0, 0);
814  s->qscale -= s->dquant;
815  }
816  s->misc_bits += get_bits_diff(s);
817  s->i_count++;
818  } else if (s->mb_intra) {
819  if (s->dquant && cbp) {
820  put_mb_modes(s, 6, 0x01, 0, 0);
821  put_qscale(s);
822  } else {
823  put_mb_modes(s, 5, 0x03, 0, 0);
824  s->qscale -= s->dquant;
825  }
826  s->misc_bits += get_bits_diff(s);
827  s->i_count++;
828  memset(s->last_mv, 0, sizeof(s->last_mv));
829  } else if (s->pict_type == AV_PICTURE_TYPE_P) {
830  if (s->mv_type == MV_TYPE_16X16) {
831  if (cbp != 0) {
832  if ((motion_x | motion_y) == 0) {
833  if (s->dquant) {
834  /* macroblock_pattern & quant */
835  put_mb_modes(s, 5, 1, 0, 0);
836  put_qscale(s);
837  } else {
838  /* macroblock_pattern only */
839  put_mb_modes(s, 2, 1, 0, 0);
840  }
841  s->misc_bits += get_bits_diff(s);
842  } else {
843  if (s->dquant) {
844  put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */
845  put_qscale(s);
846  } else {
847  put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */
848  }
849  s->misc_bits += get_bits_diff(s);
850  // RAL: f_code parameter added
851  mpeg1_encode_motion(s,
852  motion_x - s->last_mv[0][0][0],
853  s->f_code);
854  // RAL: f_code parameter added
855  mpeg1_encode_motion(s,
856  motion_y - s->last_mv[0][0][1],
857  s->f_code);
858  s->mv_bits += get_bits_diff(s);
859  }
860  } else {
861  put_bits(&s->pb, 3, 1); /* motion only */
862  if (!s->frame_pred_frame_dct)
863  put_bits(&s->pb, 2, 2); /* motion_type: frame */
864  s->misc_bits += get_bits_diff(s);
865  // RAL: f_code parameter added
866  mpeg1_encode_motion(s,
867  motion_x - s->last_mv[0][0][0],
868  s->f_code);
869  // RAL: f_code parameter added
870  mpeg1_encode_motion(s,
871  motion_y - s->last_mv[0][0][1],
872  s->f_code);
873  s->qscale -= s->dquant;
874  s->mv_bits += get_bits_diff(s);
875  }
876  s->last_mv[0][1][0] = s->last_mv[0][0][0] = motion_x;
877  s->last_mv[0][1][1] = s->last_mv[0][0][1] = motion_y;
878  } else {
880 
881  if (cbp) {
882  if (s->dquant) {
883  put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
884  put_qscale(s);
885  } else {
886  put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
887  }
888  } else {
889  put_bits(&s->pb, 3, 1); /* motion only */
890  put_bits(&s->pb, 2, 1); /* motion_type: field */
891  s->qscale -= s->dquant;
892  }
893  s->misc_bits += get_bits_diff(s);
894  for (i = 0; i < 2; i++) {
895  put_bits(&s->pb, 1, s->field_select[0][i]);
896  mpeg1_encode_motion(s,
897  s->mv[0][i][0] - s->last_mv[0][i][0],
898  s->f_code);
899  mpeg1_encode_motion(s,
900  s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
901  s->f_code);
902  s->last_mv[0][i][0] = s->mv[0][i][0];
903  s->last_mv[0][i][1] = 2 * s->mv[0][i][1];
904  }
905  s->mv_bits += get_bits_diff(s);
906  }
907  if (cbp) {
908  if (s->chroma_y_shift) {
909  put_bits(&s->pb,
910  ff_mpeg12_mbPatTable[cbp][1],
911  ff_mpeg12_mbPatTable[cbp][0]);
912  } else {
913  put_bits(&s->pb,
914  ff_mpeg12_mbPatTable[cbp >> 2][1],
915  ff_mpeg12_mbPatTable[cbp >> 2][0]);
916  put_sbits(&s->pb, 2, cbp);
917  }
918  }
919  s->f_count++;
920  } else {
921  if (s->mv_type == MV_TYPE_16X16) {
922  if (cbp) { // With coded bloc pattern
923  if (s->dquant) {
924  if (s->mv_dir == MV_DIR_FORWARD)
925  put_mb_modes(s, 6, 3, 1, 0);
926  else
927  put_mb_modes(s, 8 - s->mv_dir, 2, 1, 0);
928  put_qscale(s);
929  } else {
930  put_mb_modes(s, 5 - s->mv_dir, 3, 1, 0);
931  }
932  } else { // No coded bloc pattern
933  put_bits(&s->pb, 5 - s->mv_dir, 2);
934  if (!s->frame_pred_frame_dct)
935  put_bits(&s->pb, 2, 2); /* motion_type: frame */
936  s->qscale -= s->dquant;
937  }
938  s->misc_bits += get_bits_diff(s);
939  if (s->mv_dir & MV_DIR_FORWARD) {
940  mpeg1_encode_motion(s,
941  s->mv[0][0][0] - s->last_mv[0][0][0],
942  s->f_code);
943  mpeg1_encode_motion(s,
944  s->mv[0][0][1] - s->last_mv[0][0][1],
945  s->f_code);
946  s->last_mv[0][0][0] =
947  s->last_mv[0][1][0] = s->mv[0][0][0];
948  s->last_mv[0][0][1] =
949  s->last_mv[0][1][1] = s->mv[0][0][1];
950  s->f_count++;
951  }
952  if (s->mv_dir & MV_DIR_BACKWARD) {
953  mpeg1_encode_motion(s,
954  s->mv[1][0][0] - s->last_mv[1][0][0],
955  s->b_code);
956  mpeg1_encode_motion(s,
957  s->mv[1][0][1] - s->last_mv[1][0][1],
958  s->b_code);
959  s->last_mv[1][0][0] =
960  s->last_mv[1][1][0] = s->mv[1][0][0];
961  s->last_mv[1][0][1] =
962  s->last_mv[1][1][1] = s->mv[1][0][1];
963  s->b_count++;
964  }
965  } else {
968  if (cbp) { // With coded bloc pattern
969  if (s->dquant) {
970  if (s->mv_dir == MV_DIR_FORWARD)
971  put_mb_modes(s, 6, 3, 1, 1);
972  else
973  put_mb_modes(s, 8 - s->mv_dir, 2, 1, 1);
974  put_qscale(s);
975  } else {
976  put_mb_modes(s, 5 - s->mv_dir, 3, 1, 1);
977  }
978  } else { // No coded bloc pattern
979  put_bits(&s->pb, 5 - s->mv_dir, 2);
980  put_bits(&s->pb, 2, 1); /* motion_type: field */
981  s->qscale -= s->dquant;
982  }
983  s->misc_bits += get_bits_diff(s);
984  if (s->mv_dir & MV_DIR_FORWARD) {
985  for (i = 0; i < 2; i++) {
986  put_bits(&s->pb, 1, s->field_select[0][i]);
987  mpeg1_encode_motion(s,
988  s->mv[0][i][0] - s->last_mv[0][i][0],
989  s->f_code);
990  mpeg1_encode_motion(s,
991  s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
992  s->f_code);
993  s->last_mv[0][i][0] = s->mv[0][i][0];
994  s->last_mv[0][i][1] = s->mv[0][i][1] * 2;
995  }
996  s->f_count++;
997  }
998  if (s->mv_dir & MV_DIR_BACKWARD) {
999  for (i = 0; i < 2; i++) {
1000  put_bits(&s->pb, 1, s->field_select[1][i]);
1001  mpeg1_encode_motion(s,
1002  s->mv[1][i][0] - s->last_mv[1][i][0],
1003  s->b_code);
1004  mpeg1_encode_motion(s,
1005  s->mv[1][i][1] - (s->last_mv[1][i][1] >> 1),
1006  s->b_code);
1007  s->last_mv[1][i][0] = s->mv[1][i][0];
1008  s->last_mv[1][i][1] = s->mv[1][i][1] * 2;
1009  }
1010  s->b_count++;
1011  }
1012  }
1013  s->mv_bits += get_bits_diff(s);
1014  if (cbp) {
1015  if (s->chroma_y_shift) {
1016  put_bits(&s->pb,
1017  ff_mpeg12_mbPatTable[cbp][1],
1018  ff_mpeg12_mbPatTable[cbp][0]);
1019  } else {
1020  put_bits(&s->pb,
1021  ff_mpeg12_mbPatTable[cbp >> 2][1],
1022  ff_mpeg12_mbPatTable[cbp >> 2][0]);
1023  put_sbits(&s->pb, 2, cbp);
1024  }
1025  }
1026  }
1027  for (i = 0; i < mb_block_count; i++)
1028  if (cbp & (1 << (mb_block_count - 1 - i)))
1029  mpeg1_encode_block(s, block[i], i);
1030  s->mb_skip_run = 0;
1031  if (s->mb_intra)
1032  s->i_tex_bits += get_bits_diff(s);
1033  else
1034  s->p_tex_bits += get_bits_diff(s);
1035  }
1036 }
1037 
1038 void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64],
1039  int motion_x, int motion_y)
1040 {
1041  if (s->chroma_format == CHROMA_420)
1042  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6);
1043  else
1044  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8);
1045 }
1046 
1047 static av_cold void mpeg12_encode_init_static(void)
1048 {
1049  static uint8_t mpeg12_static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3];
1050 
1051  ff_rl_init(&ff_rl_mpeg1, mpeg12_static_rl_table_store[0]);
1052  ff_rl_init(&ff_rl_mpeg2, mpeg12_static_rl_table_store[1]);
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  FF_MPV_COMMON_BFRAME_OPTS
1152 
1153 static const AVOption mpeg1_options[] = {
1154  COMMON_OPTS
1156 #if FF_API_MPEGVIDEO_OPTS
1160 #endif
1161  { NULL },
1162 };
1163 
1164 static const AVOption mpeg2_options[] = {
1165  COMMON_OPTS
1166  { "intra_vlc", "Use MPEG-2 intra VLC table.",
1167  OFFSET(intra_vlc_format), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1168  { "non_linear_quant", "Use nonlinear quantizer.", OFFSET(q_scale_type), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1169  { "alternate_scan", "Enable alternate scantable.", OFFSET(alternate_scan), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1170  { "a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
1171  { "seq_disp_ext", "Write sequence_display_extension blocks.", OFFSET(seq_disp_ext), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "seq_disp_ext" },
1172  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, VE, "seq_disp_ext" },
1173  { "never", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, VE, "seq_disp_ext" },
1174  { "always", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, VE, "seq_disp_ext" },
1175  { "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" },
1176  { "component", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_COMPONENT }, 0, 0, VE, "video_format" },
1177  { "pal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_PAL }, 0, 0, VE, "video_format" },
1178  { "ntsc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_NTSC }, 0, 0, VE, "video_format" },
1179  { "secam", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_SECAM }, 0, 0, VE, "video_format" },
1180  { "mac", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_MAC }, 0, 0, VE, "video_format" },
1181  { "unspecified", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_UNSPECIFIED}, 0, 0, VE, "video_format" },
1182 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, { .i64 = value }, 0, 0, VE, "avctx.level"
1183  { LEVEL("high", 4) },
1184  { LEVEL("high1440", 6) },
1185  { LEVEL("main", 8) },
1186  { LEVEL("low", 10) },
1187 #undef LEVEL
1189 #if FF_API_MPEGVIDEO_OPTS
1190  { "mpeg_quant", "Deprecated, does nothing", OFFSET(mpeg_quant),
1191  AV_OPT_TYPE_INT, {.i64 = 1 }, 0, 1, VE | AV_OPT_FLAG_DEPRECATED },
1193 #endif
1195  { NULL },
1196 };
1197 
1198 #define mpeg12_class(x) \
1199 static const AVClass mpeg ## x ## _class = { \
1200  .class_name = "mpeg" # x "video encoder", \
1201  .item_name = av_default_item_name, \
1202  .option = mpeg ## x ## _options, \
1203  .version = LIBAVUTIL_VERSION_INT, \
1204 };
1205 
1206 mpeg12_class(1)
1207 mpeg12_class(2)
1208 
1210  .name = "mpeg1video",
1211  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
1212  .type = AVMEDIA_TYPE_VIDEO,
1213  .id = AV_CODEC_ID_MPEG1VIDEO,
1214  .priv_data_size = sizeof(MpegEncContext),
1215  .init = encode_init,
1216  .encode2 = ff_mpv_encode_picture,
1217  .close = ff_mpv_encode_end,
1218  .supported_framerates = ff_mpeg12_frame_rate_tab + 1,
1219  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
1220  AV_PIX_FMT_NONE },
1223  .priv_class = &mpeg1_class,
1224 };
1225 
1227  .name = "mpeg2video",
1228  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
1229  .type = AVMEDIA_TYPE_VIDEO,
1230  .id = AV_CODEC_ID_MPEG2VIDEO,
1231  .priv_data_size = sizeof(MpegEncContext),
1232  .init = encode_init,
1233  .encode2 = ff_mpv_encode_picture,
1234  .close = ff_mpv_encode_end,
1235  .supported_framerates = ff_mpeg2_frame_rate_tab,
1236  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
1238  AV_PIX_FMT_NONE },
1241  .priv_class = &mpeg2_class,
1242 };
1243 #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:49
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:1606
#define MASK_ABS(mask, level)
Definition: mathops.h:155
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:545
int64_t timecode_frame_start
GOP timecode frame start number, in non drop frame format.
Definition: mpegvideo.h:468
int aspect_ratio_info
Definition: mpegvideo.h:404
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:422
const AVRational ff_mpeg2_frame_rate_tab[]
Definition: mpeg12data.c:308
#define FF_PROFILE_MPEG2_MAIN
Definition: avcodec.h:1891
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
#define FF_MPV_DEPRECATED_A53_CC_OPT
Definition: mpegvideo.h:685
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG-1 & B-frame MPEG-4
Definition: mpegvideo.h:278
#define AV_OPT_FLAG_DEPRECATED
set if option is deprecated, users should refer to AVOption.help text for more information ...
Definition: opt.h:295
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:290
#define FF_MPV_DEPRECATED_MPEG_QUANT_OPT
Definition: mpegvideo.h:683
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:479
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:31
#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:629
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:915
int scan_offset
reserve space for SVCD scan offset user data.
Definition: mpegvideo.h:499
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
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:203
static int put_bytes_count(const PutBitContext *s, int round_up)
Definition: put_bits.h:104
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
fg index
int profile
profile
Definition: avcodec.h:1858
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
AVCodec.
Definition: codec.h:197
#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:659
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:739
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1985
#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:77
#define VIDEO_FORMAT_NTSC
Definition: mpegvideo.h:481
#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
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
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:480
#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:1007
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:496
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:180
#define CHROMA_420
Definition: mpegvideo.h:488
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:52
#define VIDEO_FORMAT_UNSPECIFIED
Definition: mpegvideo.h:484
AVCodec ff_mpeg1video_encoder
int intra_dc_precision
Definition: mpegvideo.h:469
int repeat_first_field
Definition: mpegvideo.h:485
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:482
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:456
#define av_log(a,...)
#define VE
Definition: amfenc_h264.c:26
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1605
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:777
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:492
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:117
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
#define VIDEO_FORMAT_MAC
Definition: mpegvideo.h:483
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:616
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:204
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:408
attribute_deprecated int64_t timecode_frame_start
Definition: avcodec.h:1500
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:1401
uint8_t * intra_ac_vlc_last_length
Definition: mpegvideo.h:312
int intra_vlc_format
Definition: mpegvideo.h:475
#define FF_PROFILE_MPEG2_HIGH
Definition: avcodec.h:1888
int progressive_frame
Definition: mpegvideo.h:494
uint8_t * vbv_delay_ptr
pointer to vbv_delay in the bitstream
Definition: mpegvideo.h:458
const uint16_t(* table_vlc)[2]
Definition: rl.h:42
#define width
int width
picture width / height.
Definition: avcodec.h:709
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:1859
RLTable ff_rl_mpeg1
Definition: mpeg12data.c:166
int alternate_scan
Definition: mpegvideo.h:476
#define GOP_START_CODE
Definition: mpegvideo.h:69
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1150
#define FF_PROFILE_MPEG2_422
Definition: avcodec.h:1887
#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:1984
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:112
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:470
const char * long_name
Descriptive name for the codec, meant to be more human readable than name.
Definition: codec.h:209
#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:432
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:472
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:505
enum AVCodecID codec_id
Definition: avcodec.h:546
Timecode helpers header.
#define abs(x)
Definition: cuda_runtime.h:35
main external API structure.
Definition: avcodec.h:536
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:163
av_cold void ff_mpeg1_init_uni_ac_vlc(const RLTable *rl, uint8_t *uni_ac_vlc_len)
Definition: mpeg12enc.c:68
int ff_mpv_encode_init(AVCodecContext *avctx)
uint8_t * inter_ac_vlc_length
Definition: mpegvideo.h:315
int progressive_sequence
Definition: mpegvideo.h:461
uint16_t * intra_matrix
custom intra quantization matrix Must be allocated with the av_malloc() family of functions...
Definition: avcodec.h:1036
#define FF_MPEG2_PROFILE_OPTS
Definition: profiles.h:46
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1164
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1157
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:282
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:1045
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:457
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:204
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:563
#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:466
#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:470
int len
#define SEQ_START_CODE
Definition: mpegvideo.h:68
int drop_frame_timecode
timecode is in drop frame format.
Definition: mpegvideo.h:498
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:396
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:623
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 FF_MPV_DEPRECATED_MATRIX_OPT
Definition: mpegvideo.h:687
#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:506
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:1601
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275
#define av_mod_uintp2
Definition: common.h:149
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1416
const AVRational ff_mpeg12_frame_rate_tab[]