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