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