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 <assert.h>
29 #include <stdint.h>
30 
31 #include "config.h"
32 #include "config_components.h"
33 #include "libavutil/attributes.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/log.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/thread.h"
38 #include "libavutil/timecode.h"
39 #include "libavutil/stereo3d.h"
40 
41 #include "avcodec.h"
42 #include "codec_internal.h"
43 #include "mathops.h"
44 #include "mpeg12.h"
45 #include "mpeg12data.h"
46 #include "mpeg12enc.h"
47 #include "mpeg12vlc.h"
48 #include "mpegutils.h"
49 #include "mpegvideo.h"
50 #include "mpegvideoenc.h"
51 #include "profiles.h"
52 #include "put_bits.h"
53 #include "rl.h"
54 
55 #if CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER
56 static const uint8_t svcd_scan_offset_placeholder[] = {
57  0x10, 0x0E, 0x00, 0x80, 0x81, 0x00, 0x80,
58  0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
59 };
60 
61 static uint8_t mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
62 static uint8_t fcode_tab[MAX_MV * 2 + 1];
63 
64 static uint8_t uni_mpeg1_ac_vlc_len[64 * 64 * 2];
65 static uint8_t uni_mpeg2_ac_vlc_len[64 * 64 * 2];
66 
67 static uint8_t mpeg12_max_level[MAX_LEVEL + 1];
68 static uint8_t mpeg12_index_run[MAX_RUN + 1];
69 
70 /* simple include everything table for dc, first byte is bits
71  * number next 3 are code */
72 static uint32_t mpeg1_lum_dc_uni[512];
73 static uint32_t mpeg1_chr_dc_uni[512];
74 
75 typedef struct MPEG12EncContext {
76  MPVMainEncContext mpeg;
77  AVRational frame_rate_ext;
78  unsigned frame_rate_index;
79 
80  int gop_picture_number; ///< index of the first picture of a GOP based on fake_pic_num
81 
82  int64_t timecode_frame_start; ///< GOP timecode frame start number, in non drop frame format
83  AVTimecode tc; ///< timecode context
84  char *tc_opt_str; ///< timecode option string
85  int drop_frame_timecode; ///< timecode is in drop frame format.
86  int scan_offset; ///< reserve space for SVCD scan offset user data.
87 
88  int a53_cc;
89  int seq_disp_ext;
90  int video_format;
91 #define VIDEO_FORMAT_COMPONENT 0
92 #define VIDEO_FORMAT_PAL 1
93 #define VIDEO_FORMAT_NTSC 2
94 #define VIDEO_FORMAT_SECAM 3
95 #define VIDEO_FORMAT_MAC 4
96 #define VIDEO_FORMAT_UNSPECIFIED 5
97 } MPEG12EncContext;
98 
99 #define A53_MAX_CC_COUNT 0x1f
100 #endif /* CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER */
101 
102 av_cold void ff_mpeg1_init_uni_ac_vlc(const int8_t max_level[],
103  const uint8_t index_run[],
104  const uint16_t table_vlc[][2],
105  uint8_t uni_ac_vlc_len[])
106 {
107  int i;
108 
109  for (i = 0; i < 128; i++) {
110  int level = i - 64;
111  int run;
112  if (!level)
113  continue;
114  for (run = 0; run < 64; run++) {
115  int len, code;
116  int alevel = FFABS(level);
117 
118  if (alevel > max_level[run])
119  code = 111; /* rl->n */
120  else
121  code = index_run[run] + alevel - 1;
122 
123  if (code < 111) { /* rl->n */
124  /* length of VLC and sign */
125  len = table_vlc[code][1] + 1;
126  } else {
127  len = table_vlc[MPEG12_RL_NB_ELEMS][1] + 6;
128 
129  if (alevel < 128)
130  len += 8;
131  else
132  len += 16;
133  }
134 
135  uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
136  }
137  }
138 }
139 
140 #if CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER
141 static void put_header(MPVEncContext *const s, uint32_t header)
142 {
143  align_put_bits(&s->pb);
144  put_bits32(&s->pb, header);
145 }
146 
147 /* put sequence header if needed */
148 static void mpeg1_encode_sequence_header(MPEG12EncContext *mpeg12)
149 {
150  MPVEncContext *const s = &mpeg12->mpeg.s;
151  unsigned int vbv_buffer_size, fps, v;
152  int constraint_parameter_flag;
153  AVRational framerate = ff_mpeg12_frame_rate_tab[mpeg12->frame_rate_index];
154  uint64_t time_code;
155  int64_t best_aspect_error = INT64_MAX;
156  AVRational aspect_ratio = s->c.avctx->sample_aspect_ratio;
157  int aspect_ratio_info;
158 
160 
161  if (!(s->c.cur_pic.ptr->f->flags & AV_FRAME_FLAG_KEY))
162  return;
163 
164  if (aspect_ratio.num == 0 || aspect_ratio.den == 0)
165  aspect_ratio = (AVRational){1,1}; // pixel aspect 1.1 (VGA)
166 
167  /* MPEG-1 header repeated every GOP */
169 
170  put_sbits(&s->pb, 12, s->c.width & 0xFFF);
171  put_sbits(&s->pb, 12, s->c.height & 0xFFF);
172 
173  for (int i = 1; i < 15; i++) {
174  int64_t error = aspect_ratio.num * (1LL<<32) / aspect_ratio.den;
175  if (s->c.codec_id == AV_CODEC_ID_MPEG1VIDEO || i <= 1)
176  error -= (1LL<<32) / ff_mpeg1_aspect[i];
177  else
178  error -= (1LL<<32)*ff_mpeg2_aspect[i].num * s->c.height / s->c.width / ff_mpeg2_aspect[i].den;
179 
180  error = FFABS(error);
181 
182  if (error - 2 <= best_aspect_error) {
183  best_aspect_error = error;
184  aspect_ratio_info = i;
185  }
186  }
187 
188  put_bits(&s->pb, 4, aspect_ratio_info);
189  put_bits(&s->pb, 4, mpeg12->frame_rate_index);
190 
191  if (s->c.avctx->rc_max_rate) {
192  v = (s->c.avctx->rc_max_rate + 399) / 400;
193  if (v > 0x3ffff && s->c.codec_id == AV_CODEC_ID_MPEG1VIDEO)
194  v = 0x3ffff;
195  } else {
196  v = 0x3FFFF;
197  }
198 
199  if (s->c.avctx->rc_buffer_size)
200  vbv_buffer_size = s->c.avctx->rc_buffer_size;
201  else
202  /* VBV calculation: Scaled so that a VCD has the proper
203  * VBV size of 40 kilobytes */
204  vbv_buffer_size = av_rescale_rnd(mpeg12->mpeg.bit_rate, 20, 1151929 / 2, AV_ROUND_ZERO) * 8 * 1024;
205  vbv_buffer_size = (vbv_buffer_size + 16383) / 16384;
206 
207  put_sbits(&s->pb, 18, v);
208  put_bits(&s->pb, 1, 1); // marker
209  put_sbits(&s->pb, 10, vbv_buffer_size);
210 
211  constraint_parameter_flag =
212  s->c.width <= 768 &&
213  s->c.height <= 576 &&
214  s->c.mb_width * s->c.mb_height <= 396 &&
215  s->c.mb_width * s->c.mb_height * framerate.num <= 396 * 25 * framerate.den &&
216  framerate.num <= framerate.den * 30 &&
217  s->c.avctx->me_range &&
218  s->c.avctx->me_range < 128 &&
219  vbv_buffer_size <= 20 &&
220  v <= 1856000 / 400 &&
221  s->c.codec_id == AV_CODEC_ID_MPEG1VIDEO;
222 
223  put_bits(&s->pb, 1, constraint_parameter_flag);
224 
225  ff_write_quant_matrix(&s->pb, s->c.avctx->intra_matrix);
226  ff_write_quant_matrix(&s->pb, s->c.avctx->inter_matrix);
227 
228  if (s->c.codec_id == AV_CODEC_ID_MPEG2VIDEO) {
229  const AVFrameSideData *side_data;
230  int width = s->c.width;
231  int height = s->c.height;
232  int use_seq_disp_ext;
233 
235  put_bits(&s->pb, 4, 1); // seq ext
236 
237  put_bits(&s->pb, 1, s->c.avctx->profile == AV_PROFILE_MPEG2_422); // escx 1 for 4:2:2 profile
238 
239  put_bits(&s->pb, 3, s->c.avctx->profile); // profile
240  put_bits(&s->pb, 4, s->c.avctx->level); // level
241 
242  put_bits(&s->pb, 1, s->c.progressive_sequence);
243  put_bits(&s->pb, 2, s->c.chroma_format);
244  put_bits(&s->pb, 2, s->c.width >> 12);
245  put_bits(&s->pb, 2, s->c.height >> 12);
246  put_bits(&s->pb, 12, v >> 18); // bitrate ext
247  put_bits(&s->pb, 1, 1); // marker
248  put_bits(&s->pb, 8, vbv_buffer_size >> 10); // vbv buffer ext
249  put_bits(&s->pb, 1, s->c.low_delay);
250  put_bits(&s->pb, 2, mpeg12->frame_rate_ext.num-1); // frame_rate_ext_n
251  put_bits(&s->pb, 5, mpeg12->frame_rate_ext.den-1); // frame_rate_ext_d
252 
253  side_data = av_frame_get_side_data(s->c.cur_pic.ptr->f, AV_FRAME_DATA_PANSCAN);
254  if (side_data) {
255  const AVPanScan *pan_scan = (AVPanScan *)side_data->data;
256  if (pan_scan->width && pan_scan->height) {
257  width = pan_scan->width >> 4;
258  height = pan_scan->height >> 4;
259  }
260  }
261 
262  use_seq_disp_ext = (width != s->c.width ||
263  height != s->c.height ||
264  s->c.avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
265  s->c.avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
266  s->c.avctx->colorspace != AVCOL_SPC_UNSPECIFIED ||
267  mpeg12->video_format != VIDEO_FORMAT_UNSPECIFIED);
268 
269  if (mpeg12->seq_disp_ext == 1 ||
270  (mpeg12->seq_disp_ext == -1 && use_seq_disp_ext)) {
272  put_bits(&s->pb, 4, 2); // sequence display extension
273  put_bits(&s->pb, 3, mpeg12->video_format); // video_format
274  put_bits(&s->pb, 1, 1); // colour_description
275  put_bits(&s->pb, 8, s->c.avctx->color_primaries); // colour_primaries
276  put_bits(&s->pb, 8, s->c.avctx->color_trc); // transfer_characteristics
277  put_bits(&s->pb, 8, s->c.avctx->colorspace); // matrix_coefficients
278  put_bits(&s->pb, 14, width); // display_horizontal_size
279  put_bits(&s->pb, 1, 1); // marker_bit
280  put_bits(&s->pb, 14, height); // display_vertical_size
281  put_bits(&s->pb, 3, 0); // remaining 3 bits are zero padding
282  }
283  }
284 
286  put_bits(&s->pb, 1, mpeg12->drop_frame_timecode); // drop frame flag
287  /* time code: we must convert from the real frame rate to a
288  * fake MPEG frame rate in case of low frame rate */
289  fps = (framerate.num + framerate.den / 2) / framerate.den;
290  time_code = s->c.cur_pic.ptr->coded_picture_number +
291  mpeg12->timecode_frame_start;
292 
293  mpeg12->gop_picture_number = s->c.cur_pic.ptr->coded_picture_number;
294 
295  av_assert0(mpeg12->drop_frame_timecode == !!(mpeg12->tc.flags & AV_TIMECODE_FLAG_DROPFRAME));
296  if (mpeg12->drop_frame_timecode)
297  time_code = av_timecode_adjust_ntsc_framenum2(time_code, fps);
298 
299  put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
300  put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
301  put_bits(&s->pb, 1, 1);
302  put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
303  put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
304  put_bits(&s->pb, 1, !!(s->c.avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) ||
305  mpeg12->mpeg.intra_only || !mpeg12->gop_picture_number);
306  put_bits(&s->pb, 1, 0); // broken link
307 }
308 
309 static inline void encode_mb_skip_run(MPVEncContext *const s, int run)
310 {
311  while (run >= 33) {
312  put_bits(&s->pb, 11, 0x008);
313  run -= 33;
314  }
317 }
318 
319 static av_always_inline void put_qscale(MPVEncContext *const s)
320 {
321  put_bits(&s->pb, 5, s->c.qscale);
322 }
323 
325 {
326  if (s->c.codec_id == AV_CODEC_ID_MPEG2VIDEO && s->c.height > 2800) {
327  put_header(s, SLICE_MIN_START_CODE + (s->c.mb_y & 127));
328  /* slice_vertical_position_extension */
329  put_bits(&s->pb, 3, s->c.mb_y >> 7);
330  } else {
332  put_header(s, SLICE_MIN_START_CODE + s->c.mb_y);
333  }
334  put_qscale(s);
335  /* slice extra information */
336  put_bits(&s->pb, 1, 0);
337 }
338 
339 static int mpeg1_encode_picture_header(MPVMainEncContext *const m)
340 {
341  MPEG12EncContext *const mpeg12 = (MPEG12EncContext*)m;
342  MPVEncContext *const s = &m->s;
343  const AVFrameSideData *side_data;
344 
346 
347  mpeg1_encode_sequence_header(mpeg12);
348 
349  /* MPEG-1 picture header */
351  /* temporal reference */
352 
353  // RAL: s->c.picture_number instead of s->fake_picture_number
354  put_bits(&s->pb, 10,
355  (s->c.picture_number - mpeg12->gop_picture_number) & 0x3ff);
356  put_bits(&s->pb, 3, s->c.pict_type);
357 
358  m->vbv_delay_pos = put_bytes_count(&s->pb, 0);
359  put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
360 
361  // RAL: Forward f_code also needed for B-frames
362  if (s->c.pict_type == AV_PICTURE_TYPE_P ||
363  s->c.pict_type == AV_PICTURE_TYPE_B) {
364  put_bits(&s->pb, 1, 0); /* half pel coordinates */
365  if (s->c.codec_id == AV_CODEC_ID_MPEG1VIDEO)
366  put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
367  else
368  put_bits(&s->pb, 3, 7); /* forward_f_code */
369  }
370 
371  // RAL: Backward f_code necessary for B-frames
372  if (s->c.pict_type == AV_PICTURE_TYPE_B) {
373  put_bits(&s->pb, 1, 0); /* half pel coordinates */
374  if (s->c.codec_id == AV_CODEC_ID_MPEG1VIDEO)
375  put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
376  else
377  put_bits(&s->pb, 3, 7); /* backward_f_code */
378  }
379 
380  put_bits(&s->pb, 1, 0); /* extra bit picture */
381 
382  s->c.frame_pred_frame_dct = 1;
383  if (s->c.codec_id == AV_CODEC_ID_MPEG2VIDEO) {
385  put_bits(&s->pb, 4, 8); /* pic ext */
386  if (s->c.pict_type == AV_PICTURE_TYPE_P ||
387  s->c.pict_type == AV_PICTURE_TYPE_B) {
388  put_bits(&s->pb, 4, s->f_code);
389  put_bits(&s->pb, 4, s->f_code);
390  } else {
391  put_bits(&s->pb, 8, 255);
392  }
393  if (s->c.pict_type == AV_PICTURE_TYPE_B) {
394  put_bits(&s->pb, 4, s->b_code);
395  put_bits(&s->pb, 4, s->b_code);
396  } else {
397  put_bits(&s->pb, 8, 255);
398  }
399  put_bits(&s->pb, 2, s->c.intra_dc_precision);
400 
401  av_assert0(s->c.picture_structure == PICT_FRAME);
402  put_bits(&s->pb, 2, s->c.picture_structure);
403  if (s->c.progressive_sequence)
404  put_bits(&s->pb, 1, 0); /* no repeat */
405  else
406  put_bits(&s->pb, 1, !!(s->c.cur_pic.ptr->f->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST));
407  /* XXX: optimize the generation of this flag with entropy measures */
408  s->c.frame_pred_frame_dct = s->c.progressive_sequence;
409 
410  put_bits(&s->pb, 1, s->c.frame_pred_frame_dct);
411  put_bits(&s->pb, 1, s->c.concealment_motion_vectors);
412  put_bits(&s->pb, 1, s->c.q_scale_type);
413  put_bits(&s->pb, 1, s->c.intra_vlc_format);
414  put_bits(&s->pb, 1, s->c.alternate_scan);
415  put_bits(&s->pb, 1, s->c.repeat_first_field);
416  s->c.progressive_frame = s->c.progressive_sequence;
417  /* chroma_420_type */
418  put_bits(&s->pb, 1, s->c.chroma_format ==
419  CHROMA_420 ? s->c.progressive_frame : 0);
420  put_bits(&s->pb, 1, s->c.progressive_frame);
421  put_bits(&s->pb, 1, 0); /* composite_display_flag */
422  }
423  if (mpeg12->scan_offset) {
424  int i;
425 
427  for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
428  put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
429  }
430  side_data = av_frame_get_side_data(s->c.cur_pic.ptr->f,
432  if (side_data) {
433  const AVStereo3D *stereo = (AVStereo3D *)side_data->data;
434  uint8_t fpa_type;
435 
436  switch (stereo->type) {
438  fpa_type = 0x03;
439  break;
441  fpa_type = 0x04;
442  break;
443  case AV_STEREO3D_2D:
444  fpa_type = 0x08;
445  break;
447  fpa_type = 0x23;
448  break;
449  default:
450  fpa_type = 0;
451  break;
452  }
453 
454  if (fpa_type != 0) {
456  // S3D_video_format_signaling_identifier
457  put_bits32(&s->pb, MKBETAG('J','P','3','D'));
458  put_bits(&s->pb, 8, 0x03); // S3D_video_format_length
459 
460  put_bits(&s->pb, 1, 1); // reserved_bit
461  put_bits(&s->pb, 7, fpa_type); // S3D_video_format_type
462  put_bits(&s->pb, 16, 0x04FF); // reserved_data
463  }
464  }
465 
466  if (CONFIG_MPEG2VIDEO_ENCODER && mpeg12->a53_cc) {
467  side_data = av_frame_get_side_data(s->c.cur_pic.ptr->f,
469  if (side_data) {
470  if (side_data->size <= A53_MAX_CC_COUNT * 3 && side_data->size % 3 == 0) {
472 
473  put_bits32(&s->pb, MKBETAG('G','A','9','4')); // user_identifier
474  put_bits(&s->pb, 8, 3); // user_data_type_code
475  put_bits(&s->pb, 8,
476  (side_data->size / 3 & A53_MAX_CC_COUNT) | 0x40); // flags, cc_count
477  put_bits(&s->pb, 8, 0xff); // em_data
478 
479  for (int i = 0; i < side_data->size; i++)
480  put_bits(&s->pb, 8, side_data->data[i]);
481 
482  put_bits(&s->pb, 8, 0xff); // marker_bits
483  } else {
484  av_log(s->c.avctx, AV_LOG_WARNING,
485  "Closed Caption size (%"SIZE_SPECIFIER") can not exceed "
486  "93 bytes and must be a multiple of 3\n", side_data->size);
487  }
488  }
489  }
490 
491  s->c.mb_y = 0;
493 
494  return 0;
495 }
496 
497 static inline void put_mb_modes(MPVEncContext *const s, int n, int bits,
498  int has_mv, int field_motion)
499 {
500  put_bits(&s->pb, n, bits);
501  if (!s->c.frame_pred_frame_dct) {
502  if (has_mv)
503  /* motion_type: frame/field */
504  put_bits(&s->pb, 2, 2 - field_motion);
505  put_bits(&s->pb, 1, s->c.interlaced_dct);
506  }
507 }
508 
509 // RAL: Parameter added: f_or_b_code
510 static void mpeg1_encode_motion(MPVEncContext *const s, int val, int f_or_b_code)
511 {
512  if (val == 0) {
513  /* zero vector, corresponds to ff_mpeg12_mbMotionVectorTable[0] */
514  put_bits(&s->pb, 1, 0x01);
515  } else {
516  int code, sign, bits;
517  int bit_size = f_or_b_code - 1;
518  int range = 1 << bit_size;
519  /* modulo encoding */
520  val = sign_extend(val, 5 + bit_size);
521 
522  if (val >= 0) {
523  val--;
524  code = (val >> bit_size) + 1;
525  bits = val & (range - 1);
526  sign = 0;
527  } else {
528  val = -val;
529  val--;
530  code = (val >> bit_size) + 1;
531  bits = val & (range - 1);
532  sign = 1;
533  }
534 
535  av_assert2(code > 0 && code <= 16);
536 
537  put_bits(&s->pb,
540 
541  put_bits(&s->pb, 1, sign);
542  if (bit_size > 0)
543  put_bits(&s->pb, bit_size, bits);
544  }
545 }
546 
547 static inline void encode_dc(MPVEncContext *const s, int diff, int component)
548 {
549  unsigned int diff_u = diff + 255;
550  if (diff_u >= 511) {
551  int index;
552 
553  if (diff < 0) {
554  index = av_log2_16bit(-2 * diff);
555  diff--;
556  } else {
557  index = av_log2_16bit(2 * diff);
558  }
559  if (component == 0)
560  put_bits(&s->pb,
564  else
565  put_bits(&s->pb,
569  } else {
570  if (component == 0)
571  put_bits(&s->pb,
572  mpeg1_lum_dc_uni[diff + 255] & 0xFF,
573  mpeg1_lum_dc_uni[diff + 255] >> 8);
574  else
575  put_bits(&s->pb,
576  mpeg1_chr_dc_uni[diff + 255] & 0xFF,
577  mpeg1_chr_dc_uni[diff + 255] >> 8);
578  }
579 }
580 
581 static void mpeg1_encode_block(MPVEncContext *const s, const int16_t block[], int n)
582 {
583  int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
584  int code, component;
585  const uint16_t (*table_vlc)[2] = ff_mpeg1_vlc_table;
586 
587  last_index = s->c.block_last_index[n];
588 
589  /* DC coef */
590  if (s->c.mb_intra) {
591  component = (n <= 3 ? 0 : (n & 1) + 1);
592  dc = block[0]; /* overflow is impossible */
593  diff = dc - s->c.last_dc[component];
594  encode_dc(s, diff, component);
595  s->c.last_dc[component] = dc;
596  i = 1;
597  if (s->c.intra_vlc_format)
598  table_vlc = ff_mpeg2_vlc_table;
599  } else {
600  /* encode the first coefficient: needs to be done here because
601  * it is handled slightly differently */
602  level = block[0];
603  if (abs(level) == 1) {
604  code = ((uint32_t)level >> 31); /* the sign bit */
605  put_bits(&s->pb, 2, code | 0x02);
606  i = 1;
607  } else {
608  i = 0;
609  last_non_zero = -1;
610  goto next_coef;
611  }
612  }
613 
614  /* now quantify & encode AC coefs */
615  last_non_zero = i - 1;
616 
617  for (; i <= last_index; i++) {
618  j = s->c.intra_scantable.permutated[i];
619  level = block[j];
620 
621 next_coef:
622  /* encode using VLC */
623  if (level != 0) {
624  run = i - last_non_zero - 1;
625 
626  alevel = level;
627  MASK_ABS(sign, alevel);
628  sign &= 1;
629 
630  if (alevel <= mpeg12_max_level[run]) {
631  code = mpeg12_index_run[run] + alevel - 1;
632  /* store the VLC & sign at once */
633  put_bits(&s->pb, table_vlc[code][1] + 1,
634  (table_vlc[code][0] << 1) + sign);
635  } else {
636  /* Escape seems to be pretty rare <5% so I do not optimize it.
637  * The following encodes run together with the common escape
638  * value of both tables 000001b. */
639  put_bits(&s->pb, 6 + 6, 0x01 << 6 | run);
640  /* escape: only clip in this case */
641  if (s->c.codec_id == AV_CODEC_ID_MPEG1VIDEO) {
642  if (alevel < 128) {
643  put_sbits(&s->pb, 8, level);
644  } else {
645  if (level < 0)
646  put_bits(&s->pb, 16, 0x8001 + level + 255);
647  else
648  put_sbits(&s->pb, 16, level);
649  }
650  } else {
651  put_sbits(&s->pb, 12, level);
652  }
653  }
654  last_non_zero = i;
655  }
656  }
657  /* end of block */
658  put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
659 }
660 
661 static av_always_inline void mpeg1_encode_mb_internal(MPVEncContext *const s,
662  const int16_t block[8][64],
663  int motion_x, int motion_y,
664  int mb_block_count,
665  int chroma_y_shift)
666 {
667 /* MPEG-1 is always 420. */
668 #define IS_MPEG1(s) (chroma_y_shift == 1 && (s)->c.codec_id == AV_CODEC_ID_MPEG1VIDEO)
669  int i, cbp;
670  const int mb_x = s->c.mb_x;
671  const int mb_y = s->c.mb_y;
672  const int first_mb = mb_x == s->c.resync_mb_x && mb_y == s->c.resync_mb_y;
673 
674  /* compute cbp */
675  cbp = 0;
676  for (i = 0; i < mb_block_count; i++)
677  if (s->c.block_last_index[i] >= 0)
678  cbp |= 1 << (mb_block_count - 1 - i);
679 
680  if (cbp == 0 && !first_mb && s->c.mv_type == MV_TYPE_16X16 &&
681  (mb_x != s->c.mb_width - 1 ||
682  (mb_y != s->c.end_mb_y - 1 && IS_MPEG1(s))) &&
683  ((s->c.pict_type == AV_PICTURE_TYPE_P && (motion_x | motion_y) == 0) ||
684  (s->c.pict_type == AV_PICTURE_TYPE_B && s->c.mv_dir == s->last_mv_dir &&
685  (((s->c.mv_dir & MV_DIR_FORWARD)
686  ? ((s->c.mv[0][0][0] - s->c.last_mv[0][0][0]) |
687  (s->c.mv[0][0][1] - s->c.last_mv[0][0][1])) : 0) |
688  ((s->c.mv_dir & MV_DIR_BACKWARD)
689  ? ((s->c.mv[1][0][0] - s->c.last_mv[1][0][0]) |
690  (s->c.mv[1][0][1] - s->c.last_mv[1][0][1])) : 0)) == 0))) {
691  s->c.mb_skip_run++;
692  s->c.qscale -= s->dquant;
693  s->misc_bits++;
694  s->last_bits++;
695  if (s->c.pict_type == AV_PICTURE_TYPE_P) {
696  s->c.last_mv[0][0][0] =
697  s->c.last_mv[0][0][1] =
698  s->c.last_mv[0][1][0] =
699  s->c.last_mv[0][1][1] = 0;
700  }
701  } else {
702  if (first_mb) {
703  av_assert0(s->c.mb_skip_run == 0);
704  encode_mb_skip_run(s, s->c.mb_x);
705  } else {
706  encode_mb_skip_run(s, s->c.mb_skip_run);
707  }
708 
709  if (s->c.pict_type == AV_PICTURE_TYPE_I) {
710  if (s->dquant && cbp) {
711  /* macroblock_type: macroblock_quant = 1 */
712  put_mb_modes(s, 2, 1, 0, 0);
713  put_qscale(s);
714  } else {
715  /* macroblock_type: macroblock_quant = 0 */
716  put_mb_modes(s, 1, 1, 0, 0);
717  s->c.qscale -= s->dquant;
718  }
719  s->misc_bits += get_bits_diff(s);
720  s->i_count++;
721  } else if (s->c.mb_intra) {
722  if (s->dquant && cbp) {
723  put_mb_modes(s, 6, 0x01, 0, 0);
724  put_qscale(s);
725  } else {
726  put_mb_modes(s, 5, 0x03, 0, 0);
727  s->c.qscale -= s->dquant;
728  }
729  s->misc_bits += get_bits_diff(s);
730  s->i_count++;
731  memset(s->c.last_mv, 0, sizeof(s->c.last_mv));
732  } else if (s->c.pict_type == AV_PICTURE_TYPE_P) {
733  if (s->c.mv_type == MV_TYPE_16X16) {
734  if (cbp != 0) {
735  if ((motion_x | motion_y) == 0) {
736  if (s->dquant) {
737  /* macroblock_pattern & quant */
738  put_mb_modes(s, 5, 1, 0, 0);
739  put_qscale(s);
740  } else {
741  /* macroblock_pattern only */
742  put_mb_modes(s, 2, 1, 0, 0);
743  }
744  s->misc_bits += get_bits_diff(s);
745  } else {
746  if (s->dquant) {
747  put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */
748  put_qscale(s);
749  } else {
750  put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */
751  }
752  s->misc_bits += get_bits_diff(s);
753  // RAL: f_code parameter added
754  mpeg1_encode_motion(s,
755  motion_x - s->c.last_mv[0][0][0],
756  s->f_code);
757  // RAL: f_code parameter added
758  mpeg1_encode_motion(s,
759  motion_y - s->c.last_mv[0][0][1],
760  s->f_code);
761  s->mv_bits += get_bits_diff(s);
762  }
763  } else {
764  put_bits(&s->pb, 3, 1); /* motion only */
765  if (!s->c.frame_pred_frame_dct)
766  put_bits(&s->pb, 2, 2); /* motion_type: frame */
767  s->misc_bits += get_bits_diff(s);
768  // RAL: f_code parameter added
769  mpeg1_encode_motion(s,
770  motion_x - s->c.last_mv[0][0][0],
771  s->f_code);
772  // RAL: f_code parameter added
773  mpeg1_encode_motion(s,
774  motion_y - s->c.last_mv[0][0][1],
775  s->f_code);
776  s->c.qscale -= s->dquant;
777  s->mv_bits += get_bits_diff(s);
778  }
779  s->c.last_mv[0][1][0] = s->c.last_mv[0][0][0] = motion_x;
780  s->c.last_mv[0][1][1] = s->c.last_mv[0][0][1] = motion_y;
781  } else {
782  av_assert2(!s->c.frame_pred_frame_dct && s->c.mv_type == MV_TYPE_FIELD);
783 
784  if (cbp) {
785  if (s->dquant) {
786  put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
787  put_qscale(s);
788  } else {
789  put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
790  }
791  } else {
792  put_bits(&s->pb, 3, 1); /* motion only */
793  put_bits(&s->pb, 2, 1); /* motion_type: field */
794  s->c.qscale -= s->dquant;
795  }
796  s->misc_bits += get_bits_diff(s);
797  for (i = 0; i < 2; i++) {
798  put_bits(&s->pb, 1, s->c.field_select[0][i]);
799  mpeg1_encode_motion(s,
800  s->c.mv[0][i][0] - s->c.last_mv[0][i][0],
801  s->f_code);
802  mpeg1_encode_motion(s,
803  s->c.mv[0][i][1] - (s->c.last_mv[0][i][1] >> 1),
804  s->f_code);
805  s->c.last_mv[0][i][0] = s->c.mv[0][i][0];
806  s->c.last_mv[0][i][1] = 2 * s->c.mv[0][i][1];
807  }
808  s->mv_bits += get_bits_diff(s);
809  }
810  if (cbp) {
811  if (chroma_y_shift) {
812  put_bits(&s->pb,
813  ff_mpeg12_mbPatTable[cbp][1],
814  ff_mpeg12_mbPatTable[cbp][0]);
815  } else {
816  put_bits(&s->pb,
817  ff_mpeg12_mbPatTable[cbp >> 2][1],
818  ff_mpeg12_mbPatTable[cbp >> 2][0]);
819  put_sbits(&s->pb, 2, cbp);
820  }
821  }
822  } else {
823  if (s->c.mv_type == MV_TYPE_16X16) {
824  if (cbp) { // With coded bloc pattern
825  if (s->dquant) {
826  if (s->c.mv_dir == MV_DIR_FORWARD)
827  put_mb_modes(s, 6, 3, 1, 0);
828  else
829  put_mb_modes(s, 8 - s->c.mv_dir, 2, 1, 0);
830  put_qscale(s);
831  } else {
832  put_mb_modes(s, 5 - s->c.mv_dir, 3, 1, 0);
833  }
834  } else { // No coded bloc pattern
835  put_bits(&s->pb, 5 - s->c.mv_dir, 2);
836  if (!s->c.frame_pred_frame_dct)
837  put_bits(&s->pb, 2, 2); /* motion_type: frame */
838  s->c.qscale -= s->dquant;
839  }
840  s->misc_bits += get_bits_diff(s);
841  if (s->c.mv_dir & MV_DIR_FORWARD) {
842  mpeg1_encode_motion(s,
843  s->c.mv[0][0][0] - s->c.last_mv[0][0][0],
844  s->f_code);
845  mpeg1_encode_motion(s,
846  s->c.mv[0][0][1] - s->c.last_mv[0][0][1],
847  s->f_code);
848  s->c.last_mv[0][0][0] =
849  s->c.last_mv[0][1][0] = s->c.mv[0][0][0];
850  s->c.last_mv[0][0][1] =
851  s->c.last_mv[0][1][1] = s->c.mv[0][0][1];
852  }
853  if (s->c.mv_dir & MV_DIR_BACKWARD) {
854  mpeg1_encode_motion(s,
855  s->c.mv[1][0][0] - s->c.last_mv[1][0][0],
856  s->b_code);
857  mpeg1_encode_motion(s,
858  s->c.mv[1][0][1] - s->c.last_mv[1][0][1],
859  s->b_code);
860  s->c.last_mv[1][0][0] =
861  s->c.last_mv[1][1][0] = s->c.mv[1][0][0];
862  s->c.last_mv[1][0][1] =
863  s->c.last_mv[1][1][1] = s->c.mv[1][0][1];
864  }
865  } else {
866  av_assert2(s->c.mv_type == MV_TYPE_FIELD);
867  av_assert2(!s->c.frame_pred_frame_dct);
868  if (cbp) { // With coded bloc pattern
869  if (s->dquant) {
870  if (s->c.mv_dir == MV_DIR_FORWARD)
871  put_mb_modes(s, 6, 3, 1, 1);
872  else
873  put_mb_modes(s, 8 - s->c.mv_dir, 2, 1, 1);
874  put_qscale(s);
875  } else {
876  put_mb_modes(s, 5 - s->c.mv_dir, 3, 1, 1);
877  }
878  } else { // No coded bloc pattern
879  put_bits(&s->pb, 5 - s->c.mv_dir, 2);
880  put_bits(&s->pb, 2, 1); /* motion_type: field */
881  s->c.qscale -= s->dquant;
882  }
883  s->misc_bits += get_bits_diff(s);
884  if (s->c.mv_dir & MV_DIR_FORWARD) {
885  for (i = 0; i < 2; i++) {
886  put_bits(&s->pb, 1, s->c.field_select[0][i]);
887  mpeg1_encode_motion(s,
888  s->c.mv[0][i][0] - s->c.last_mv[0][i][0],
889  s->f_code);
890  mpeg1_encode_motion(s,
891  s->c.mv[0][i][1] - (s->c.last_mv[0][i][1] >> 1),
892  s->f_code);
893  s->c.last_mv[0][i][0] = s->c.mv[0][i][0];
894  s->c.last_mv[0][i][1] = s->c.mv[0][i][1] * 2;
895  }
896  }
897  if (s->c.mv_dir & MV_DIR_BACKWARD) {
898  for (i = 0; i < 2; i++) {
899  put_bits(&s->pb, 1, s->c.field_select[1][i]);
900  mpeg1_encode_motion(s,
901  s->c.mv[1][i][0] - s->c.last_mv[1][i][0],
902  s->b_code);
903  mpeg1_encode_motion(s,
904  s->c.mv[1][i][1] - (s->c.last_mv[1][i][1] >> 1),
905  s->b_code);
906  s->c.last_mv[1][i][0] = s->c.mv[1][i][0];
907  s->c.last_mv[1][i][1] = s->c.mv[1][i][1] * 2;
908  }
909  }
910  }
911  s->mv_bits += get_bits_diff(s);
912  if (cbp) {
913  if (chroma_y_shift) {
914  put_bits(&s->pb,
915  ff_mpeg12_mbPatTable[cbp][1],
916  ff_mpeg12_mbPatTable[cbp][0]);
917  } else {
918  put_bits(&s->pb,
919  ff_mpeg12_mbPatTable[cbp >> 2][1],
920  ff_mpeg12_mbPatTable[cbp >> 2][0]);
921  put_sbits(&s->pb, 2, cbp);
922  }
923  }
924  }
925  for (i = 0; i < mb_block_count; i++)
926  if (cbp & (1 << (mb_block_count - 1 - i)))
927  mpeg1_encode_block(s, block[i], i);
928  s->c.mb_skip_run = 0;
929  if (s->c.mb_intra)
930  s->i_tex_bits += get_bits_diff(s);
931  else
932  s->p_tex_bits += get_bits_diff(s);
933  }
934 }
935 
936 static void mpeg12_encode_mb(MPVEncContext *const s, int16_t block[][64],
937  int motion_x, int motion_y)
938 {
939  if (!s->c.mb_intra)
940  s->c.last_dc[0] = s->c.last_dc[1] = s->c.last_dc[2] = 128 << s->c.intra_dc_precision;
941  if (s->c.chroma_format == CHROMA_420)
942  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6, 1);
943  else
944  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8, 0);
945 }
946 
947 static av_cold void mpeg12_encode_init_static(void)
948 {
949  ff_rl_init_level_run(mpeg12_max_level, mpeg12_index_run,
951 
952  ff_mpeg1_init_uni_ac_vlc(mpeg12_max_level, mpeg12_index_run,
953  ff_mpeg1_vlc_table, uni_mpeg1_ac_vlc_len);
954  ff_mpeg1_init_uni_ac_vlc(mpeg12_max_level, mpeg12_index_run,
955  ff_mpeg2_vlc_table, uni_mpeg2_ac_vlc_len);
956 
957  /* build unified dc encoding tables */
958  for (int i = -255; i < 256; i++) {
959  int adiff, index;
960  int bits, code;
961  int diff = i;
962 
963  adiff = FFABS(diff);
964  if (diff < 0)
965  diff--;
966  index = av_log2(2 * adiff);
967 
971  mpeg1_lum_dc_uni[i + 255] = bits + (code << 8);
972 
976  mpeg1_chr_dc_uni[i + 255] = bits + (code << 8);
977  }
978 
979  for (int f_code = 1; f_code <= MAX_FCODE; f_code++)
980  for (int mv = -MAX_DMV; mv <= MAX_DMV; mv++) {
981  int len;
982 
983  if (mv == 0) {
984  len = 1; /* ff_mpeg12_mbMotionVectorTable[0][1] */
985  } else {
986  int val, bit_size, code;
987 
988  bit_size = f_code - 1;
989 
990  val = mv;
991  if (val < 0)
992  val = -val;
993  val--;
994  code = (val >> bit_size) + 1;
995  if (code < 17)
997  1 + bit_size;
998  else
999  len = 10 /* ff_mpeg12_mbMotionVectorTable[16][1] */ +
1000  2 + bit_size;
1001  }
1002 
1003  mv_penalty[f_code][mv + MAX_DMV] = len;
1004  }
1005 
1006 
1007  for (int f_code = MAX_FCODE; f_code > 0; f_code--)
1008  for (int mv = -(8 << f_code); mv < (8 << f_code); mv++)
1009  fcode_tab[mv + MAX_MV] = f_code;
1010 }
1011 
1012 static av_cold int find_frame_rate_index(AVCodecContext *avctx, MPEG12EncContext *mpeg12)
1013 {
1014  AVRational bestq = (AVRational) {0, 0};
1015  AVRational ext;
1016  AVRational target = av_inv_q(avctx->time_base);
1017 
1018  for (int i = 1; i < 14; i++) {
1020  i >= 9)
1021  break;
1022 
1023  for (ext.num = 1; ext.num <= 4; ext.num++) {
1024  for (ext.den = 1; ext.den <= 32; ext.den++) {
1026 
1027  if (avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO && (ext.den!=1 || ext.num!=1))
1028  continue;
1029  if (av_gcd(ext.den, ext.num) != 1)
1030  continue;
1031 
1032  if ( bestq.num==0
1033  || av_nearer_q(target, bestq, q) < 0
1034  || ext.num==1 && ext.den==1 && av_nearer_q(target, bestq, q) == 0) {
1035  bestq = q;
1036  mpeg12->frame_rate_index = i;
1037  mpeg12->frame_rate_ext.num = ext.num;
1038  mpeg12->frame_rate_ext.den = ext.den;
1039  }
1040  }
1041  }
1042  }
1043 
1044  if (av_cmp_q(target, bestq))
1045  return -1;
1046  else
1047  return 0;
1048 }
1049 
1050 static av_cold int encode_init(AVCodecContext *avctx)
1051 {
1052  static AVOnce init_static_once = AV_ONCE_INIT;
1053  MPEG12EncContext *const mpeg12 = avctx->priv_data;
1054  MPVMainEncContext *const m = &mpeg12->mpeg;
1055  MPVEncContext *const s = &m->s;
1056  int ret;
1057  int max_size = avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 16383 : 4095;
1058 
1059  if (avctx->width > max_size || avctx->height > max_size) {
1060  av_log(avctx, AV_LOG_ERROR, "%s does not support resolutions above %dx%d\n",
1061  CONFIG_SMALL ? avctx->codec->name : avctx->codec->long_name,
1062  max_size, max_size);
1063  return AVERROR(EINVAL);
1064  }
1065  if ((avctx->width & 0xFFF) == 0 && (avctx->height & 0xFFF) == 1) {
1066  av_log(avctx, AV_LOG_ERROR, "Width / Height is invalid for MPEG2\n");
1067  return AVERROR(EINVAL);
1068  }
1069 
1071  if ((avctx->width & 0xFFF) == 0 || (avctx->height & 0xFFF) == 0) {
1072  av_log(avctx, AV_LOG_ERROR, "Width or Height are not allowed to be multiples of 4096\n"
1073  "add '-strict %d' if you want to use them anyway.\n", FF_COMPLIANCE_UNOFFICIAL);
1074  return AVERROR(EINVAL);
1075  }
1076  }
1077 
1078  if (s->c.q_scale_type == 1) {
1079  if (avctx->qmax > 28) {
1080  av_log(avctx, AV_LOG_ERROR,
1081  "non linear quant only supports qmax <= 28 currently\n");
1082  return AVERROR_PATCHWELCOME;
1083  }
1084  }
1085 
1086  if (avctx->profile == AV_PROFILE_UNKNOWN) {
1087  if (avctx->level != AV_LEVEL_UNKNOWN) {
1088  av_log(avctx, AV_LOG_ERROR, "Set profile and level\n");
1089  return AVERROR(EINVAL);
1090  }
1091  /* Main or 4:2:2 */
1094  }
1095  if (avctx->level == AV_LEVEL_UNKNOWN) {
1096  if (avctx->profile == AV_PROFILE_MPEG2_422) { /* 4:2:2 */
1097  if (avctx->width <= 720 && avctx->height <= 608)
1098  avctx->level = 5; /* Main */
1099  else
1100  avctx->level = 2; /* High */
1101  } else {
1102  if (avctx->profile != AV_PROFILE_MPEG2_HIGH &&
1103  avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
1104  av_log(avctx, AV_LOG_ERROR,
1105  "Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n");
1106  return AVERROR(EINVAL);
1107  }
1108  if (avctx->width <= 720 && avctx->height <= 576)
1109  avctx->level = 8; /* Main */
1110  else if (avctx->width <= 1440)
1111  avctx->level = 6; /* High 1440 */
1112  else
1113  avctx->level = 4; /* High */
1114  }
1115  }
1116 
1117  m->encode_picture_header = mpeg1_encode_picture_header;
1118  s->encode_mb = mpeg12_encode_mb;
1119 
1120  s->me.mv_penalty = mv_penalty;
1121  m->fcode_tab = fcode_tab + MAX_MV;
1122  if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1123  s->min_qcoeff = -255;
1124  s->max_qcoeff = 255;
1125  } else {
1126  s->min_qcoeff = -2047;
1127  s->max_qcoeff = 2047;
1128  s->c.mpeg_quant = 1;
1129  }
1130  if (s->c.intra_vlc_format) {
1131  s->intra_ac_vlc_length =
1132  s->intra_ac_vlc_last_length = uni_mpeg2_ac_vlc_len;
1133  } else {
1134  s->intra_ac_vlc_length =
1135  s->intra_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1136  }
1137  s->inter_ac_vlc_length =
1138  s->inter_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1139 
1140  ret = ff_mpv_encode_init(avctx);
1141  if (ret < 0)
1142  return ret;
1143 
1144  if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
1145  s->c.thread_context[s->c.slice_context_count - 1]->start_mb_y >
1147  // MPEG-1 slices must not start at a MB row number that would make
1148  // their start code > SLICE_MAX_START_CODE. So make the last slice
1149  // bigger if needed and evenly distribute the first 174 rows.
1150  static_assert(MAX_THREADS <= 1 + SLICE_MAX_START_CODE - SLICE_MIN_START_CODE,
1151  "With more than 175 slice contexts, we have to handle "
1152  "the case in which there is no work to do for some "
1153  "slice contexts.");
1154  const int mb_height = SLICE_MAX_START_CODE - SLICE_MIN_START_CODE;
1155  const int nb_slices = s->c.slice_context_count - 1;
1156 
1157  s->c.thread_context[nb_slices]->start_mb_y = mb_height;
1158 
1159  av_assert1(nb_slices >= 1);
1160  for (int i = 0; i < nb_slices; i++) {
1161  s->c.thread_context[i]->start_mb_y =
1162  (mb_height * (i ) + nb_slices / 2) / nb_slices;
1163  s->c.thread_context[i]->end_mb_y =
1164  (mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1165  }
1166  }
1167 
1168  if (find_frame_rate_index(avctx, mpeg12) < 0) {
1170  av_log(avctx, AV_LOG_ERROR, "MPEG-1/2 does not support %d/%d fps\n",
1171  avctx->time_base.den, avctx->time_base.num);
1172  return AVERROR(EINVAL);
1173  } else {
1174  av_log(avctx, AV_LOG_INFO,
1175  "MPEG-1/2 does not support %d/%d fps, there may be AV sync issues\n",
1176  avctx->time_base.den, avctx->time_base.num);
1177  }
1178  }
1179 
1180  if (avctx->rc_max_rate &&
1181  avctx->rc_min_rate == avctx->rc_max_rate &&
1182  90000LL * (avctx->rc_buffer_size - 1) >
1183  avctx->rc_max_rate * 0xFFFFLL) {
1184  av_log(avctx, AV_LOG_INFO,
1185  "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
1186  "specified vbv buffer is too large for the given bitrate!\n");
1187  }
1188 
1189  if (mpeg12->drop_frame_timecode)
1190  mpeg12->tc.flags |= AV_TIMECODE_FLAG_DROPFRAME;
1191  if (mpeg12->drop_frame_timecode && mpeg12->frame_rate_index != 4) {
1192  av_log(avctx, AV_LOG_ERROR,
1193  "Drop frame time code only allowed with 1001/30000 fps\n");
1194  return AVERROR(EINVAL);
1195  }
1196 
1197  if (mpeg12->tc_opt_str) {
1198  AVRational rate = ff_mpeg12_frame_rate_tab[mpeg12->frame_rate_index];
1199  int ret = av_timecode_init_from_string(&mpeg12->tc, rate, mpeg12->tc_opt_str, avctx);
1200  if (ret < 0)
1201  return ret;
1202  mpeg12->drop_frame_timecode = !!(mpeg12->tc.flags & AV_TIMECODE_FLAG_DROPFRAME);
1203  mpeg12->timecode_frame_start = mpeg12->tc.start;
1204  } else {
1205  mpeg12->timecode_frame_start = 0; // default is -1
1206  }
1207 
1208  ff_thread_once(&init_static_once, mpeg12_encode_init_static);
1209 
1210  return 0;
1211 }
1212 
1213 #define OFFSET(x) offsetof(MPEG12EncContext, x)
1214 #define VE AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
1215 #define COMMON_OPTS \
1216  { "gop_timecode", "MPEG GOP Timecode in hh:mm:ss[:;.]ff format. Overrides timecode_frame_start.", \
1217  OFFSET(tc_opt_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE },\
1218  { "drop_frame_timecode", "Timecode is in drop frame format.", \
1219  OFFSET(drop_frame_timecode), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1220  { "scan_offset", "Reserve space for SVCD scan offset user data.", \
1221  OFFSET(scan_offset), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1222  { "timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", \
1223  OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = -1 }, -1, INT64_MAX, VE}, \
1224  FF_MPV_COMMON_BFRAME_OPTS
1225 
1226 static const AVOption mpeg1_options[] = {
1227  COMMON_OPTS
1230  { NULL },
1231 };
1232 
1233 static const AVOption mpeg2_options[] = {
1234  COMMON_OPTS
1235  { "intra_vlc", "Use MPEG-2 intra VLC table.",
1236  FF_MPV_OFFSET(c.intra_vlc_format), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1237  { "non_linear_quant", "Use nonlinear quantizer.", FF_MPV_OFFSET(c.q_scale_type), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1238  { "alternate_scan", "Enable alternate scantable.", FF_MPV_OFFSET(c.alternate_scan), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1239  { "a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
1240  { "seq_disp_ext", "Write sequence_display_extension blocks.", OFFSET(seq_disp_ext), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, .unit = "seq_disp_ext" },
1241  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, VE, .unit = "seq_disp_ext" },
1242  { "never", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, VE, .unit = "seq_disp_ext" },
1243  { "always", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, VE, .unit = "seq_disp_ext" },
1244  { "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, .unit = "video_format" },
1245  { "component", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_COMPONENT }, 0, 0, VE, .unit = "video_format" },
1246  { "pal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_PAL }, 0, 0, VE, .unit = "video_format" },
1247  { "ntsc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_NTSC }, 0, 0, VE, .unit = "video_format" },
1248  { "secam", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_SECAM }, 0, 0, VE, .unit = "video_format" },
1249  { "mac", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_MAC }, 0, 0, VE, .unit = "video_format" },
1250  { "unspecified", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_UNSPECIFIED}, 0, 0, VE, .unit = "video_format" },
1251 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, { .i64 = value }, 0, 0, VE, .unit = "avctx.level"
1252  { LEVEL("high", 4) },
1253  { LEVEL("high1440", 6) },
1254  { LEVEL("main", 8) },
1255  { LEVEL("low", 10) },
1256 #undef LEVEL
1260  { NULL },
1261 };
1262 
1263 #define mpeg12_class(x) \
1264 static const AVClass mpeg ## x ## _class = { \
1265  .class_name = "mpeg" # x "video encoder", \
1266  .item_name = av_default_item_name, \
1267  .option = mpeg ## x ## _options, \
1268  .version = LIBAVUTIL_VERSION_INT, \
1269 };
1270 
1271 mpeg12_class(1)
1272 mpeg12_class(2)
1273 
1275  .p.name = "mpeg1video",
1276  CODEC_LONG_NAME("MPEG-1 video"),
1277  .p.type = AVMEDIA_TYPE_VIDEO,
1278  .p.id = AV_CODEC_ID_MPEG1VIDEO,
1279  .priv_data_size = sizeof(MPEG12EncContext),
1280  .init = encode_init,
1282  .close = ff_mpv_encode_end,
1285  .color_ranges = AVCOL_RANGE_MPEG,
1286  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1289  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1290  .p.priv_class = &mpeg1_class,
1291 };
1292 
1294  .p.name = "mpeg2video",
1295  CODEC_LONG_NAME("MPEG-2 video"),
1296  .p.type = AVMEDIA_TYPE_VIDEO,
1297  .p.id = AV_CODEC_ID_MPEG2VIDEO,
1298  .priv_data_size = sizeof(MPEG12EncContext),
1299  .init = encode_init,
1301  .close = ff_mpv_encode_end,
1304  .color_ranges = AVCOL_RANGE_MPEG,
1305  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1308  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1309  .p.priv_class = &mpeg2_class,
1310 };
1311 #endif /* CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER */
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
MPVMainEncContext::fcode_tab
const uint8_t * fcode_tab
smallest fcode needed for each MV
Definition: mpegvideoenc.h:217
CODEC_PIXFMTS
#define CODEC_PIXFMTS(...)
Definition: codec_internal.h:386
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:186
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
CODEC_FRAMERATES_ARRAY
#define CODEC_FRAMERATES_ARRAY(array)
Definition: codec_internal.h:384
level
uint8_t level
Definition: svq3.c:208
MPVEncContext
Definition: mpegvideoenc.h:45
ff_mpeg2_aspect
const AVRational ff_mpeg2_aspect[16]
Definition: mpeg12data.c:380
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
AVERROR
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
opt.h
AV_STEREO3D_SIDEBYSIDE_QUINCUNX
@ AV_STEREO3D_SIDEBYSIDE_QUINCUNX
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:114
put_bits32
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:301
AVCodec::long_name
const char * long_name
Descriptive name for the codec, meant to be more human readable than name.
Definition: codec.h:184
align_put_bits
static void align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: put_bits.h:445
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:661
MAX_FCODE
#define MAX_FCODE
Definition: mpegvideoenc.h:263
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1277
thread.h
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
EXT_START_CODE
#define EXT_START_CODE
Definition: cavs.h:39
AVPanScan
Pan Scan area.
Definition: defs.h:250
SLICE_MAX_START_CODE
#define SLICE_MAX_START_CODE
Definition: cavs.h:38
mpegvideoenc.h
int64_t
long long int64_t
Definition: coverity.c:34
mv
static const int8_t mv[256][2]
Definition: 4xm.c:81
ff_rl_init_level_run
av_cold void ff_rl_init_level_run(uint8_t max_level[MAX_LEVEL+1], uint8_t index_run[MAX_RUN+1], const uint8_t table_run[], const uint8_t table_level[], int n)
Initialize max_level and index_run from table_run and table_level; this is equivalent to initializing...
Definition: rl.c:26
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:291
MAX_RUN
#define MAX_RUN
Definition: rl.h:35
av_log2_16bit
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
MPEG12_RL_NB_ELEMS
#define MPEG12_RL_NB_ELEMS
Definition: mpeg12vlc.h:52
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
MAX_DMV
#define MAX_DMV
Definition: motion_est.h:39
AVOption
AVOption.
Definition: opt.h:429
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:647
put_bytes_count
static int put_bytes_count(const PutBitContext *s, int round_up)
Definition: put_bits.h:110
AV_ROUND_ZERO
@ AV_ROUND_ZERO
Round toward zero.
Definition: mathematics.h:131
mv_penalty
static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
Definition: h261enc.c:53
FFCodec
Definition: codec_internal.h:127
MASK_ABS
#define MASK_ABS(mask, level)
Definition: mathops.h:165
ff_mpeg2video_encoder
const FFCodec ff_mpeg2video_encoder
mpegvideo.h
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1241
mpegutils.h
ff_mpeg12_vlc_dc_chroma_bits
const unsigned char ff_mpeg12_vlc_dc_chroma_bits[12]
Definition: mpeg12data.c:63
MPVMainEncContext::encode_picture_header
int(* encode_picture_header)(struct MPVMainEncContext *m)
Definition: mpegvideoenc.h:226
SEQ_START_CODE
#define SEQ_START_CODE
Definition: mpeg12.h:29
MV_DIR_BACKWARD
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:183
ff_mpeg12_vlc_dc_lum_bits
const unsigned char ff_mpeg12_vlc_dc_lum_bits[12]
Definition: mpeg12data.c:56
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:638
FF_MPV_COMMON_MOTION_EST_OPTS
#define FF_MPV_COMMON_MOTION_EST_OPTS
Definition: mpegvideoenc.h:355
ff_mpeg12_mbAddrIncrTable
const uint8_t ff_mpeg12_mbAddrIncrTable[36][2]
Definition: mpeg12data.c:167
AV_STEREO3D_SIDEBYSIDE
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:64
ff_mpv_encode_picture
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)
Definition: mpegvideo_enc.c:1927
FF_MPV_COMMON_OPTS
#define FF_MPV_COMMON_OPTS
Definition: mpegvideoenc.h:314
ff_mpeg2_frame_rate_tab
const AVRational ff_mpeg2_frame_rate_tab[]
Definition: mpeg12data.c:293
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:440
mpeg12enc.h
AV_STEREO3D_2D
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:52
timecode.h
ff_mpeg12_mbMotionVectorTable
const uint8_t ff_mpeg12_mbMotionVectorTable[17][2]
Definition: mpeg12data.c:273
AVPanScan::width
int width
width and height in 1/16 pel
Definition: defs.h:263
mpeg12vlc.h
MAX_THREADS
#define MAX_THREADS
Definition: frame_thread_encoder.c:37
val
static double val(void *priv, double ch)
Definition: aeval.c:77
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:353
AVRational::num
int num
Numerator.
Definition: rational.h:59
GOP_START_CODE
#define GOP_START_CODE
Definition: mpeg12.h:30
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: asvenc.c:327
avassert.h
mpeg12.h
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
AVFrameSideData::size
size_t size
Definition: frame.h:268
av_cold
#define av_cold
Definition: attributes.h:90
MAX_MV
#define MAX_MV
Definition: motion_est.h:37
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
A53_MAX_CC_COUNT
#define A53_MAX_CC_COUNT
Definition: mpeg12dec.c:62
stereo3d.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
ff_mpeg1_aspect
const float ff_mpeg1_aspect[16]
Definition: mpeg12data.c:359
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:144
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
ff_write_quant_matrix
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
Definition: mpegvideo_enc.c:228
FF_MPV_OFFSET
#define FF_MPV_OFFSET(x)
Definition: mpegvideoenc.h:310
av_timecode_adjust_ntsc_framenum2
int av_timecode_adjust_ntsc_framenum2(int framenum, int fps)
Adjust frame number for NTSC drop frame time code.
Definition: timecode.c:36
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1270
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:622
ff_mpeg1video_encoder
const FFCodec ff_mpeg1video_encoder
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:441
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1255
framerate
float framerate
Definition: av1_levels.c:29
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:207
SLICE_MIN_START_CODE
#define SLICE_MIN_START_CODE
Definition: mpeg12.h:32
AV_LEVEL_UNKNOWN
#define AV_LEVEL_UNKNOWN
Definition: defs.h:206
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
profiles.h
mathops.h
ff_mpv_encode_end
av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:1105
abs
#define abs(x)
Definition: cuda_runtime.h:35
COMMON_OPTS
#define COMMON_OPTS
Definition: f_segment.c:264
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1628
MPVMainEncContext
Definition: mpegvideoenc.h:177
AVOnce
#define AVOnce
Definition: thread.h:202
index
int index
Definition: gxfenc.c:90
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:53
ff_mpeg12_run
const int8_t ff_mpeg12_run[MPEG12_RL_NB_ELEMS]
Definition: mpeg12data.c:150
MAX_LEVEL
#define MAX_LEVEL
Definition: rl.h:36
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:535
av_rescale_rnd
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
dc
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
AV_FRAME_DATA_PANSCAN
@ AV_FRAME_DATA_PANSCAN
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:53
height
#define height
Definition: dsp.h:89
codec_internal.h
MPVMainEncContext::vbv_delay_pos
int vbv_delay_pos
offset of vbv_delay in the bitstream
Definition: mpegvideoenc.h:215
ff_mpeg12_level
const int8_t ff_mpeg12_level[MPEG12_RL_NB_ELEMS]
Definition: mpeg12data.c:133
put_bits_assume_flushed
static void put_bits_assume_flushed(const PutBitContext *s)
Inform the compiler that a PutBitContext is flushed (i.e.
Definition: put_bits.h:82
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
PICTURE_START_CODE
#define PICTURE_START_CODE
Definition: mpeg12.h:31
USER_START_CODE
#define USER_START_CODE
Definition: cavs.h:40
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2594
header
static const uint8_t header[24]
Definition: sdr2.c:68
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
fcode_tab
static uint8_t fcode_tab[MAX_MV *2+1]
Minimal fcode that a motion vector component would need.
Definition: mpeg4videoenc.c:44
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:99
ff_mpeg1_encode_slice_header
void ff_mpeg1_encode_slice_header(MPVEncContext *s)
attributes.h
MV_TYPE_FIELD
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:189
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: defs.h:61
av_zero_extend
#define av_zero_extend
Definition: common.h:151
UNI_AC_ENC_INDEX
#define UNI_AC_ENC_INDEX(run, level)
Definition: mpegvideoenc.h:264
encode_dc
static void encode_dc(PutBitContext *pb, int diff, int component)
Definition: speedhqenc.c:131
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
get_bits_diff
static int get_bits_diff(MPVEncContext *s)
Definition: mpegvideoenc.h:387
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
CHROMA_420
#define CHROMA_420
Definition: mpegvideo.h:303
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
code
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
Definition: filter_design.txt:178
AV_STEREO3D_TOPBOTTOM
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
Definition: stereo3d.h:76
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:57
av_always_inline
#define av_always_inline
Definition: attributes.h:49
AV_FRAME_DATA_STEREO3D
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition: frame.h:64
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
len
int len
Definition: vorbis_enc_data.h:426
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:676
AVCodecContext::height
int height
Definition: avcodec.h:592
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
FF_MPEG2_PROFILE_OPTS
#define FF_MPEG2_PROFILE_OPTS
Definition: profiles.h:48
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:733
ff_mpeg1_init_uni_ac_vlc
av_cold void ff_mpeg1_init_uni_ac_vlc(const int8_t max_level[], const uint8_t index_run[], const uint16_t table_vlc[][2], uint8_t uni_ac_vlc_len[])
Definition: mpeg12enc.c:102
ff_mpeg12_mbPatTable
const uint8_t ff_mpeg12_mbPatTable[64][2]
Definition: mpeg12data.c:206
avcodec.h
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
ff_mpeg12_vlc_dc_chroma_code
const uint16_t ff_mpeg12_vlc_dc_chroma_code[12]
Definition: mpeg12data.c:60
AV_TIMECODE_FLAG_DROPFRAME
@ AV_TIMECODE_FLAG_DROPFRAME
timecode is drop frame
Definition: timecode.h:36
put_header
static int64_t put_header(AVIOContext *pb, const ff_asf_guid *g)
Definition: asfenc.c:259
ff_mpeg12_frame_rate_tab
const AVRational ff_mpeg12_frame_rate_tab[]
Definition: mpeg12framerate.c:24
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:332
ret
ret
Definition: filter_design.txt:187
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1357
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:207
ff_mpeg1_vlc_table
const uint16_t ff_mpeg1_vlc_table[MPEG12_RL_NB_ELEMS+2][2]
Definition: mpeg12data.c:67
mpeg12data.h
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
OFFSET
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 see the OFFSET() macro
AVCodecContext
main external API structure.
Definition: avcodec.h:431
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:280
AV_PROFILE_MPEG2_HIGH
#define AV_PROFILE_MPEG2_HIGH
Definition: defs.h:101
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1618
ff_mpeg2_vlc_table
const uint16_t ff_mpeg2_vlc_table[MPEG12_RL_NB_ELEMS+2][2]
Definition: mpeg12data.c:100
AV_PROFILE_MPEG2_422
#define AV_PROFILE_MPEG2_422
Definition: defs.h:100
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:131
AV_PROFILE_MPEG2_MAIN
#define AV_PROFILE_MPEG2_MAIN
Definition: defs.h:104
AV_CODEC_CAP_DELAY
#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:76
LEVEL
#define LEVEL(name, value)
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:279
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
ff_mpv_encode_init
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:544
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
av_nearer_q
int av_nearer_q(AVRational q, AVRational q1, AVRational q2)
Find which of the two rationals is closer to another rational.
Definition: rational.c:125
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:182
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
rl.h
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
ff_mpeg12_vlc_dc_lum_code
const uint16_t ff_mpeg12_vlc_dc_lum_code[12]
Definition: mpeg12data.c:53
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
VE
#define VE
Definition: amfenc_av1.c:30
AVPanScan::height
int height
Definition: defs.h:264
av_timecode_init_from_string
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
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:203
width
#define width
Definition: dsp.h:89
AVTimecode
Definition: timecode.h:41
put_bits.h
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
MPVMainEncContext::s
MPVEncContext s
The main slicecontext.
Definition: mpegvideoenc.h:178