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 == AV_PROFILE_UNKNOWN) {
207  if (avctx->level != AV_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 == AV_LEVEL_UNKNOWN) {
216  if (avctx->profile == AV_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 != AV_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  if (mpeg12->drop_frame_timecode)
253  mpeg12->tc.flags |= AV_TIMECODE_FLAG_DROPFRAME;
254  if (mpeg12->drop_frame_timecode && mpeg12->frame_rate_index != 4) {
255  av_log(avctx, AV_LOG_ERROR,
256  "Drop frame time code only allowed with 1001/30000 fps\n");
257  return AVERROR(EINVAL);
258  }
259 
260  if (mpeg12->tc_opt_str) {
261  AVRational rate = ff_mpeg12_frame_rate_tab[mpeg12->frame_rate_index];
262  int ret = av_timecode_init_from_string(&mpeg12->tc, rate, mpeg12->tc_opt_str, s);
263  if (ret < 0)
264  return ret;
265  mpeg12->drop_frame_timecode = !!(mpeg12->tc.flags & AV_TIMECODE_FLAG_DROPFRAME);
266  mpeg12->timecode_frame_start = mpeg12->tc.start;
267  } else {
268  mpeg12->timecode_frame_start = 0; // default is -1
269  }
270 
271  return 0;
272 }
273 
274 static void put_header(MpegEncContext *s, int header)
275 {
276  align_put_bits(&s->pb);
277  put_bits(&s->pb, 16, header >> 16);
278  put_sbits(&s->pb, 16, header);
279 }
280 
281 /* put sequence header if needed */
282 static void mpeg1_encode_sequence_header(MpegEncContext *s)
283 {
284  MPEG12EncContext *const mpeg12 = (MPEG12EncContext*)s;
285  unsigned int vbv_buffer_size, fps, v;
286  int constraint_parameter_flag;
287  AVRational framerate = ff_mpeg12_frame_rate_tab[mpeg12->frame_rate_index];
288  uint64_t time_code;
289  int64_t best_aspect_error = INT64_MAX;
290  AVRational aspect_ratio = s->avctx->sample_aspect_ratio;
291  int aspect_ratio_info;
292 
293  if (!(s->current_picture.f->flags & AV_FRAME_FLAG_KEY))
294  return;
295 
296  if (aspect_ratio.num == 0 || aspect_ratio.den == 0)
297  aspect_ratio = (AVRational){1,1}; // pixel aspect 1.1 (VGA)
298 
299  /* MPEG-1 header repeated every GOP */
301 
302  put_sbits(&s->pb, 12, s->width & 0xFFF);
303  put_sbits(&s->pb, 12, s->height & 0xFFF);
304 
305  for (int i = 1; i < 15; i++) {
306  int64_t error = aspect_ratio.num * (1LL<<32) / aspect_ratio.den;
307  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || i <= 1)
308  error -= (1LL<<32) / ff_mpeg1_aspect[i];
309  else
310  error -= (1LL<<32)*ff_mpeg2_aspect[i].num * s->height / s->width / ff_mpeg2_aspect[i].den;
311 
312  error = FFABS(error);
313 
314  if (error - 2 <= best_aspect_error) {
315  best_aspect_error = error;
316  aspect_ratio_info = i;
317  }
318  }
319 
320  put_bits(&s->pb, 4, aspect_ratio_info);
321  put_bits(&s->pb, 4, mpeg12->frame_rate_index);
322 
323  if (s->avctx->rc_max_rate) {
324  v = (s->avctx->rc_max_rate + 399) / 400;
325  if (v > 0x3ffff && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
326  v = 0x3ffff;
327  } else {
328  v = 0x3FFFF;
329  }
330 
331  if (s->avctx->rc_buffer_size)
332  vbv_buffer_size = s->avctx->rc_buffer_size;
333  else
334  /* VBV calculation: Scaled so that a VCD has the proper
335  * VBV size of 40 kilobytes */
336  vbv_buffer_size = ((20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
337  vbv_buffer_size = (vbv_buffer_size + 16383) / 16384;
338 
339  put_sbits(&s->pb, 18, v);
340  put_bits(&s->pb, 1, 1); // marker
341  put_sbits(&s->pb, 10, vbv_buffer_size);
342 
343  constraint_parameter_flag =
344  s->width <= 768 &&
345  s->height <= 576 &&
346  s->mb_width * s->mb_height <= 396 &&
347  s->mb_width * s->mb_height * framerate.num <= 396 * 25 * framerate.den &&
348  framerate.num <= framerate.den * 30 &&
349  s->avctx->me_range &&
350  s->avctx->me_range < 128 &&
351  vbv_buffer_size <= 20 &&
352  v <= 1856000 / 400 &&
353  s->codec_id == AV_CODEC_ID_MPEG1VIDEO;
354 
355  put_bits(&s->pb, 1, constraint_parameter_flag);
356 
357  ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
358  ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
359 
360  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
361  const AVFrameSideData *side_data;
362  int width = s->width;
363  int height = s->height;
364  int use_seq_disp_ext;
365 
367  put_bits(&s->pb, 4, 1); // seq ext
368 
369  put_bits(&s->pb, 1, s->avctx->profile == AV_PROFILE_MPEG2_422); // escx 1 for 4:2:2 profile
370 
371  put_bits(&s->pb, 3, s->avctx->profile); // profile
372  put_bits(&s->pb, 4, s->avctx->level); // level
373 
374  put_bits(&s->pb, 1, s->progressive_sequence);
375  put_bits(&s->pb, 2, s->chroma_format);
376  put_bits(&s->pb, 2, s->width >> 12);
377  put_bits(&s->pb, 2, s->height >> 12);
378  put_bits(&s->pb, 12, v >> 18); // bitrate ext
379  put_bits(&s->pb, 1, 1); // marker
380  put_bits(&s->pb, 8, vbv_buffer_size >> 10); // vbv buffer ext
381  put_bits(&s->pb, 1, s->low_delay);
382  put_bits(&s->pb, 2, mpeg12->frame_rate_ext.num-1); // frame_rate_ext_n
383  put_bits(&s->pb, 5, mpeg12->frame_rate_ext.den-1); // frame_rate_ext_d
384 
385  side_data = av_frame_get_side_data(s->current_picture_ptr->f, AV_FRAME_DATA_PANSCAN);
386  if (side_data) {
387  const AVPanScan *pan_scan = (AVPanScan *)side_data->data;
388  if (pan_scan->width && pan_scan->height) {
389  width = pan_scan->width >> 4;
390  height = pan_scan->height >> 4;
391  }
392  }
393 
394  use_seq_disp_ext = (width != s->width ||
395  height != s->height ||
396  s->avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
397  s->avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
398  s->avctx->colorspace != AVCOL_SPC_UNSPECIFIED ||
399  mpeg12->video_format != VIDEO_FORMAT_UNSPECIFIED);
400 
401  if (mpeg12->seq_disp_ext == 1 ||
402  (mpeg12->seq_disp_ext == -1 && use_seq_disp_ext)) {
404  put_bits(&s->pb, 4, 2); // sequence display extension
405  put_bits(&s->pb, 3, mpeg12->video_format); // video_format
406  put_bits(&s->pb, 1, 1); // colour_description
407  put_bits(&s->pb, 8, s->avctx->color_primaries); // colour_primaries
408  put_bits(&s->pb, 8, s->avctx->color_trc); // transfer_characteristics
409  put_bits(&s->pb, 8, s->avctx->colorspace); // matrix_coefficients
410  put_bits(&s->pb, 14, width); // display_horizontal_size
411  put_bits(&s->pb, 1, 1); // marker_bit
412  put_bits(&s->pb, 14, height); // display_vertical_size
413  put_bits(&s->pb, 3, 0); // remaining 3 bits are zero padding
414  }
415  }
416 
418  put_bits(&s->pb, 1, mpeg12->drop_frame_timecode); // drop frame flag
419  /* time code: we must convert from the real frame rate to a
420  * fake MPEG frame rate in case of low frame rate */
421  fps = (framerate.num + framerate.den / 2) / framerate.den;
422  time_code = s->current_picture_ptr->coded_picture_number +
423  mpeg12->timecode_frame_start;
424 
425  mpeg12->gop_picture_number = s->current_picture_ptr->coded_picture_number;
426 
427  av_assert0(mpeg12->drop_frame_timecode == !!(mpeg12->tc.flags & AV_TIMECODE_FLAG_DROPFRAME));
428  if (mpeg12->drop_frame_timecode)
429  time_code = av_timecode_adjust_ntsc_framenum2(time_code, fps);
430 
431  put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
432  put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
433  put_bits(&s->pb, 1, 1);
434  put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
435  put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
436  put_bits(&s->pb, 1, !!(s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) ||
437  s->intra_only || !mpeg12->gop_picture_number);
438  put_bits(&s->pb, 1, 0); // broken link
439 }
440 
441 static inline void encode_mb_skip_run(MpegEncContext *s, int run)
442 {
443  while (run >= 33) {
444  put_bits(&s->pb, 11, 0x008);
445  run -= 33;
446  }
449 }
450 
451 static av_always_inline void put_qscale(MpegEncContext *s)
452 {
453  put_bits(&s->pb, 5, s->qscale);
454 }
455 
457 {
458  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->height > 2800) {
459  put_header(s, SLICE_MIN_START_CODE + (s->mb_y & 127));
460  /* slice_vertical_position_extension */
461  put_bits(&s->pb, 3, s->mb_y >> 7);
462  } else {
464  }
465  put_qscale(s);
466  /* slice extra information */
467  put_bits(&s->pb, 1, 0);
468 }
469 
471 {
472  MPEG12EncContext *const mpeg12 = (MPEG12EncContext*)s;
473  AVFrameSideData *side_data;
474  mpeg1_encode_sequence_header(s);
475 
476  /* MPEG-1 picture header */
478  /* temporal reference */
479 
480  // RAL: s->picture_number instead of s->fake_picture_number
481  put_bits(&s->pb, 10,
482  (s->picture_number - mpeg12->gop_picture_number) & 0x3ff);
483  put_bits(&s->pb, 3, s->pict_type);
484 
485  s->vbv_delay_pos = put_bytes_count(&s->pb, 0);
486  put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
487 
488  // RAL: Forward f_code also needed for B-frames
489  if (s->pict_type == AV_PICTURE_TYPE_P ||
490  s->pict_type == AV_PICTURE_TYPE_B) {
491  put_bits(&s->pb, 1, 0); /* half pel coordinates */
492  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
493  put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
494  else
495  put_bits(&s->pb, 3, 7); /* forward_f_code */
496  }
497 
498  // RAL: Backward f_code necessary for B-frames
499  if (s->pict_type == AV_PICTURE_TYPE_B) {
500  put_bits(&s->pb, 1, 0); /* half pel coordinates */
501  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
502  put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
503  else
504  put_bits(&s->pb, 3, 7); /* backward_f_code */
505  }
506 
507  put_bits(&s->pb, 1, 0); /* extra bit picture */
508 
509  s->frame_pred_frame_dct = 1;
510  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
512  put_bits(&s->pb, 4, 8); /* pic ext */
513  if (s->pict_type == AV_PICTURE_TYPE_P ||
514  s->pict_type == AV_PICTURE_TYPE_B) {
515  put_bits(&s->pb, 4, s->f_code);
516  put_bits(&s->pb, 4, s->f_code);
517  } else {
518  put_bits(&s->pb, 8, 255);
519  }
520  if (s->pict_type == AV_PICTURE_TYPE_B) {
521  put_bits(&s->pb, 4, s->b_code);
522  put_bits(&s->pb, 4, s->b_code);
523  } else {
524  put_bits(&s->pb, 8, 255);
525  }
526  put_bits(&s->pb, 2, s->intra_dc_precision);
527 
528  av_assert0(s->picture_structure == PICT_FRAME);
529  put_bits(&s->pb, 2, s->picture_structure);
530  if (s->progressive_sequence)
531  put_bits(&s->pb, 1, 0); /* no repeat */
532  else
533  put_bits(&s->pb, 1, !!(s->current_picture_ptr->f->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST));
534  /* XXX: optimize the generation of this flag with entropy measures */
535  s->frame_pred_frame_dct = s->progressive_sequence;
536 
537  put_bits(&s->pb, 1, s->frame_pred_frame_dct);
538  put_bits(&s->pb, 1, s->concealment_motion_vectors);
539  put_bits(&s->pb, 1, s->q_scale_type);
540  put_bits(&s->pb, 1, s->intra_vlc_format);
541  put_bits(&s->pb, 1, s->alternate_scan);
542  put_bits(&s->pb, 1, s->repeat_first_field);
543  s->progressive_frame = s->progressive_sequence;
544  /* chroma_420_type */
545  put_bits(&s->pb, 1, s->chroma_format ==
546  CHROMA_420 ? s->progressive_frame : 0);
547  put_bits(&s->pb, 1, s->progressive_frame);
548  put_bits(&s->pb, 1, 0); /* composite_display_flag */
549  }
550  if (mpeg12->scan_offset) {
551  int i;
552 
554  for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
555  put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
556  }
557  side_data = av_frame_get_side_data(s->current_picture_ptr->f,
559  if (side_data) {
560  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
561  uint8_t fpa_type;
562 
563  switch (stereo->type) {
565  fpa_type = 0x03;
566  break;
568  fpa_type = 0x04;
569  break;
570  case AV_STEREO3D_2D:
571  fpa_type = 0x08;
572  break;
574  fpa_type = 0x23;
575  break;
576  default:
577  fpa_type = 0;
578  break;
579  }
580 
581  if (fpa_type != 0) {
583  put_bits(&s->pb, 8, 'J'); // S3D_video_format_signaling_identifier
584  put_bits(&s->pb, 8, 'P');
585  put_bits(&s->pb, 8, '3');
586  put_bits(&s->pb, 8, 'D');
587  put_bits(&s->pb, 8, 0x03); // S3D_video_format_length
588 
589  put_bits(&s->pb, 1, 1); // reserved_bit
590  put_bits(&s->pb, 7, fpa_type); // S3D_video_format_type
591  put_bits(&s->pb, 8, 0x04); // reserved_data[0]
592  put_bits(&s->pb, 8, 0xFF); // reserved_data[1]
593  }
594  }
595 
596  if (CONFIG_MPEG2VIDEO_ENCODER && mpeg12->a53_cc) {
597  side_data = av_frame_get_side_data(s->current_picture_ptr->f,
599  if (side_data) {
600  if (side_data->size <= A53_MAX_CC_COUNT * 3 && side_data->size % 3 == 0) {
601  int i = 0;
602 
604 
605  put_bits(&s->pb, 8, 'G'); // user_identifier
606  put_bits(&s->pb, 8, 'A');
607  put_bits(&s->pb, 8, '9');
608  put_bits(&s->pb, 8, '4');
609  put_bits(&s->pb, 8, 3); // user_data_type_code
610  put_bits(&s->pb, 8,
611  (side_data->size / 3 & A53_MAX_CC_COUNT) | 0x40); // flags, cc_count
612  put_bits(&s->pb, 8, 0xff); // em_data
613 
614  for (i = 0; i < side_data->size; i++)
615  put_bits(&s->pb, 8, side_data->data[i]);
616 
617  put_bits(&s->pb, 8, 0xff); // marker_bits
618  } else {
619  av_log(s->avctx, AV_LOG_WARNING,
620  "Closed Caption size (%"SIZE_SPECIFIER") can not exceed "
621  "93 bytes and must be a multiple of 3\n", side_data->size);
622  }
623  }
624  }
625 
626  s->mb_y = 0;
628 }
629 
630 static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
631  int has_mv, int field_motion)
632 {
633  put_bits(&s->pb, n, bits);
634  if (!s->frame_pred_frame_dct) {
635  if (has_mv)
636  /* motion_type: frame/field */
637  put_bits(&s->pb, 2, 2 - field_motion);
638  put_bits(&s->pb, 1, s->interlaced_dct);
639  }
640 }
641 
642 // RAL: Parameter added: f_or_b_code
643 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
644 {
645  if (val == 0) {
646  /* zero vector, corresponds to ff_mpeg12_mbMotionVectorTable[0] */
647  put_bits(&s->pb, 1, 0x01);
648  } else {
649  int code, sign, bits;
650  int bit_size = f_or_b_code - 1;
651  int range = 1 << bit_size;
652  /* modulo encoding */
653  val = sign_extend(val, 5 + bit_size);
654 
655  if (val >= 0) {
656  val--;
657  code = (val >> bit_size) + 1;
658  bits = val & (range - 1);
659  sign = 0;
660  } else {
661  val = -val;
662  val--;
663  code = (val >> bit_size) + 1;
664  bits = val & (range - 1);
665  sign = 1;
666  }
667 
668  av_assert2(code > 0 && code <= 16);
669 
670  put_bits(&s->pb,
673 
674  put_bits(&s->pb, 1, sign);
675  if (bit_size > 0)
676  put_bits(&s->pb, bit_size, bits);
677  }
678 }
679 
680 static inline void encode_dc(MpegEncContext *s, int diff, int component)
681 {
682  unsigned int diff_u = diff + 255;
683  if (diff_u >= 511) {
684  int index;
685 
686  if (diff < 0) {
687  index = av_log2_16bit(-2 * diff);
688  diff--;
689  } else {
690  index = av_log2_16bit(2 * diff);
691  }
692  if (component == 0)
693  put_bits(&s->pb,
697  else
698  put_bits(&s->pb,
702  } else {
703  if (component == 0)
704  put_bits(&s->pb,
705  mpeg1_lum_dc_uni[diff + 255] & 0xFF,
706  mpeg1_lum_dc_uni[diff + 255] >> 8);
707  else
708  put_bits(&s->pb,
709  mpeg1_chr_dc_uni[diff + 255] & 0xFF,
710  mpeg1_chr_dc_uni[diff + 255] >> 8);
711  }
712 }
713 
714 static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n)
715 {
716  int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
717  int code, component;
718  const uint16_t (*table_vlc)[2] = ff_mpeg1_vlc_table;
719 
720  last_index = s->block_last_index[n];
721 
722  /* DC coef */
723  if (s->mb_intra) {
724  component = (n <= 3 ? 0 : (n & 1) + 1);
725  dc = block[0]; /* overflow is impossible */
726  diff = dc - s->last_dc[component];
727  encode_dc(s, diff, component);
728  s->last_dc[component] = dc;
729  i = 1;
730  if (s->intra_vlc_format)
731  table_vlc = ff_mpeg2_vlc_table;
732  } else {
733  /* encode the first coefficient: needs to be done here because
734  * it is handled slightly differently */
735  level = block[0];
736  if (abs(level) == 1) {
737  code = ((uint32_t)level >> 31); /* the sign bit */
738  put_bits(&s->pb, 2, code | 0x02);
739  i = 1;
740  } else {
741  i = 0;
742  last_non_zero = -1;
743  goto next_coef;
744  }
745  }
746 
747  /* now quantify & encode AC coefs */
748  last_non_zero = i - 1;
749 
750  for (; i <= last_index; i++) {
751  j = s->intra_scantable.permutated[i];
752  level = block[j];
753 
754 next_coef:
755  /* encode using VLC */
756  if (level != 0) {
757  run = i - last_non_zero - 1;
758 
759  alevel = level;
760  MASK_ABS(sign, alevel);
761  sign &= 1;
762 
763  if (alevel <= mpeg12_max_level[run]) {
764  code = mpeg12_index_run[run] + alevel - 1;
765  /* store the VLC & sign at once */
766  put_bits(&s->pb, table_vlc[code][1] + 1,
767  (table_vlc[code][0] << 1) + sign);
768  } else {
769  /* Escape seems to be pretty rare <5% so I do not optimize it;
770  * the following value is the common escape value for both
771  * possible tables (i.e. table_vlc[111]). */
772  put_bits(&s->pb, 6, 0x01);
773  /* escape: only clip in this case */
774  put_bits(&s->pb, 6, run);
775  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
776  if (alevel < 128) {
777  put_sbits(&s->pb, 8, level);
778  } else {
779  if (level < 0)
780  put_bits(&s->pb, 16, 0x8001 + level + 255);
781  else
782  put_sbits(&s->pb, 16, level);
783  }
784  } else {
785  put_sbits(&s->pb, 12, level);
786  }
787  }
788  last_non_zero = i;
789  }
790  }
791  /* end of block */
792  put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
793 }
794 
795 static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s,
796  int16_t block[8][64],
797  int motion_x, int motion_y,
798  int mb_block_count,
799  int chroma_y_shift)
800 {
801 /* MPEG-1 is always 420. */
802 #define IS_MPEG1(s) (chroma_y_shift == 1 && (s)->codec_id == AV_CODEC_ID_MPEG1VIDEO)
803  int i, cbp;
804  const int mb_x = s->mb_x;
805  const int mb_y = s->mb_y;
806  const int first_mb = mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
807 
808  /* compute cbp */
809  cbp = 0;
810  for (i = 0; i < mb_block_count; i++)
811  if (s->block_last_index[i] >= 0)
812  cbp |= 1 << (mb_block_count - 1 - i);
813 
814  if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 &&
815  (mb_x != s->mb_width - 1 ||
816  (mb_y != s->end_mb_y - 1 && IS_MPEG1(s))) &&
817  ((s->pict_type == AV_PICTURE_TYPE_P && (motion_x | motion_y) == 0) ||
818  (s->pict_type == AV_PICTURE_TYPE_B && s->mv_dir == s->last_mv_dir &&
819  (((s->mv_dir & MV_DIR_FORWARD)
820  ? ((s->mv[0][0][0] - s->last_mv[0][0][0]) |
821  (s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
822  ((s->mv_dir & MV_DIR_BACKWARD)
823  ? ((s->mv[1][0][0] - s->last_mv[1][0][0]) |
824  (s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
825  s->mb_skip_run++;
826  s->qscale -= s->dquant;
827  s->skip_count++;
828  s->misc_bits++;
829  s->last_bits++;
830  if (s->pict_type == AV_PICTURE_TYPE_P) {
831  s->last_mv[0][0][0] =
832  s->last_mv[0][0][1] =
833  s->last_mv[0][1][0] =
834  s->last_mv[0][1][1] = 0;
835  }
836  } else {
837  if (first_mb) {
838  av_assert0(s->mb_skip_run == 0);
839  encode_mb_skip_run(s, s->mb_x);
840  } else {
841  encode_mb_skip_run(s, s->mb_skip_run);
842  }
843 
844  if (s->pict_type == AV_PICTURE_TYPE_I) {
845  if (s->dquant && cbp) {
846  /* macroblock_type: macroblock_quant = 1 */
847  put_mb_modes(s, 2, 1, 0, 0);
848  put_qscale(s);
849  } else {
850  /* macroblock_type: macroblock_quant = 0 */
851  put_mb_modes(s, 1, 1, 0, 0);
852  s->qscale -= s->dquant;
853  }
854  s->misc_bits += get_bits_diff(s);
855  s->i_count++;
856  } else if (s->mb_intra) {
857  if (s->dquant && cbp) {
858  put_mb_modes(s, 6, 0x01, 0, 0);
859  put_qscale(s);
860  } else {
861  put_mb_modes(s, 5, 0x03, 0, 0);
862  s->qscale -= s->dquant;
863  }
864  s->misc_bits += get_bits_diff(s);
865  s->i_count++;
866  memset(s->last_mv, 0, sizeof(s->last_mv));
867  } else if (s->pict_type == AV_PICTURE_TYPE_P) {
868  if (s->mv_type == MV_TYPE_16X16) {
869  if (cbp != 0) {
870  if ((motion_x | motion_y) == 0) {
871  if (s->dquant) {
872  /* macroblock_pattern & quant */
873  put_mb_modes(s, 5, 1, 0, 0);
874  put_qscale(s);
875  } else {
876  /* macroblock_pattern only */
877  put_mb_modes(s, 2, 1, 0, 0);
878  }
879  s->misc_bits += get_bits_diff(s);
880  } else {
881  if (s->dquant) {
882  put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */
883  put_qscale(s);
884  } else {
885  put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */
886  }
887  s->misc_bits += get_bits_diff(s);
888  // RAL: f_code parameter added
889  mpeg1_encode_motion(s,
890  motion_x - s->last_mv[0][0][0],
891  s->f_code);
892  // RAL: f_code parameter added
893  mpeg1_encode_motion(s,
894  motion_y - s->last_mv[0][0][1],
895  s->f_code);
896  s->mv_bits += get_bits_diff(s);
897  }
898  } else {
899  put_bits(&s->pb, 3, 1); /* motion only */
900  if (!s->frame_pred_frame_dct)
901  put_bits(&s->pb, 2, 2); /* motion_type: frame */
902  s->misc_bits += get_bits_diff(s);
903  // RAL: f_code parameter added
904  mpeg1_encode_motion(s,
905  motion_x - s->last_mv[0][0][0],
906  s->f_code);
907  // RAL: f_code parameter added
908  mpeg1_encode_motion(s,
909  motion_y - s->last_mv[0][0][1],
910  s->f_code);
911  s->qscale -= s->dquant;
912  s->mv_bits += get_bits_diff(s);
913  }
914  s->last_mv[0][1][0] = s->last_mv[0][0][0] = motion_x;
915  s->last_mv[0][1][1] = s->last_mv[0][0][1] = motion_y;
916  } else {
917  av_assert2(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD);
918 
919  if (cbp) {
920  if (s->dquant) {
921  put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
922  put_qscale(s);
923  } else {
924  put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
925  }
926  } else {
927  put_bits(&s->pb, 3, 1); /* motion only */
928  put_bits(&s->pb, 2, 1); /* motion_type: field */
929  s->qscale -= s->dquant;
930  }
931  s->misc_bits += get_bits_diff(s);
932  for (i = 0; i < 2; i++) {
933  put_bits(&s->pb, 1, s->field_select[0][i]);
934  mpeg1_encode_motion(s,
935  s->mv[0][i][0] - s->last_mv[0][i][0],
936  s->f_code);
937  mpeg1_encode_motion(s,
938  s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
939  s->f_code);
940  s->last_mv[0][i][0] = s->mv[0][i][0];
941  s->last_mv[0][i][1] = 2 * s->mv[0][i][1];
942  }
943  s->mv_bits += get_bits_diff(s);
944  }
945  if (cbp) {
946  if (chroma_y_shift) {
947  put_bits(&s->pb,
948  ff_mpeg12_mbPatTable[cbp][1],
949  ff_mpeg12_mbPatTable[cbp][0]);
950  } else {
951  put_bits(&s->pb,
952  ff_mpeg12_mbPatTable[cbp >> 2][1],
953  ff_mpeg12_mbPatTable[cbp >> 2][0]);
954  put_sbits(&s->pb, 2, cbp);
955  }
956  }
957  } else {
958  if (s->mv_type == MV_TYPE_16X16) {
959  if (cbp) { // With coded bloc pattern
960  if (s->dquant) {
961  if (s->mv_dir == MV_DIR_FORWARD)
962  put_mb_modes(s, 6, 3, 1, 0);
963  else
964  put_mb_modes(s, 8 - s->mv_dir, 2, 1, 0);
965  put_qscale(s);
966  } else {
967  put_mb_modes(s, 5 - s->mv_dir, 3, 1, 0);
968  }
969  } else { // No coded bloc pattern
970  put_bits(&s->pb, 5 - s->mv_dir, 2);
971  if (!s->frame_pred_frame_dct)
972  put_bits(&s->pb, 2, 2); /* motion_type: frame */
973  s->qscale -= s->dquant;
974  }
975  s->misc_bits += get_bits_diff(s);
976  if (s->mv_dir & MV_DIR_FORWARD) {
977  mpeg1_encode_motion(s,
978  s->mv[0][0][0] - s->last_mv[0][0][0],
979  s->f_code);
980  mpeg1_encode_motion(s,
981  s->mv[0][0][1] - s->last_mv[0][0][1],
982  s->f_code);
983  s->last_mv[0][0][0] =
984  s->last_mv[0][1][0] = s->mv[0][0][0];
985  s->last_mv[0][0][1] =
986  s->last_mv[0][1][1] = s->mv[0][0][1];
987  }
988  if (s->mv_dir & MV_DIR_BACKWARD) {
989  mpeg1_encode_motion(s,
990  s->mv[1][0][0] - s->last_mv[1][0][0],
991  s->b_code);
992  mpeg1_encode_motion(s,
993  s->mv[1][0][1] - s->last_mv[1][0][1],
994  s->b_code);
995  s->last_mv[1][0][0] =
996  s->last_mv[1][1][0] = s->mv[1][0][0];
997  s->last_mv[1][0][1] =
998  s->last_mv[1][1][1] = s->mv[1][0][1];
999  }
1000  } else {
1001  av_assert2(s->mv_type == MV_TYPE_FIELD);
1002  av_assert2(!s->frame_pred_frame_dct);
1003  if (cbp) { // With coded bloc pattern
1004  if (s->dquant) {
1005  if (s->mv_dir == MV_DIR_FORWARD)
1006  put_mb_modes(s, 6, 3, 1, 1);
1007  else
1008  put_mb_modes(s, 8 - s->mv_dir, 2, 1, 1);
1009  put_qscale(s);
1010  } else {
1011  put_mb_modes(s, 5 - s->mv_dir, 3, 1, 1);
1012  }
1013  } else { // No coded bloc pattern
1014  put_bits(&s->pb, 5 - s->mv_dir, 2);
1015  put_bits(&s->pb, 2, 1); /* motion_type: field */
1016  s->qscale -= s->dquant;
1017  }
1018  s->misc_bits += get_bits_diff(s);
1019  if (s->mv_dir & MV_DIR_FORWARD) {
1020  for (i = 0; i < 2; i++) {
1021  put_bits(&s->pb, 1, s->field_select[0][i]);
1022  mpeg1_encode_motion(s,
1023  s->mv[0][i][0] - s->last_mv[0][i][0],
1024  s->f_code);
1025  mpeg1_encode_motion(s,
1026  s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
1027  s->f_code);
1028  s->last_mv[0][i][0] = s->mv[0][i][0];
1029  s->last_mv[0][i][1] = s->mv[0][i][1] * 2;
1030  }
1031  }
1032  if (s->mv_dir & MV_DIR_BACKWARD) {
1033  for (i = 0; i < 2; i++) {
1034  put_bits(&s->pb, 1, s->field_select[1][i]);
1035  mpeg1_encode_motion(s,
1036  s->mv[1][i][0] - s->last_mv[1][i][0],
1037  s->b_code);
1038  mpeg1_encode_motion(s,
1039  s->mv[1][i][1] - (s->last_mv[1][i][1] >> 1),
1040  s->b_code);
1041  s->last_mv[1][i][0] = s->mv[1][i][0];
1042  s->last_mv[1][i][1] = s->mv[1][i][1] * 2;
1043  }
1044  }
1045  }
1046  s->mv_bits += get_bits_diff(s);
1047  if (cbp) {
1048  if (chroma_y_shift) {
1049  put_bits(&s->pb,
1050  ff_mpeg12_mbPatTable[cbp][1],
1051  ff_mpeg12_mbPatTable[cbp][0]);
1052  } else {
1053  put_bits(&s->pb,
1054  ff_mpeg12_mbPatTable[cbp >> 2][1],
1055  ff_mpeg12_mbPatTable[cbp >> 2][0]);
1056  put_sbits(&s->pb, 2, cbp);
1057  }
1058  }
1059  }
1060  for (i = 0; i < mb_block_count; i++)
1061  if (cbp & (1 << (mb_block_count - 1 - i)))
1062  mpeg1_encode_block(s, block[i], i);
1063  s->mb_skip_run = 0;
1064  if (s->mb_intra)
1065  s->i_tex_bits += get_bits_diff(s);
1066  else
1067  s->p_tex_bits += get_bits_diff(s);
1068  }
1069 }
1070 
1071 void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64],
1072  int motion_x, int motion_y)
1073 {
1074  if (s->chroma_format == CHROMA_420)
1075  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6, 1);
1076  else
1077  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8, 0);
1078 }
1079 
1080 static av_cold void mpeg12_encode_init_static(void)
1081 {
1082  ff_rl_init_level_run(mpeg12_max_level, mpeg12_index_run,
1084 
1085  ff_mpeg1_init_uni_ac_vlc(mpeg12_max_level, mpeg12_index_run,
1086  ff_mpeg1_vlc_table, uni_mpeg1_ac_vlc_len);
1087  ff_mpeg1_init_uni_ac_vlc(mpeg12_max_level, mpeg12_index_run,
1088  ff_mpeg2_vlc_table, uni_mpeg2_ac_vlc_len);
1089 
1090  /* build unified dc encoding tables */
1091  for (int i = -255; i < 256; i++) {
1092  int adiff, index;
1093  int bits, code;
1094  int diff = i;
1095 
1096  adiff = FFABS(diff);
1097  if (diff < 0)
1098  diff--;
1099  index = av_log2(2 * adiff);
1100 
1104  mpeg1_lum_dc_uni[i + 255] = bits + (code << 8);
1105 
1109  mpeg1_chr_dc_uni[i + 255] = bits + (code << 8);
1110  }
1111 
1112  for (int f_code = 1; f_code <= MAX_FCODE; f_code++)
1113  for (int mv = -MAX_DMV; mv <= MAX_DMV; mv++) {
1114  int len;
1115 
1116  if (mv == 0) {
1117  len = 1; /* ff_mpeg12_mbMotionVectorTable[0][1] */
1118  } else {
1119  int val, bit_size, code;
1120 
1121  bit_size = f_code - 1;
1122 
1123  val = mv;
1124  if (val < 0)
1125  val = -val;
1126  val--;
1127  code = (val >> bit_size) + 1;
1128  if (code < 17)
1130  1 + bit_size;
1131  else
1132  len = 10 /* ff_mpeg12_mbMotionVectorTable[16][1] */ +
1133  2 + bit_size;
1134  }
1135 
1136  mv_penalty[f_code][mv + MAX_DMV] = len;
1137  }
1138 
1139 
1140  for (int f_code = MAX_FCODE; f_code > 0; f_code--)
1141  for (int mv = -(8 << f_code); mv < (8 << f_code); mv++)
1142  fcode_tab[mv + MAX_MV] = f_code;
1143 }
1144 
1146 {
1147  static AVOnce init_static_once = AV_ONCE_INIT;
1148 
1149  s->y_dc_scale_table =
1150  s->c_dc_scale_table = ff_mpeg12_dc_scale_table[s->intra_dc_precision];
1151 
1152  s->me.mv_penalty = mv_penalty;
1153  s->fcode_tab = fcode_tab;
1154  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1155  s->min_qcoeff = -255;
1156  s->max_qcoeff = 255;
1157  } else {
1158  s->min_qcoeff = -2047;
1159  s->max_qcoeff = 2047;
1160  s->mpeg_quant = 1;
1161  }
1162  if (s->intra_vlc_format) {
1163  s->intra_ac_vlc_length =
1164  s->intra_ac_vlc_last_length = uni_mpeg2_ac_vlc_len;
1165  } else {
1166  s->intra_ac_vlc_length =
1167  s->intra_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1168  }
1169  s->inter_ac_vlc_length =
1170  s->inter_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1171 
1172  ff_thread_once(&init_static_once, mpeg12_encode_init_static);
1173 }
1174 
1175 #define OFFSET(x) offsetof(MPEG12EncContext, x)
1176 #define VE AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
1177 #define COMMON_OPTS \
1178  { "gop_timecode", "MPEG GOP Timecode in hh:mm:ss[:;.]ff format. Overrides timecode_frame_start.", \
1179  OFFSET(tc_opt_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE },\
1180  { "drop_frame_timecode", "Timecode is in drop frame format.", \
1181  OFFSET(drop_frame_timecode), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1182  { "scan_offset", "Reserve space for SVCD scan offset user data.", \
1183  OFFSET(scan_offset), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1184  { "timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", \
1185  OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = -1 }, -1, INT64_MAX, VE}, \
1186  FF_MPV_COMMON_BFRAME_OPTS
1187 
1188 static const AVOption mpeg1_options[] = {
1189  COMMON_OPTS
1192  { NULL },
1193 };
1194 
1195 static const AVOption mpeg2_options[] = {
1196  COMMON_OPTS
1197  { "intra_vlc", "Use MPEG-2 intra VLC table.",
1198  FF_MPV_OFFSET(intra_vlc_format), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1199  { "non_linear_quant", "Use nonlinear quantizer.", FF_MPV_OFFSET(q_scale_type), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1200  { "alternate_scan", "Enable alternate scantable.", FF_MPV_OFFSET(alternate_scan), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1201  { "a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
1202  { "seq_disp_ext", "Write sequence_display_extension blocks.", OFFSET(seq_disp_ext), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, .unit = "seq_disp_ext" },
1203  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, VE, .unit = "seq_disp_ext" },
1204  { "never", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, VE, .unit = "seq_disp_ext" },
1205  { "always", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, VE, .unit = "seq_disp_ext" },
1206  { "video_format", "Video_format in the sequence_display_extension indicating the source of the video.", OFFSET(video_format), AV_OPT_TYPE_INT, { .i64 = VIDEO_FORMAT_UNSPECIFIED }, 0, 7, VE, .unit = "video_format" },
1207  { "component", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_COMPONENT }, 0, 0, VE, .unit = "video_format" },
1208  { "pal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_PAL }, 0, 0, VE, .unit = "video_format" },
1209  { "ntsc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_NTSC }, 0, 0, VE, .unit = "video_format" },
1210  { "secam", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_SECAM }, 0, 0, VE, .unit = "video_format" },
1211  { "mac", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_MAC }, 0, 0, VE, .unit = "video_format" },
1212  { "unspecified", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_UNSPECIFIED}, 0, 0, VE, .unit = "video_format" },
1213 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, { .i64 = value }, 0, 0, VE, .unit = "avctx.level"
1214  { LEVEL("high", 4) },
1215  { LEVEL("high1440", 6) },
1216  { LEVEL("main", 8) },
1217  { LEVEL("low", 10) },
1218 #undef LEVEL
1222  { NULL },
1223 };
1224 
1225 #define mpeg12_class(x) \
1226 static const AVClass mpeg ## x ## _class = { \
1227  .class_name = "mpeg" # x "video encoder", \
1228  .item_name = av_default_item_name, \
1229  .option = mpeg ## x ## _options, \
1230  .version = LIBAVUTIL_VERSION_INT, \
1231 };
1232 
1233 mpeg12_class(1)
1234 mpeg12_class(2)
1235 
1237  .p.name = "mpeg1video",
1238  CODEC_LONG_NAME("MPEG-1 video"),
1239  .p.type = AVMEDIA_TYPE_VIDEO,
1240  .p.id = AV_CODEC_ID_MPEG1VIDEO,
1241  .priv_data_size = sizeof(MPEG12EncContext),
1242  .init = encode_init,
1244  .close = ff_mpv_encode_end,
1245  .p.supported_framerates = ff_mpeg12_frame_rate_tab + 1,
1246  .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
1247  AV_PIX_FMT_NONE },
1248  .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 |
1269  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1270  .p.priv_class = &mpeg2_class,
1271 };
1272 #endif /* CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER */
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:267
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
level
uint8_t level
Definition: svq3.c:205
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:158
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:199
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:420
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:947
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:240
mpegvideoenc.h
mv
static const int8_t mv[256][2]
Definition: 4xm.c:81
ff_rl_init_level_run
av_cold void ff_rl_init_level_run(uint8_t max_level[MAX_LEVEL+1], uint8_t index_run[MAX_RUN+1], const uint8_t table_run[], const uint8_t table_level[], int n)
Initialize max_level and index_run from table_run and table_level; this is equivalent to initializing...
Definition: rl.c: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:126
av_log2_16bit
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
MPEG12_RL_NB_ELEMS
#define MPEG12_RL_NB_ELEMS
Definition: mpeg12vlc.h:52
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
MAX_DMV
#define MAX_DMV
Definition: motion_est.h:37
AVOption
AVOption.
Definition: opt.h:346
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
put_bytes_count
static int put_bytes_count(const PutBitContext *s, int round_up)
Definition: put_bits.h:100
FFCodec
Definition: codec_internal.h:127
MASK_ABS
#define MASK_ABS(mask, level)
Definition: mathops.h:167
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_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
mpegutils.h
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:264
ff_mpeg12_vlc_dc_lum_bits
const unsigned char ff_mpeg12_vlc_dc_lum_bits[12]
Definition: mpeg12data.c:56
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:639
FF_MPV_COMMON_MOTION_EST_OPTS
#define FF_MPV_COMMON_MOTION_EST_OPTS
Definition: mpegvideoenc.h:127
MAX_FCODE
#define MAX_FCODE
Definition: mpegutils.h:36
ff_mpeg12_mbAddrIncrTable
const uint8_t ff_mpeg12_mbAddrIncrTable[36][2]
Definition: mpeg12data.c:167
AV_STEREO3D_SIDEBYSIDE
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:64
ff_mpv_encode_picture
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)
Definition: mpegvideo_enc.c:1754
FF_MPV_COMMON_OPTS
#define FF_MPV_COMMON_OPTS
Definition: mpegvideoenc.h:84
ff_mpeg2_frame_rate_tab
const AVRational ff_mpeg2_frame_rate_tab[]
Definition: mpeg12data.c:293
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:454
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:253
mpeg12vlc.h
val
static double val(void *priv, double ch)
Definition: aeval.c:78
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:296
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:321
avassert.h
mpeg12.h
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVFrameSideData::size
size_t size
Definition: frame.h:253
av_cold
#define av_cold
Definition: attributes.h:90
MAX_MV
#define MAX_MV
Definition: motion_est.h:35
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:626
A53_MAX_CC_COUNT
#define A53_MAX_CC_COUNT
Definition: mpeg12dec.c:63
width
#define width
stereo3d.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
ff_mpeg1_aspect
const float ff_mpeg1_aspect[16]
Definition: mpeg12data.c:359
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
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:82
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:73
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
ff_mpeg1video_encoder
const FFCodec ff_mpeg1video_encoder
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:73
if
if(ret)
Definition: filter_design.txt:179
framerate
float framerate
Definition: av1_levels.c:29
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:204
SLICE_MIN_START_CODE
#define SLICE_MIN_START_CODE
Definition: mpeg12.h:32
AV_LEVEL_UNKNOWN
#define AV_LEVEL_UNKNOWN
Definition: defs.h:196
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
profiles.h
mathops.h
ff_mpv_encode_end
av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:987
abs
#define abs(x)
Definition: cuda_runtime.h:35
COMMON_OPTS
#define COMMON_OPTS
Definition: f_segment.c:263
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1783
AVOnce
#define AVOnce
Definition: thread.h:202
index
int index
Definition: gxfenc.c:90
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:544
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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:252
PICTURE_START_CODE
#define PICTURE_START_CODE
Definition: mpeg12.h:31
USER_START_CODE
#define USER_START_CODE
Definition: cavs.h:40
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2557
header
static const uint8_t header[24]
Definition: sdr2.c:68
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:165
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:114
mpegvideodata.h
attributes.h
MV_TYPE_FIELD
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:270
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:67
CHROMA_420
#define CHROMA_420
Definition: mpegvideo.h:455
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
AV_STEREO3D_TOPBOTTOM
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
Definition: stereo3d.h:76
av_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:194
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:612
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
FF_MPEG2_PROFILE_OPTS
#define FF_MPEG2_PROFILE_OPTS
Definition: profiles.h:47
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:259
ff_mpeg12_frame_rate_tab
const AVRational ff_mpeg12_frame_rate_tab[]
Definition: mpeg12framerate.c:24
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:352
ret
ret
Definition: filter_design.txt:187
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1379
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:177
ff_mpeg1_encode_picture_header
void ff_mpeg1_encode_picture_header(MpegEncContext *s)
ff_mpeg1_vlc_table
const uint16_t ff_mpeg1_vlc_table[MPEG12_RL_NB_ELEMS+2][2]
Definition: mpeg12data.c:67
mpeg12data.h
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
OFFSET
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your see the OFFSET() macro
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
AV_PROFILE_MPEG2_HIGH
#define AV_PROFILE_MPEG2_HIGH
Definition: defs.h:100
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1639
ff_mpeg2_vlc_table
const uint16_t ff_mpeg2_vlc_table[MPEG12_RL_NB_ELEMS+2][2]
Definition: mpeg12data.c:100
AV_PROFILE_MPEG2_422
#define AV_PROFILE_MPEG2_422
Definition: defs.h:99
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:133
AV_PROFILE_MPEG2_MAIN
#define AV_PROFILE_MPEG2_MAIN
Definition: defs.h:103
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
LEVEL
#define LEVEL(name, value)
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
tc
#define tc
Definition: regdef.h:69
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
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:77
ff_mpv_encode_init
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:310
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:250
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:263
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
rl.h
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
ff_mpeg12_vlc_dc_lum_code
const uint16_t ff_mpeg12_vlc_dc_lum_code[12]
Definition: mpeg12data.c:53
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
VE
#define VE
Definition: amfenc_av1.c:26
AVPanScan::height
int height
Definition: defs.h:254
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:244
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_mpeg1_encode_slice_header
void ff_mpeg1_encode_slice_header(MpegEncContext *s)