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