FFmpeg
mpeg12enc.c
Go to the documentation of this file.
1 /*
2  * MPEG-1/2 encoder
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * MPEG-1/2 encoder
26  */
27 
28 #include <stdint.h>
29 
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/log.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/thread.h"
35 #include "libavutil/timecode.h"
36 #include "libavutil/stereo3d.h"
37 
38 #include "avcodec.h"
39 #include "bytestream.h"
40 #include "mathops.h"
41 #include "mpeg12.h"
42 #include "mpeg12data.h"
43 #include "mpegutils.h"
44 #include "mpegvideo.h"
45 #include "profiles.h"
46 
48  0x10, 0x0E, 0x00, 0x80, 0x81, 0x00, 0x80,
49  0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
50 };
51 
52 static uint8_t mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
53 static uint8_t fcode_tab[MAX_MV * 2 + 1];
54 
55 static uint8_t uni_mpeg1_ac_vlc_len[64 * 64 * 2];
56 static uint8_t uni_mpeg2_ac_vlc_len[64 * 64 * 2];
57 
58 /* simple include everything table for dc, first byte is bits
59  * number next 3 are code */
60 static uint32_t mpeg1_lum_dc_uni[512];
61 static uint32_t mpeg1_chr_dc_uni[512];
62 
63 static uint8_t mpeg1_index_run[2][64];
64 static int8_t mpeg1_max_level[2][64];
65 
66 #define A53_MAX_CC_COUNT 0x1f
67 
68 static av_cold void init_uni_ac_vlc(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 
104 {
105  int i;
106  AVRational bestq = (AVRational) {0, 0};
107  AVRational ext;
108  AVRational target = av_inv_q(s->avctx->time_base);
109 
110  for (i = 1; i < 14; i++) {
112  i >= 9)
113  break;
114 
115  for (ext.num=1; ext.num <= 4; ext.num++) {
116  for (ext.den=1; ext.den <= 32; ext.den++) {
118 
119  if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO && (ext.den!=1 || ext.num!=1))
120  continue;
121  if (av_gcd(ext.den, ext.num) != 1)
122  continue;
123 
124  if ( bestq.num==0
125  || av_nearer_q(target, bestq, q) < 0
126  || ext.num==1 && ext.den==1 && av_nearer_q(target, bestq, q) == 0) {
127  bestq = q;
128  s->frame_rate_index = i;
129  s->mpeg2_frame_rate_ext.num = ext.num;
130  s->mpeg2_frame_rate_ext.den = ext.den;
131  }
132  }
133  }
134  }
135 
136  if (av_cmp_q(target, bestq))
137  return -1;
138  else
139  return 0;
140 }
141 
143 {
144  int ret;
145  MpegEncContext *s = avctx->priv_data;
146 
147  if ((ret = ff_mpv_encode_init(avctx)) < 0)
148  return ret;
149 
150  if (find_frame_rate_index(s) < 0) {
152  av_log(avctx, AV_LOG_ERROR, "MPEG-1/2 does not support %d/%d fps\n",
153  avctx->time_base.den, avctx->time_base.num);
154  return AVERROR(EINVAL);
155  } else {
156  av_log(avctx, AV_LOG_INFO,
157  "MPEG-1/2 does not support %d/%d fps, there may be AV sync issues\n",
158  avctx->time_base.den, avctx->time_base.num);
159  }
160  }
161 
162  if (avctx->profile == FF_PROFILE_UNKNOWN) {
163  if (avctx->level != FF_LEVEL_UNKNOWN) {
164  av_log(avctx, AV_LOG_ERROR, "Set profile and level\n");
165  return AVERROR(EINVAL);
166  }
167  /* Main or 4:2:2 */
169  }
170 
171  if (avctx->level == FF_LEVEL_UNKNOWN) {
172  if (avctx->profile == FF_PROFILE_MPEG2_422) { /* 4:2:2 */
173  if (avctx->width <= 720 && avctx->height <= 608)
174  avctx->level = 5; /* Main */
175  else
176  avctx->level = 2; /* High */
177  } else {
178  if (avctx->profile != FF_PROFILE_MPEG2_HIGH && s->chroma_format != CHROMA_420) {
179  av_log(avctx, AV_LOG_ERROR,
180  "Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n");
181  return AVERROR(EINVAL);
182  }
183  if (avctx->width <= 720 && avctx->height <= 576)
184  avctx->level = 8; /* Main */
185  else if (avctx->width <= 1440)
186  avctx->level = 6; /* High 1440 */
187  else
188  avctx->level = 4; /* High */
189  }
190  }
191 
192  if ((avctx->width & 0xFFF) == 0 && (avctx->height & 0xFFF) == 1) {
193  av_log(avctx, AV_LOG_ERROR, "Width / Height is invalid for MPEG2\n");
194  return AVERROR(EINVAL);
195  }
196 
198  if ((avctx->width & 0xFFF) == 0 || (avctx->height & 0xFFF) == 0) {
199  av_log(avctx, AV_LOG_ERROR, "Width or Height are not allowed to be multiples of 4096\n"
200  "add '-strict %d' if you want to use them anyway.\n", FF_COMPLIANCE_UNOFFICIAL);
201  return AVERROR(EINVAL);
202  }
203  }
204 
206  if (s->drop_frame_timecode)
208  if (s->drop_frame_timecode && s->frame_rate_index != 4) {
209  av_log(avctx, AV_LOG_ERROR,
210  "Drop frame time code only allowed with 1001/30000 fps\n");
211  return AVERROR(EINVAL);
212  }
213 
214 #if FF_API_PRIVATE_OPT
216  if (avctx->timecode_frame_start)
219 #endif
220 
221  if (s->tc_opt_str) {
223  int ret = av_timecode_init_from_string(&s->tc, rate, s->tc_opt_str, s);
224  if (ret < 0)
225  return ret;
227  s->timecode_frame_start = s->tc.start;
228  } else {
229  s->timecode_frame_start = 0; // default is -1
230  }
231 
232  return 0;
233 }
234 
235 static void put_header(MpegEncContext *s, int header)
236 {
237  align_put_bits(&s->pb);
238  put_bits(&s->pb, 16, header >> 16);
239  put_sbits(&s->pb, 16, header);
240 }
241 
242 /* put sequence header if needed */
244 {
245  unsigned int vbv_buffer_size, fps, v;
246  int i, constraint_parameter_flag;
247  uint64_t time_code;
248  int64_t best_aspect_error = INT64_MAX;
249  AVRational aspect_ratio = s->avctx->sample_aspect_ratio;
250 
251  if (aspect_ratio.num == 0 || aspect_ratio.den == 0)
252  aspect_ratio = (AVRational){1,1}; // pixel aspect 1.1 (VGA)
253 
254  if (s->current_picture.f->key_frame) {
256 
257  /* MPEG-1 header repeated every GOP */
259 
260  put_sbits(&s->pb, 12, s->width & 0xFFF);
261  put_sbits(&s->pb, 12, s->height & 0xFFF);
262 
263  for (i = 1; i < 15; i++) {
264  int64_t error = aspect_ratio.num * (1LL<<32) / aspect_ratio.den;
265  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || i <= 1)
266  error -= (1LL<<32) / ff_mpeg1_aspect[i];
267  else
268  error -= (1LL<<32)*ff_mpeg2_aspect[i].num * s->height / s->width / ff_mpeg2_aspect[i].den;
269 
270  error = FFABS(error);
271 
272  if (error - 2 <= best_aspect_error) {
273  best_aspect_error = error;
274  s->aspect_ratio_info = i;
275  }
276  }
277 
278  put_bits(&s->pb, 4, s->aspect_ratio_info);
279  put_bits(&s->pb, 4, s->frame_rate_index);
280 
281  if (s->avctx->rc_max_rate) {
282  v = (s->avctx->rc_max_rate + 399) / 400;
283  if (v > 0x3ffff && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
284  v = 0x3ffff;
285  } else {
286  v = 0x3FFFF;
287  }
288 
289  if (s->avctx->rc_buffer_size)
290  vbv_buffer_size = s->avctx->rc_buffer_size;
291  else
292  /* VBV calculation: Scaled so that a VCD has the proper
293  * VBV size of 40 kilobytes */
294  vbv_buffer_size = ((20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
295  vbv_buffer_size = (vbv_buffer_size + 16383) / 16384;
296 
297  put_sbits(&s->pb, 18, v);
298  put_bits(&s->pb, 1, 1); // marker
299  put_sbits(&s->pb, 10, vbv_buffer_size);
300 
301  constraint_parameter_flag =
302  s->width <= 768 &&
303  s->height <= 576 &&
304  s->mb_width * s->mb_height <= 396 &&
305  s->mb_width * s->mb_height * framerate.num <= 396 * 25 * framerate.den &&
306  framerate.num <= framerate.den * 30 &&
307  s->avctx->me_range &&
308  s->avctx->me_range < 128 &&
309  vbv_buffer_size <= 20 &&
310  v <= 1856000 / 400 &&
312 
313  put_bits(&s->pb, 1, constraint_parameter_flag);
314 
317 
318  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
319  AVFrameSideData *side_data;
320  int width = s->width;
321  int height = s->height;
322  int use_seq_disp_ext;
323 
325  put_bits(&s->pb, 4, 1); // seq ext
326 
327  put_bits(&s->pb, 1, s->avctx->profile == FF_PROFILE_MPEG2_422); // escx 1 for 4:2:2 profile
328 
329  put_bits(&s->pb, 3, s->avctx->profile); // profile
330  put_bits(&s->pb, 4, s->avctx->level); // level
331 
332  put_bits(&s->pb, 1, s->progressive_sequence);
333  put_bits(&s->pb, 2, s->chroma_format);
334  put_bits(&s->pb, 2, s->width >> 12);
335  put_bits(&s->pb, 2, s->height >> 12);
336  put_bits(&s->pb, 12, v >> 18); // bitrate ext
337  put_bits(&s->pb, 1, 1); // marker
338  put_bits(&s->pb, 8, vbv_buffer_size >> 10); // vbv buffer ext
339  put_bits(&s->pb, 1, s->low_delay);
340  put_bits(&s->pb, 2, s->mpeg2_frame_rate_ext.num-1); // frame_rate_ext_n
341  put_bits(&s->pb, 5, s->mpeg2_frame_rate_ext.den-1); // frame_rate_ext_d
342 
344  if (side_data) {
345  AVPanScan *pan_scan = (AVPanScan *)side_data->data;
346  if (pan_scan->width && pan_scan->height) {
347  width = pan_scan->width >> 4;
348  height = pan_scan->height >> 4;
349  }
350  }
351 
352  use_seq_disp_ext = (width != s->width ||
353  height != s->height ||
358 
359  if (s->seq_disp_ext == 1 || (s->seq_disp_ext == -1 && use_seq_disp_ext)) {
361  put_bits(&s->pb, 4, 2); // sequence display extension
362  put_bits(&s->pb, 3, s->video_format); // video_format
363  put_bits(&s->pb, 1, 1); // colour_description
364  put_bits(&s->pb, 8, s->avctx->color_primaries); // colour_primaries
365  put_bits(&s->pb, 8, s->avctx->color_trc); // transfer_characteristics
366  put_bits(&s->pb, 8, s->avctx->colorspace); // matrix_coefficients
367  put_bits(&s->pb, 14, width); // display_horizontal_size
368  put_bits(&s->pb, 1, 1); // marker_bit
369  put_bits(&s->pb, 14, height); // display_vertical_size
370  put_bits(&s->pb, 3, 0); // remaining 3 bits are zero padding
371  }
372  }
373 
375  put_bits(&s->pb, 1, s->drop_frame_timecode); // drop frame flag
376  /* time code: we must convert from the real frame rate to a
377  * fake MPEG frame rate in case of low frame rate */
378  fps = (framerate.num + framerate.den / 2) / framerate.den;
379  time_code = s->current_picture_ptr->f->coded_picture_number +
381 
383 
385  if (s->drop_frame_timecode)
386  time_code = av_timecode_adjust_ntsc_framenum2(time_code, fps);
387 
388  put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
389  put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
390  put_bits(&s->pb, 1, 1);
391  put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
392  put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
394  put_bits(&s->pb, 1, 0); // broken link
395  }
396 }
397 
398 static inline void encode_mb_skip_run(MpegEncContext *s, int run)
399 {
400  while (run >= 33) {
401  put_bits(&s->pb, 11, 0x008);
402  run -= 33;
403  }
405  ff_mpeg12_mbAddrIncrTable[run][0]);
406 }
407 
409 {
410  put_bits(&s->pb, 5, s->qscale);
411 }
412 
414 {
415  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->height > 2800) {
416  put_header(s, SLICE_MIN_START_CODE + (s->mb_y & 127));
417  /* slice_vertical_position_extension */
418  put_bits(&s->pb, 3, s->mb_y >> 7);
419  } else {
421  }
422  put_qscale(s);
423  /* slice extra information */
424  put_bits(&s->pb, 1, 0);
425 }
426 
428 {
429  AVFrameSideData *side_data;
431 
432  /* MPEG-1 picture header */
434  /* temporal reference */
435 
436  // RAL: s->picture_number instead of s->fake_picture_number
437  put_bits(&s->pb, 10,
438  (s->picture_number - s->gop_picture_number) & 0x3ff);
439  put_bits(&s->pb, 3, s->pict_type);
440 
441  s->vbv_delay_ptr = s->pb.buf + put_bits_count(&s->pb) / 8;
442  put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
443 
444  // RAL: Forward f_code also needed for B-frames
445  if (s->pict_type == AV_PICTURE_TYPE_P ||
447  put_bits(&s->pb, 1, 0); /* half pel coordinates */
449  put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
450  else
451  put_bits(&s->pb, 3, 7); /* forward_f_code */
452  }
453 
454  // RAL: Backward f_code necessary for B-frames
455  if (s->pict_type == AV_PICTURE_TYPE_B) {
456  put_bits(&s->pb, 1, 0); /* half pel coordinates */
458  put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
459  else
460  put_bits(&s->pb, 3, 7); /* backward_f_code */
461  }
462 
463  put_bits(&s->pb, 1, 0); /* extra bit picture */
464 
465  s->frame_pred_frame_dct = 1;
466  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
468  put_bits(&s->pb, 4, 8); /* pic ext */
469  if (s->pict_type == AV_PICTURE_TYPE_P ||
471  put_bits(&s->pb, 4, s->f_code);
472  put_bits(&s->pb, 4, s->f_code);
473  } else {
474  put_bits(&s->pb, 8, 255);
475  }
476  if (s->pict_type == AV_PICTURE_TYPE_B) {
477  put_bits(&s->pb, 4, s->b_code);
478  put_bits(&s->pb, 4, s->b_code);
479  } else {
480  put_bits(&s->pb, 8, 255);
481  }
482  put_bits(&s->pb, 2, s->intra_dc_precision);
483 
485  put_bits(&s->pb, 2, s->picture_structure);
486  if (s->progressive_sequence)
487  put_bits(&s->pb, 1, 0); /* no repeat */
488  else
490  /* XXX: optimize the generation of this flag with entropy measures */
492 
493  put_bits(&s->pb, 1, s->frame_pred_frame_dct);
495  put_bits(&s->pb, 1, s->q_scale_type);
496  put_bits(&s->pb, 1, s->intra_vlc_format);
497  put_bits(&s->pb, 1, s->alternate_scan);
498  put_bits(&s->pb, 1, s->repeat_first_field);
500  /* chroma_420_type */
501  put_bits(&s->pb, 1, s->chroma_format ==
502  CHROMA_420 ? s->progressive_frame : 0);
503  put_bits(&s->pb, 1, s->progressive_frame);
504  put_bits(&s->pb, 1, 0); /* composite_display_flag */
505  }
506  if (s->scan_offset) {
507  int i;
508 
510  for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
512  }
515  if (side_data) {
516  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
517  uint8_t fpa_type;
518 
519  switch (stereo->type) {
521  fpa_type = 0x03;
522  break;
524  fpa_type = 0x04;
525  break;
526  case AV_STEREO3D_2D:
527  fpa_type = 0x08;
528  break;
530  fpa_type = 0x23;
531  break;
532  default:
533  fpa_type = 0;
534  break;
535  }
536 
537  if (fpa_type != 0) {
539  put_bits(&s->pb, 8, 'J'); // S3D_video_format_signaling_identifier
540  put_bits(&s->pb, 8, 'P');
541  put_bits(&s->pb, 8, '3');
542  put_bits(&s->pb, 8, 'D');
543  put_bits(&s->pb, 8, 0x03); // S3D_video_format_length
544 
545  put_bits(&s->pb, 1, 1); // reserved_bit
546  put_bits(&s->pb, 7, fpa_type); // S3D_video_format_type
547  put_bits(&s->pb, 8, 0x04); // reserved_data[0]
548  put_bits(&s->pb, 8, 0xFF); // reserved_data[1]
549  }
550  }
551 
552  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->a53_cc) {
555  if (side_data) {
556  if (side_data->size <= A53_MAX_CC_COUNT * 3 && side_data->size % 3 == 0) {
557  int i = 0;
558 
560 
561  put_bits(&s->pb, 8, 'G'); // user_identifier
562  put_bits(&s->pb, 8, 'A');
563  put_bits(&s->pb, 8, '9');
564  put_bits(&s->pb, 8, '4');
565  put_bits(&s->pb, 8, 3); // user_data_type_code
566  put_bits(&s->pb, 8,
567  (side_data->size / 3 & A53_MAX_CC_COUNT) | 0x40); // flags, cc_count
568  put_bits(&s->pb, 8, 0xff); // em_data
569 
570  for (i = 0; i < side_data->size; i++)
571  put_bits(&s->pb, 8, side_data->data[i]);
572 
573  put_bits(&s->pb, 8, 0xff); // marker_bits
574  } else {
576  "Warning Closed Caption size (%d) can not exceed 93 bytes "
577  "and must be a multiple of 3\n", side_data->size);
578  }
579  }
580  }
581 
582  s->mb_y = 0;
584 }
585 
586 static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
587  int has_mv, int field_motion)
588 {
589  put_bits(&s->pb, n, bits);
590  if (!s->frame_pred_frame_dct) {
591  if (has_mv)
592  /* motion_type: frame/field */
593  put_bits(&s->pb, 2, 2 - field_motion);
594  put_bits(&s->pb, 1, s->interlaced_dct);
595  }
596 }
597 
598 // RAL: Parameter added: f_or_b_code
599 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
600 {
601  if (val == 0) {
602  /* zero vector */
603  put_bits(&s->pb,
606  } else {
607  int code, sign, bits;
608  int bit_size = f_or_b_code - 1;
609  int range = 1 << bit_size;
610  /* modulo encoding */
611  val = sign_extend(val, 5 + bit_size);
612 
613  if (val >= 0) {
614  val--;
615  code = (val >> bit_size) + 1;
616  bits = val & (range - 1);
617  sign = 0;
618  } else {
619  val = -val;
620  val--;
621  code = (val >> bit_size) + 1;
622  bits = val & (range - 1);
623  sign = 1;
624  }
625 
626  av_assert2(code > 0 && code <= 16);
627 
628  put_bits(&s->pb,
631 
632  put_bits(&s->pb, 1, sign);
633  if (bit_size > 0)
634  put_bits(&s->pb, bit_size, bits);
635  }
636 }
637 
638 static inline void encode_dc(MpegEncContext *s, int diff, int component)
639 {
640  unsigned int diff_u = diff + 255;
641  if (diff_u >= 511) {
642  int index;
643 
644  if (diff < 0) {
645  index = av_log2_16bit(-2 * diff);
646  diff--;
647  } else {
648  index = av_log2_16bit(2 * diff);
649  }
650  if (component == 0)
651  put_bits(&s->pb,
652  ff_mpeg12_vlc_dc_lum_bits[index] + index,
653  (ff_mpeg12_vlc_dc_lum_code[index] << index) +
654  av_mod_uintp2(diff, index));
655  else
656  put_bits(&s->pb,
657  ff_mpeg12_vlc_dc_chroma_bits[index] + index,
658  (ff_mpeg12_vlc_dc_chroma_code[index] << index) +
659  av_mod_uintp2(diff, index));
660  } else {
661  if (component == 0)
662  put_bits(&s->pb,
663  mpeg1_lum_dc_uni[diff + 255] & 0xFF,
664  mpeg1_lum_dc_uni[diff + 255] >> 8);
665  else
666  put_bits(&s->pb,
667  mpeg1_chr_dc_uni[diff + 255] & 0xFF,
668  mpeg1_chr_dc_uni[diff + 255] >> 8);
669  }
670 }
671 
672 static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n)
673 {
674  int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
675  int code, component;
676  const uint16_t (*table_vlc)[2] = ff_rl_mpeg1.table_vlc;
677 
678  last_index = s->block_last_index[n];
679 
680  /* DC coef */
681  if (s->mb_intra) {
682  component = (n <= 3 ? 0 : (n & 1) + 1);
683  dc = block[0]; /* overflow is impossible */
684  diff = dc - s->last_dc[component];
685  encode_dc(s, diff, component);
686  s->last_dc[component] = dc;
687  i = 1;
688  if (s->intra_vlc_format)
689  table_vlc = ff_rl_mpeg2.table_vlc;
690  } else {
691  /* encode the first coefficient: needs to be done here because
692  * it is handled slightly differently */
693  level = block[0];
694  if (abs(level) == 1) {
695  code = ((uint32_t)level >> 31); /* the sign bit */
696  put_bits(&s->pb, 2, code | 0x02);
697  i = 1;
698  } else {
699  i = 0;
700  last_non_zero = -1;
701  goto next_coef;
702  }
703  }
704 
705  /* now quantify & encode AC coefs */
706  last_non_zero = i - 1;
707 
708  for (; i <= last_index; i++) {
709  j = s->intra_scantable.permutated[i];
710  level = block[j];
711 
712 next_coef:
713  /* encode using VLC */
714  if (level != 0) {
715  run = i - last_non_zero - 1;
716 
717  alevel = level;
718  MASK_ABS(sign, alevel);
719  sign &= 1;
720 
721  if (alevel <= mpeg1_max_level[0][run]) {
722  code = mpeg1_index_run[0][run] + alevel - 1;
723  /* store the VLC & sign at once */
724  put_bits(&s->pb, table_vlc[code][1] + 1,
725  (table_vlc[code][0] << 1) + sign);
726  } else {
727  /* escape seems to be pretty rare <5% so I do not optimize it */
728  put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]);
729  /* escape: only clip in this case */
730  put_bits(&s->pb, 6, run);
731  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
732  if (alevel < 128) {
733  put_sbits(&s->pb, 8, level);
734  } else {
735  if (level < 0)
736  put_bits(&s->pb, 16, 0x8001 + level + 255);
737  else
738  put_sbits(&s->pb, 16, level);
739  }
740  } else {
741  put_sbits(&s->pb, 12, level);
742  }
743  }
744  last_non_zero = i;
745  }
746  }
747  /* end of block */
748  put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
749 }
750 
752  int16_t block[8][64],
753  int motion_x, int motion_y,
754  int mb_block_count)
755 {
756  int i, cbp;
757  const int mb_x = s->mb_x;
758  const int mb_y = s->mb_y;
759  const int first_mb = mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
760 
761  /* compute cbp */
762  cbp = 0;
763  for (i = 0; i < mb_block_count; i++)
764  if (s->block_last_index[i] >= 0)
765  cbp |= 1 << (mb_block_count - 1 - i);
766 
767  if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 &&
768  (mb_x != s->mb_width - 1 ||
769  (mb_y != s->end_mb_y - 1 && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)) &&
770  ((s->pict_type == AV_PICTURE_TYPE_P && (motion_x | motion_y) == 0) ||
771  (s->pict_type == AV_PICTURE_TYPE_B && s->mv_dir == s->last_mv_dir &&
772  (((s->mv_dir & MV_DIR_FORWARD)
773  ? ((s->mv[0][0][0] - s->last_mv[0][0][0]) |
774  (s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
775  ((s->mv_dir & MV_DIR_BACKWARD)
776  ? ((s->mv[1][0][0] - s->last_mv[1][0][0]) |
777  (s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
778  s->mb_skip_run++;
779  s->qscale -= s->dquant;
780  s->skip_count++;
781  s->misc_bits++;
782  s->last_bits++;
783  if (s->pict_type == AV_PICTURE_TYPE_P) {
784  s->last_mv[0][0][0] =
785  s->last_mv[0][0][1] =
786  s->last_mv[0][1][0] =
787  s->last_mv[0][1][1] = 0;
788  }
789  } else {
790  if (first_mb) {
791  av_assert0(s->mb_skip_run == 0);
792  encode_mb_skip_run(s, s->mb_x);
793  } else {
795  }
796 
797  if (s->pict_type == AV_PICTURE_TYPE_I) {
798  if (s->dquant && cbp) {
799  /* macroblock_type: macroblock_quant = 1 */
800  put_mb_modes(s, 2, 1, 0, 0);
801  put_qscale(s);
802  } else {
803  /* macroblock_type: macroblock_quant = 0 */
804  put_mb_modes(s, 1, 1, 0, 0);
805  s->qscale -= s->dquant;
806  }
807  s->misc_bits += get_bits_diff(s);
808  s->i_count++;
809  } else if (s->mb_intra) {
810  if (s->dquant && cbp) {
811  put_mb_modes(s, 6, 0x01, 0, 0);
812  put_qscale(s);
813  } else {
814  put_mb_modes(s, 5, 0x03, 0, 0);
815  s->qscale -= s->dquant;
816  }
817  s->misc_bits += get_bits_diff(s);
818  s->i_count++;
819  memset(s->last_mv, 0, sizeof(s->last_mv));
820  } else if (s->pict_type == AV_PICTURE_TYPE_P) {
821  if (s->mv_type == MV_TYPE_16X16) {
822  if (cbp != 0) {
823  if ((motion_x | motion_y) == 0) {
824  if (s->dquant) {
825  /* macroblock_pattern & quant */
826  put_mb_modes(s, 5, 1, 0, 0);
827  put_qscale(s);
828  } else {
829  /* macroblock_pattern only */
830  put_mb_modes(s, 2, 1, 0, 0);
831  }
832  s->misc_bits += get_bits_diff(s);
833  } else {
834  if (s->dquant) {
835  put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */
836  put_qscale(s);
837  } else {
838  put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */
839  }
840  s->misc_bits += get_bits_diff(s);
841  // RAL: f_code parameter added
843  motion_x - s->last_mv[0][0][0],
844  s->f_code);
845  // RAL: f_code parameter added
847  motion_y - s->last_mv[0][0][1],
848  s->f_code);
849  s->mv_bits += get_bits_diff(s);
850  }
851  } else {
852  put_bits(&s->pb, 3, 1); /* motion only */
853  if (!s->frame_pred_frame_dct)
854  put_bits(&s->pb, 2, 2); /* motion_type: frame */
855  s->misc_bits += get_bits_diff(s);
856  // RAL: f_code parameter added
858  motion_x - s->last_mv[0][0][0],
859  s->f_code);
860  // RAL: f_code parameter added
862  motion_y - s->last_mv[0][0][1],
863  s->f_code);
864  s->qscale -= s->dquant;
865  s->mv_bits += get_bits_diff(s);
866  }
867  s->last_mv[0][1][0] = s->last_mv[0][0][0] = motion_x;
868  s->last_mv[0][1][1] = s->last_mv[0][0][1] = motion_y;
869  } else {
871 
872  if (cbp) {
873  if (s->dquant) {
874  put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
875  put_qscale(s);
876  } else {
877  put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
878  }
879  } else {
880  put_bits(&s->pb, 3, 1); /* motion only */
881  put_bits(&s->pb, 2, 1); /* motion_type: field */
882  s->qscale -= s->dquant;
883  }
884  s->misc_bits += get_bits_diff(s);
885  for (i = 0; i < 2; i++) {
886  put_bits(&s->pb, 1, s->field_select[0][i]);
888  s->mv[0][i][0] - s->last_mv[0][i][0],
889  s->f_code);
891  s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
892  s->f_code);
893  s->last_mv[0][i][0] = s->mv[0][i][0];
894  s->last_mv[0][i][1] = 2 * s->mv[0][i][1];
895  }
896  s->mv_bits += get_bits_diff(s);
897  }
898  if (cbp) {
899  if (s->chroma_y_shift) {
900  put_bits(&s->pb,
901  ff_mpeg12_mbPatTable[cbp][1],
902  ff_mpeg12_mbPatTable[cbp][0]);
903  } else {
904  put_bits(&s->pb,
905  ff_mpeg12_mbPatTable[cbp >> 2][1],
906  ff_mpeg12_mbPatTable[cbp >> 2][0]);
907  put_sbits(&s->pb, 2, cbp);
908  }
909  }
910  s->f_count++;
911  } else {
912  if (s->mv_type == MV_TYPE_16X16) {
913  if (cbp) { // With coded bloc pattern
914  if (s->dquant) {
915  if (s->mv_dir == MV_DIR_FORWARD)
916  put_mb_modes(s, 6, 3, 1, 0);
917  else
918  put_mb_modes(s, 8 - s->mv_dir, 2, 1, 0);
919  put_qscale(s);
920  } else {
921  put_mb_modes(s, 5 - s->mv_dir, 3, 1, 0);
922  }
923  } else { // No coded bloc pattern
924  put_bits(&s->pb, 5 - s->mv_dir, 2);
925  if (!s->frame_pred_frame_dct)
926  put_bits(&s->pb, 2, 2); /* motion_type: frame */
927  s->qscale -= s->dquant;
928  }
929  s->misc_bits += get_bits_diff(s);
930  if (s->mv_dir & MV_DIR_FORWARD) {
932  s->mv[0][0][0] - s->last_mv[0][0][0],
933  s->f_code);
935  s->mv[0][0][1] - s->last_mv[0][0][1],
936  s->f_code);
937  s->last_mv[0][0][0] =
938  s->last_mv[0][1][0] = s->mv[0][0][0];
939  s->last_mv[0][0][1] =
940  s->last_mv[0][1][1] = s->mv[0][0][1];
941  s->f_count++;
942  }
943  if (s->mv_dir & MV_DIR_BACKWARD) {
945  s->mv[1][0][0] - s->last_mv[1][0][0],
946  s->b_code);
948  s->mv[1][0][1] - s->last_mv[1][0][1],
949  s->b_code);
950  s->last_mv[1][0][0] =
951  s->last_mv[1][1][0] = s->mv[1][0][0];
952  s->last_mv[1][0][1] =
953  s->last_mv[1][1][1] = s->mv[1][0][1];
954  s->b_count++;
955  }
956  } else {
959  if (cbp) { // With coded bloc pattern
960  if (s->dquant) {
961  if (s->mv_dir == MV_DIR_FORWARD)
962  put_mb_modes(s, 6, 3, 1, 1);
963  else
964  put_mb_modes(s, 8 - s->mv_dir, 2, 1, 1);
965  put_qscale(s);
966  } else {
967  put_mb_modes(s, 5 - s->mv_dir, 3, 1, 1);
968  }
969  } else { // No coded bloc pattern
970  put_bits(&s->pb, 5 - s->mv_dir, 2);
971  put_bits(&s->pb, 2, 1); /* motion_type: field */
972  s->qscale -= s->dquant;
973  }
974  s->misc_bits += get_bits_diff(s);
975  if (s->mv_dir & MV_DIR_FORWARD) {
976  for (i = 0; i < 2; i++) {
977  put_bits(&s->pb, 1, s->field_select[0][i]);
979  s->mv[0][i][0] - s->last_mv[0][i][0],
980  s->f_code);
982  s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
983  s->f_code);
984  s->last_mv[0][i][0] = s->mv[0][i][0];
985  s->last_mv[0][i][1] = s->mv[0][i][1] * 2;
986  }
987  s->f_count++;
988  }
989  if (s->mv_dir & MV_DIR_BACKWARD) {
990  for (i = 0; i < 2; i++) {
991  put_bits(&s->pb, 1, s->field_select[1][i]);
993  s->mv[1][i][0] - s->last_mv[1][i][0],
994  s->b_code);
996  s->mv[1][i][1] - (s->last_mv[1][i][1] >> 1),
997  s->b_code);
998  s->last_mv[1][i][0] = s->mv[1][i][0];
999  s->last_mv[1][i][1] = s->mv[1][i][1] * 2;
1000  }
1001  s->b_count++;
1002  }
1003  }
1004  s->mv_bits += get_bits_diff(s);
1005  if (cbp) {
1006  if (s->chroma_y_shift) {
1007  put_bits(&s->pb,
1008  ff_mpeg12_mbPatTable[cbp][1],
1009  ff_mpeg12_mbPatTable[cbp][0]);
1010  } else {
1011  put_bits(&s->pb,
1012  ff_mpeg12_mbPatTable[cbp >> 2][1],
1013  ff_mpeg12_mbPatTable[cbp >> 2][0]);
1014  put_sbits(&s->pb, 2, cbp);
1015  }
1016  }
1017  }
1018  for (i = 0; i < mb_block_count; i++)
1019  if (cbp & (1 << (mb_block_count - 1 - i)))
1020  mpeg1_encode_block(s, block[i], i);
1021  s->mb_skip_run = 0;
1022  if (s->mb_intra)
1023  s->i_tex_bits += get_bits_diff(s);
1024  else
1025  s->p_tex_bits += get_bits_diff(s);
1026  }
1027 }
1028 
1030  int motion_x, int motion_y)
1031 {
1032  if (s->chroma_format == CHROMA_420)
1033  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6);
1034  else
1035  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8);
1036 }
1037 
1039 {
1042 
1043  for (int i = 0; i < 64; i++) {
1046  }
1047 
1050 
1051  /* build unified dc encoding tables */
1052  for (int i = -255; i < 256; i++) {
1053  int adiff, index;
1054  int bits, code;
1055  int diff = i;
1056 
1057  adiff = FFABS(diff);
1058  if (diff < 0)
1059  diff--;
1060  index = av_log2(2 * adiff);
1061 
1063  code = (ff_mpeg12_vlc_dc_lum_code[index] << index) +
1064  av_mod_uintp2(diff, index);
1065  mpeg1_lum_dc_uni[i + 255] = bits + (code << 8);
1066 
1069  av_mod_uintp2(diff, index);
1070  mpeg1_chr_dc_uni[i + 255] = bits + (code << 8);
1071  }
1072 
1073  for (int f_code = 1; f_code <= MAX_FCODE; f_code++)
1074  for (int mv = -MAX_DMV; mv <= MAX_DMV; mv++) {
1075  int len;
1076 
1077  if (mv == 0) {
1078  len = ff_mpeg12_mbMotionVectorTable[0][1];
1079  } else {
1080  int val, bit_size, code;
1081 
1082  bit_size = f_code - 1;
1083 
1084  val = mv;
1085  if (val < 0)
1086  val = -val;
1087  val--;
1088  code = (val >> bit_size) + 1;
1089  if (code < 17)
1091  1 + bit_size;
1092  else
1093  len = ff_mpeg12_mbMotionVectorTable[16][1] +
1094  2 + bit_size;
1095  }
1096 
1097  mv_penalty[f_code][mv + MAX_DMV] = len;
1098  }
1099 
1100 
1101  for (int f_code = MAX_FCODE; f_code > 0; f_code--)
1102  for (int mv = -(8 << f_code); mv < (8 << f_code); mv++)
1103  fcode_tab[mv + MAX_MV] = f_code;
1104 }
1105 
1107 {
1108  static AVOnce init_static_once = AV_ONCE_INIT;
1109 
1111 
1112  s->me.mv_penalty = mv_penalty;
1113  s->fcode_tab = fcode_tab;
1114  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1115  s->min_qcoeff = -255;
1116  s->max_qcoeff = 255;
1117  } else {
1118  s->min_qcoeff = -2047;
1119  s->max_qcoeff = 2047;
1120  }
1121  if (s->intra_vlc_format) {
1122  s->intra_ac_vlc_length =
1124  } else {
1125  s->intra_ac_vlc_length =
1127  }
1128  s->inter_ac_vlc_length =
1130 
1131  ff_thread_once(&init_static_once, mpeg12_encode_init_static);
1132 }
1133 
1134 #define OFFSET(x) offsetof(MpegEncContext, x)
1135 #define VE AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
1136 #define COMMON_OPTS \
1137  { "gop_timecode", "MPEG GOP Timecode in hh:mm:ss[:;.]ff format. Overrides timecode_frame_start.", \
1138  OFFSET(tc_opt_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE },\
1139  { "intra_vlc", "Use MPEG-2 intra VLC table.", \
1140  OFFSET(intra_vlc_format), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1141  { "drop_frame_timecode", "Timecode is in drop frame format.", \
1142  OFFSET(drop_frame_timecode), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1143  { "scan_offset", "Reserve space for SVCD scan offset user data.", \
1144  OFFSET(scan_offset), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1145  { "timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", \
1146  OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = -1 }, -1, INT64_MAX, VE}, \
1147 
1148 static const AVOption mpeg1_options[] = {
1149  COMMON_OPTS
1151  { NULL },
1152 };
1153 
1154 static const AVOption mpeg2_options[] = {
1155  COMMON_OPTS
1156  { "non_linear_quant", "Use nonlinear quantizer.", OFFSET(q_scale_type), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1157  { "alternate_scan", "Enable alternate scantable.", OFFSET(alternate_scan), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1158  { "seq_disp_ext", "Write sequence_display_extension blocks.", OFFSET(seq_disp_ext), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "seq_disp_ext" },
1159  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, VE, "seq_disp_ext" },
1160  { "never", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, VE, "seq_disp_ext" },
1161  { "always", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, VE, "seq_disp_ext" },
1162  { "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" },
1163  { "component", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_COMPONENT }, 0, 0, VE, "video_format" },
1164  { "pal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_PAL }, 0, 0, VE, "video_format" },
1165  { "ntsc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_NTSC }, 0, 0, VE, "video_format" },
1166  { "secam", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_SECAM }, 0, 0, VE, "video_format" },
1167  { "mac", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_MAC }, 0, 0, VE, "video_format" },
1168  { "unspecified", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_UNSPECIFIED}, 0, 0, VE, "video_format" },
1169 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, { .i64 = value }, 0, 0, VE, "avctx.level"
1170  { LEVEL("high", 4) },
1171  { LEVEL("high1440", 6) },
1172  { LEVEL("main", 8) },
1173  { LEVEL("low", 10) },
1174 #undef LEVEL
1177  { NULL },
1178 };
1179 
1180 #define mpeg12_class(x) \
1181 static const AVClass mpeg ## x ## _class = { \
1182  .class_name = "mpeg" # x "video encoder", \
1183  .item_name = av_default_item_name, \
1184  .option = mpeg ## x ## _options, \
1185  .version = LIBAVUTIL_VERSION_INT, \
1186 };
1187 
1189 mpeg12_class(2)
1190 
1192  .name = "mpeg1video",
1193  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
1194  .type = AVMEDIA_TYPE_VIDEO,
1195  .id = AV_CODEC_ID_MPEG1VIDEO,
1196  .priv_data_size = sizeof(MpegEncContext),
1197  .init = encode_init,
1198  .encode2 = ff_mpv_encode_picture,
1199  .close = ff_mpv_encode_end,
1200  .supported_framerates = ff_mpeg12_frame_rate_tab + 1,
1201  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
1202  AV_PIX_FMT_NONE },
1204  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1205  .priv_class = &mpeg1_class,
1206 };
1207 
1209  .name = "mpeg2video",
1210  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
1211  .type = AVMEDIA_TYPE_VIDEO,
1212  .id = AV_CODEC_ID_MPEG2VIDEO,
1213  .priv_data_size = sizeof(MpegEncContext),
1214  .init = encode_init,
1215  .encode2 = ff_mpv_encode_picture,
1216  .close = ff_mpv_encode_end,
1217  .supported_framerates = ff_mpeg2_frame_rate_tab,
1218  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
1220  AV_PIX_FMT_NONE },
1222  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1223  .priv_class = &mpeg2_class,
1224 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1599
av_cold void ff_mpeg1_encode_init(MpegEncContext *s)
Definition: mpeg12enc.c:1106
static uint8_t uni_mpeg1_ac_vlc_len[64 *64 *2]
Definition: mpeg12enc.c:55
#define MASK_ABS(mask, level)
Definition: mathops.h:155
#define NULL
Definition: coverity.c:32
AVCodec ff_mpeg2video_encoder
Definition: mpeg12enc.c:1208
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
AVOption.
Definition: opt.h:248
uint8_t * fcode_tab
smallest fcode needed for each MV
Definition: mpegvideo.h:279
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:269
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG-1 & B-frame MPEG-4
Definition: mpegvideo.h:278
static int find_frame_rate_index(MpegEncContext *s)
Definition: mpeg12enc.c:103
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
#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.
#define LEVEL(name, value)
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:204
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
uint8_t(* mv_penalty)[MAX_DMV *2+1]
bit amount needed to encode a MV
Definition: motion_est.h:93
int qscale
QP.
Definition: mpegvideo.h:204
RLTable.
Definition: rl.h:39
int field_select[2][2]
Definition: mpegvideo.h:277
Macro definitions for various function/variable attributes.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:654
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:738
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1995
#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
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:232
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
static uint32_t mpeg1_lum_dc_uni[512]
Definition: mpeg12enc.c:60
AVOptions.
static void encode_mb_skip_run(MpegEncContext *s, int run)
Definition: mpeg12enc.c:398
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
static const AVOption mpeg1_options[]
Definition: mpeg12enc.c:1148
static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12enc.c:672
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
static int8_t mpeg1_max_level[2][64]
Definition: mpeg12enc.c:64
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
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 FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1598
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:758
int intra_only
if true, only intra pictures are generated
Definition: mpegvideo.h:102
#define MAX_DMV
Definition: motion_est.h:37
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:185
static void put_mb_modes(MpegEncContext *s, int n, int bits, int has_mv, int field_motion)
Definition: mpeg12enc.c:586
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
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
#define VIDEO_FORMAT_MAC
Definition: mpegvideo.h:481
const uint16_t ff_mpeg12_vlc_dc_chroma_code[12]
Definition: mpeg12data.c:59
static void encode_dc(MpegEncContext *s, int diff, int component)
Definition: mpeg12enc.c:638
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:202
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 void mpeg1_encode_sequence_header(MpegEncContext *s)
Definition: mpeg12enc.c:243
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
Definition: mpeg12enc.c:599
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
#define mpeg12_class(x)
Definition: mpeg12enc.c:1180
int intra_vlc_format
Definition: mpegvideo.h:473
#define FF_PROFILE_MPEG2_HIGH
Definition: avcodec.h:1901
int progressive_frame
Definition: mpegvideo.h:492
static av_cold void mpeg12_encode_init_static(void)
Definition: mpeg12enc.c:1038
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
static uint8_t fcode_tab[MAX_MV *2+1]
Definition: mpeg12enc.c:53
#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
static uint8_t uni_mpeg2_ac_vlc_len[64 *64 *2]
Definition: mpeg12enc.c:56
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int level
level
Definition: avcodec.h:1994
#define VE
Definition: mpeg12enc.c:1135
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:86
MotionEstContext me
Definition: mpegvideo.h:282
#define EXT_START_CODE
Definition: cavs.h:33
static av_cold void init_uni_ac_vlc(RLTable *rl, uint8_t *uni_ac_vlc_len)
Definition: mpeg12enc.c:68
static void put_header(MpegEncContext *s, int header)
Definition: mpeg12enc.c:235
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
if(ret)
static const uint8_t svcd_scan_offset_placeholder[]
Definition: mpeg12enc.c:47
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:110
static const int8_t mv[256][2]
Definition: 4xm.c:77
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
int frame_pred_frame_dct
Definition: mpegvideo.h: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 A53_MAX_CC_COUNT
Definition: mpeg12enc.c:66
#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:34
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:100
MPEG-1/2 tables.
static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s, int16_t block[8][64], int motion_x, int motion_y, int mb_block_count)
Definition: mpeg12enc.c:751
uint8_t * data
Definition: frame.h:222
av_cold int ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:39
int ff_mpv_encode_init(AVCodecContext *avctx)
uint8_t * inter_ac_vlc_length
Definition: mpegvideo.h:315
static uint8_t mpeg1_index_run[2][64]
Definition: mpeg12enc.c:63
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
static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
Definition: mpeg12enc.c:52
#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
#define COMMON_OPTS
Definition: mpeg12enc.c:1136
uint8_t * index_run[2]
encoding only
Definition: rl.h:45
#define OFFSET(x)
Definition: mpeg12enc.c:1134
void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: mpeg12enc.c:427
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:300
av_cold void ff_mpeg12_common_init(MpegEncContext *s)
Definition: mpeg12.c:107
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
int last_mv_dir
last mv_dir, used for B-frame encoding
Definition: mpegvideo.h:455
void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64], int motion_x, int motion_y)
Definition: mpeg12enc.c:1029
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:205
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
Definition: mpegvideo.h:276
static av_cold int encode_init(AVCodecContext *avctx)
Definition: mpeg12enc.c:142
MpegEncContext.
Definition: mpegvideo.h:81
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
PutBitContext pb
bit output
Definition: mpegvideo.h:151
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
const AVRational ff_mpeg2_aspect[16]
Definition: mpeg12data.c:395
static av_always_inline void put_qscale(MpegEncContext *s)
Definition: mpeg12enc.c:408
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
static uint32_t mpeg1_chr_dc_uni[512]
Definition: mpeg12enc.c:61
static const AVOption mpeg2_options[]
Definition: mpeg12enc.c:1154
uint8_t ff_mpeg12_static_rl_table_store[2][2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: mpeg12.c:44
int av_nearer_q(AVRational q, AVRational q1, AVRational q2)
Find which of the two rationals is closer to another rational.
Definition: rational.c:127
Bi-dir predicted.
Definition: avutil.h:276
Stereoscopic video.
const uint8_t ff_mpeg12_mbPatTable[64][2]
Definition: mpeg12data.c:221
int den
Denominator.
Definition: rational.h:60
int ff_mpv_encode_end(AVCodecContext *avctx)
void * priv_data
Definition: avcodec.h:558
void ff_mpeg1_encode_slice_header(MpegEncContext *s)
Definition: mpeg12enc.c:413
#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:85
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[]