FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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(AVCodecContext *avctx, MPEG12EncContext *mpeg12)
141 {
142  int i;
143  AVRational bestq = (AVRational) {0, 0};
144  AVRational ext;
145  AVRational target = av_inv_q(avctx->time_base);
146 
147  for (i = 1; i < 14; i++) {
149  i >= 9)
150  break;
151 
152  for (ext.num=1; ext.num <= 4; ext.num++) {
153  for (ext.den=1; ext.den <= 32; ext.den++) {
155 
156  if (avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO && (ext.den!=1 || ext.num!=1))
157  continue;
158  if (av_gcd(ext.den, ext.num) != 1)
159  continue;
160 
161  if ( bestq.num==0
162  || av_nearer_q(target, bestq, q) < 0
163  || ext.num==1 && ext.den==1 && av_nearer_q(target, bestq, q) == 0) {
164  bestq = q;
165  mpeg12->frame_rate_index = i;
166  mpeg12->frame_rate_ext.num = ext.num;
167  mpeg12->frame_rate_ext.den = ext.den;
168  }
169  }
170  }
171  }
172 
173  if (av_cmp_q(target, bestq))
174  return -1;
175  else
176  return 0;
177 }
178 
179 static av_cold int encode_init(AVCodecContext *avctx)
180 {
181  MPEG12EncContext *const mpeg12 = avctx->priv_data;
182  int ret;
183  int max_size = avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 16383 : 4095;
184 
185  if (avctx->width > max_size || avctx->height > max_size) {
186  av_log(avctx, AV_LOG_ERROR, "%s does not support resolutions above %dx%d\n",
187  CONFIG_SMALL ? avctx->codec->name : avctx->codec->long_name,
188  max_size, max_size);
189  return AVERROR(EINVAL);
190  }
191  if ((avctx->width & 0xFFF) == 0 && (avctx->height & 0xFFF) == 1) {
192  av_log(avctx, AV_LOG_ERROR, "Width / Height is invalid for MPEG2\n");
193  return AVERROR(EINVAL);
194  }
195 
197  if ((avctx->width & 0xFFF) == 0 || (avctx->height & 0xFFF) == 0) {
198  av_log(avctx, AV_LOG_ERROR, "Width or Height are not allowed to be multiples of 4096\n"
199  "add '-strict %d' if you want to use them anyway.\n", FF_COMPLIANCE_UNOFFICIAL);
200  return AVERROR(EINVAL);
201  }
202  }
203 
204  if (mpeg12->mpeg.q_scale_type == 1) {
205  if (avctx->qmax > 28) {
206  av_log(avctx, AV_LOG_ERROR,
207  "non linear quant only supports qmax <= 28 currently\n");
208  return AVERROR_PATCHWELCOME;
209  }
210  }
211 
212  if (avctx->profile == AV_PROFILE_UNKNOWN) {
213  if (avctx->level != AV_LEVEL_UNKNOWN) {
214  av_log(avctx, AV_LOG_ERROR, "Set profile and level\n");
215  return AVERROR(EINVAL);
216  }
217  /* Main or 4:2:2 */
220  }
221  if (avctx->level == AV_LEVEL_UNKNOWN) {
222  if (avctx->profile == AV_PROFILE_MPEG2_422) { /* 4:2:2 */
223  if (avctx->width <= 720 && avctx->height <= 608)
224  avctx->level = 5; /* Main */
225  else
226  avctx->level = 2; /* High */
227  } else {
228  if (avctx->profile != AV_PROFILE_MPEG2_HIGH &&
229  avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
230  av_log(avctx, AV_LOG_ERROR,
231  "Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n");
232  return AVERROR(EINVAL);
233  }
234  if (avctx->width <= 720 && avctx->height <= 576)
235  avctx->level = 8; /* Main */
236  else if (avctx->width <= 1440)
237  avctx->level = 6; /* High 1440 */
238  else
239  avctx->level = 4; /* High */
240  }
241  }
242 
243  if ((ret = ff_mpv_encode_init(avctx)) < 0)
244  return ret;
245 
246  if (find_frame_rate_index(avctx, mpeg12) < 0) {
248  av_log(avctx, AV_LOG_ERROR, "MPEG-1/2 does not support %d/%d fps\n",
249  avctx->time_base.den, avctx->time_base.num);
250  return AVERROR(EINVAL);
251  } else {
252  av_log(avctx, AV_LOG_INFO,
253  "MPEG-1/2 does not support %d/%d fps, there may be AV sync issues\n",
254  avctx->time_base.den, avctx->time_base.num);
255  }
256  }
257 
258  if (avctx->rc_max_rate &&
259  avctx->rc_min_rate == avctx->rc_max_rate &&
260  90000LL * (avctx->rc_buffer_size - 1) >
261  avctx->rc_max_rate * 0xFFFFLL) {
262  av_log(avctx, AV_LOG_INFO,
263  "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
264  "specified vbv buffer is too large for the given bitrate!\n");
265  }
266 
267  if (mpeg12->drop_frame_timecode)
268  mpeg12->tc.flags |= AV_TIMECODE_FLAG_DROPFRAME;
269  if (mpeg12->drop_frame_timecode && mpeg12->frame_rate_index != 4) {
270  av_log(avctx, AV_LOG_ERROR,
271  "Drop frame time code only allowed with 1001/30000 fps\n");
272  return AVERROR(EINVAL);
273  }
274 
275  if (mpeg12->tc_opt_str) {
276  AVRational rate = ff_mpeg12_frame_rate_tab[mpeg12->frame_rate_index];
277  int ret = av_timecode_init_from_string(&mpeg12->tc, rate, mpeg12->tc_opt_str, avctx);
278  if (ret < 0)
279  return ret;
280  mpeg12->drop_frame_timecode = !!(mpeg12->tc.flags & AV_TIMECODE_FLAG_DROPFRAME);
281  mpeg12->timecode_frame_start = mpeg12->tc.start;
282  } else {
283  mpeg12->timecode_frame_start = 0; // default is -1
284  }
285 
286  return 0;
287 }
288 
289 static void put_header(MpegEncContext *s, uint32_t header)
290 {
291  align_put_bits(&s->pb);
292  put_bits32(&s->pb, header);
293 }
294 
295 /* put sequence header if needed */
296 static void mpeg1_encode_sequence_header(MpegEncContext *s)
297 {
298  MPEG12EncContext *const mpeg12 = (MPEG12EncContext*)s;
299  unsigned int vbv_buffer_size, fps, v;
300  int constraint_parameter_flag;
301  AVRational framerate = ff_mpeg12_frame_rate_tab[mpeg12->frame_rate_index];
302  uint64_t time_code;
303  int64_t best_aspect_error = INT64_MAX;
304  AVRational aspect_ratio = s->avctx->sample_aspect_ratio;
305  int aspect_ratio_info;
306 
307  if (!(s->cur_pic.ptr->f->flags & AV_FRAME_FLAG_KEY))
308  return;
309 
310  if (aspect_ratio.num == 0 || aspect_ratio.den == 0)
311  aspect_ratio = (AVRational){1,1}; // pixel aspect 1.1 (VGA)
312 
313  /* MPEG-1 header repeated every GOP */
315 
316  put_sbits(&s->pb, 12, s->width & 0xFFF);
317  put_sbits(&s->pb, 12, s->height & 0xFFF);
318 
319  for (int i = 1; i < 15; i++) {
320  int64_t error = aspect_ratio.num * (1LL<<32) / aspect_ratio.den;
321  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || i <= 1)
322  error -= (1LL<<32) / ff_mpeg1_aspect[i];
323  else
324  error -= (1LL<<32)*ff_mpeg2_aspect[i].num * s->height / s->width / ff_mpeg2_aspect[i].den;
325 
326  error = FFABS(error);
327 
328  if (error - 2 <= best_aspect_error) {
329  best_aspect_error = error;
330  aspect_ratio_info = i;
331  }
332  }
333 
334  put_bits(&s->pb, 4, aspect_ratio_info);
335  put_bits(&s->pb, 4, mpeg12->frame_rate_index);
336 
337  if (s->avctx->rc_max_rate) {
338  v = (s->avctx->rc_max_rate + 399) / 400;
339  if (v > 0x3ffff && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
340  v = 0x3ffff;
341  } else {
342  v = 0x3FFFF;
343  }
344 
345  if (s->avctx->rc_buffer_size)
346  vbv_buffer_size = s->avctx->rc_buffer_size;
347  else
348  /* VBV calculation: Scaled so that a VCD has the proper
349  * VBV size of 40 kilobytes */
350  vbv_buffer_size = av_rescale_rnd(s->bit_rate, 20, 1151929 / 2, AV_ROUND_ZERO) * 8 * 1024;
351  vbv_buffer_size = (vbv_buffer_size + 16383) / 16384;
352 
353  put_sbits(&s->pb, 18, v);
354  put_bits(&s->pb, 1, 1); // marker
355  put_sbits(&s->pb, 10, vbv_buffer_size);
356 
357  constraint_parameter_flag =
358  s->width <= 768 &&
359  s->height <= 576 &&
360  s->mb_width * s->mb_height <= 396 &&
361  s->mb_width * s->mb_height * framerate.num <= 396 * 25 * framerate.den &&
362  framerate.num <= framerate.den * 30 &&
363  s->avctx->me_range &&
364  s->avctx->me_range < 128 &&
365  vbv_buffer_size <= 20 &&
366  v <= 1856000 / 400 &&
367  s->codec_id == AV_CODEC_ID_MPEG1VIDEO;
368 
369  put_bits(&s->pb, 1, constraint_parameter_flag);
370 
371  ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
372  ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
373 
374  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
375  const AVFrameSideData *side_data;
376  int width = s->width;
377  int height = s->height;
378  int use_seq_disp_ext;
379 
381  put_bits(&s->pb, 4, 1); // seq ext
382 
383  put_bits(&s->pb, 1, s->avctx->profile == AV_PROFILE_MPEG2_422); // escx 1 for 4:2:2 profile
384 
385  put_bits(&s->pb, 3, s->avctx->profile); // profile
386  put_bits(&s->pb, 4, s->avctx->level); // level
387 
388  put_bits(&s->pb, 1, s->progressive_sequence);
389  put_bits(&s->pb, 2, s->chroma_format);
390  put_bits(&s->pb, 2, s->width >> 12);
391  put_bits(&s->pb, 2, s->height >> 12);
392  put_bits(&s->pb, 12, v >> 18); // bitrate ext
393  put_bits(&s->pb, 1, 1); // marker
394  put_bits(&s->pb, 8, vbv_buffer_size >> 10); // vbv buffer ext
395  put_bits(&s->pb, 1, s->low_delay);
396  put_bits(&s->pb, 2, mpeg12->frame_rate_ext.num-1); // frame_rate_ext_n
397  put_bits(&s->pb, 5, mpeg12->frame_rate_ext.den-1); // frame_rate_ext_d
398 
399  side_data = av_frame_get_side_data(s->cur_pic.ptr->f, AV_FRAME_DATA_PANSCAN);
400  if (side_data) {
401  const AVPanScan *pan_scan = (AVPanScan *)side_data->data;
402  if (pan_scan->width && pan_scan->height) {
403  width = pan_scan->width >> 4;
404  height = pan_scan->height >> 4;
405  }
406  }
407 
408  use_seq_disp_ext = (width != s->width ||
409  height != s->height ||
410  s->avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
411  s->avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
412  s->avctx->colorspace != AVCOL_SPC_UNSPECIFIED ||
413  mpeg12->video_format != VIDEO_FORMAT_UNSPECIFIED);
414 
415  if (mpeg12->seq_disp_ext == 1 ||
416  (mpeg12->seq_disp_ext == -1 && use_seq_disp_ext)) {
418  put_bits(&s->pb, 4, 2); // sequence display extension
419  put_bits(&s->pb, 3, mpeg12->video_format); // video_format
420  put_bits(&s->pb, 1, 1); // colour_description
421  put_bits(&s->pb, 8, s->avctx->color_primaries); // colour_primaries
422  put_bits(&s->pb, 8, s->avctx->color_trc); // transfer_characteristics
423  put_bits(&s->pb, 8, s->avctx->colorspace); // matrix_coefficients
424  put_bits(&s->pb, 14, width); // display_horizontal_size
425  put_bits(&s->pb, 1, 1); // marker_bit
426  put_bits(&s->pb, 14, height); // display_vertical_size
427  put_bits(&s->pb, 3, 0); // remaining 3 bits are zero padding
428  }
429  }
430 
432  put_bits(&s->pb, 1, mpeg12->drop_frame_timecode); // drop frame flag
433  /* time code: we must convert from the real frame rate to a
434  * fake MPEG frame rate in case of low frame rate */
435  fps = (framerate.num + framerate.den / 2) / framerate.den;
436  time_code = s->cur_pic.ptr->coded_picture_number +
437  mpeg12->timecode_frame_start;
438 
439  mpeg12->gop_picture_number = s->cur_pic.ptr->coded_picture_number;
440 
441  av_assert0(mpeg12->drop_frame_timecode == !!(mpeg12->tc.flags & AV_TIMECODE_FLAG_DROPFRAME));
442  if (mpeg12->drop_frame_timecode)
443  time_code = av_timecode_adjust_ntsc_framenum2(time_code, fps);
444 
445  put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
446  put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
447  put_bits(&s->pb, 1, 1);
448  put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
449  put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
450  put_bits(&s->pb, 1, !!(s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) ||
451  s->intra_only || !mpeg12->gop_picture_number);
452  put_bits(&s->pb, 1, 0); // broken link
453 }
454 
455 static inline void encode_mb_skip_run(MpegEncContext *s, int run)
456 {
457  while (run >= 33) {
458  put_bits(&s->pb, 11, 0x008);
459  run -= 33;
460  }
463 }
464 
465 static av_always_inline void put_qscale(MpegEncContext *s)
466 {
467  put_bits(&s->pb, 5, s->qscale);
468 }
469 
471 {
472  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->height > 2800) {
473  put_header(s, SLICE_MIN_START_CODE + (s->mb_y & 127));
474  /* slice_vertical_position_extension */
475  put_bits(&s->pb, 3, s->mb_y >> 7);
476  } else {
478  }
479  put_qscale(s);
480  /* slice extra information */
481  put_bits(&s->pb, 1, 0);
482 }
483 
485 {
486  MPEG12EncContext *const mpeg12 = (MPEG12EncContext*)s;
487  const AVFrameSideData *side_data;
488  mpeg1_encode_sequence_header(s);
489 
490  /* MPEG-1 picture header */
492  /* temporal reference */
493 
494  // RAL: s->picture_number instead of s->fake_picture_number
495  put_bits(&s->pb, 10,
496  (s->picture_number - mpeg12->gop_picture_number) & 0x3ff);
497  put_bits(&s->pb, 3, s->pict_type);
498 
499  s->vbv_delay_pos = put_bytes_count(&s->pb, 0);
500  put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
501 
502  // RAL: Forward f_code also needed for B-frames
503  if (s->pict_type == AV_PICTURE_TYPE_P ||
504  s->pict_type == AV_PICTURE_TYPE_B) {
505  put_bits(&s->pb, 1, 0); /* half pel coordinates */
506  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
507  put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
508  else
509  put_bits(&s->pb, 3, 7); /* forward_f_code */
510  }
511 
512  // RAL: Backward f_code necessary for B-frames
513  if (s->pict_type == AV_PICTURE_TYPE_B) {
514  put_bits(&s->pb, 1, 0); /* half pel coordinates */
515  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
516  put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
517  else
518  put_bits(&s->pb, 3, 7); /* backward_f_code */
519  }
520 
521  put_bits(&s->pb, 1, 0); /* extra bit picture */
522 
523  s->frame_pred_frame_dct = 1;
524  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
526  put_bits(&s->pb, 4, 8); /* pic ext */
527  if (s->pict_type == AV_PICTURE_TYPE_P ||
528  s->pict_type == AV_PICTURE_TYPE_B) {
529  put_bits(&s->pb, 4, s->f_code);
530  put_bits(&s->pb, 4, s->f_code);
531  } else {
532  put_bits(&s->pb, 8, 255);
533  }
534  if (s->pict_type == AV_PICTURE_TYPE_B) {
535  put_bits(&s->pb, 4, s->b_code);
536  put_bits(&s->pb, 4, s->b_code);
537  } else {
538  put_bits(&s->pb, 8, 255);
539  }
540  put_bits(&s->pb, 2, s->intra_dc_precision);
541 
542  av_assert0(s->picture_structure == PICT_FRAME);
543  put_bits(&s->pb, 2, s->picture_structure);
544  if (s->progressive_sequence)
545  put_bits(&s->pb, 1, 0); /* no repeat */
546  else
547  put_bits(&s->pb, 1, !!(s->cur_pic.ptr->f->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST));
548  /* XXX: optimize the generation of this flag with entropy measures */
549  s->frame_pred_frame_dct = s->progressive_sequence;
550 
551  put_bits(&s->pb, 1, s->frame_pred_frame_dct);
552  put_bits(&s->pb, 1, s->concealment_motion_vectors);
553  put_bits(&s->pb, 1, s->q_scale_type);
554  put_bits(&s->pb, 1, s->intra_vlc_format);
555  put_bits(&s->pb, 1, s->alternate_scan);
556  put_bits(&s->pb, 1, s->repeat_first_field);
557  s->progressive_frame = s->progressive_sequence;
558  /* chroma_420_type */
559  put_bits(&s->pb, 1, s->chroma_format ==
560  CHROMA_420 ? s->progressive_frame : 0);
561  put_bits(&s->pb, 1, s->progressive_frame);
562  put_bits(&s->pb, 1, 0); /* composite_display_flag */
563  }
564  if (mpeg12->scan_offset) {
565  int i;
566 
568  for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
569  put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
570  }
571  side_data = av_frame_get_side_data(s->cur_pic.ptr->f,
573  if (side_data) {
574  const AVStereo3D *stereo = (AVStereo3D *)side_data->data;
575  uint8_t fpa_type;
576 
577  switch (stereo->type) {
579  fpa_type = 0x03;
580  break;
582  fpa_type = 0x04;
583  break;
584  case AV_STEREO3D_2D:
585  fpa_type = 0x08;
586  break;
588  fpa_type = 0x23;
589  break;
590  default:
591  fpa_type = 0;
592  break;
593  }
594 
595  if (fpa_type != 0) {
597  // S3D_video_format_signaling_identifier
598  put_bits32(&s->pb, MKBETAG('J','P','3','D'));
599  put_bits(&s->pb, 8, 0x03); // S3D_video_format_length
600 
601  put_bits(&s->pb, 1, 1); // reserved_bit
602  put_bits(&s->pb, 7, fpa_type); // S3D_video_format_type
603  put_bits(&s->pb, 8, 0x04); // reserved_data[0]
604  put_bits(&s->pb, 8, 0xFF); // reserved_data[1]
605  }
606  }
607 
608  if (CONFIG_MPEG2VIDEO_ENCODER && mpeg12->a53_cc) {
609  side_data = av_frame_get_side_data(s->cur_pic.ptr->f,
611  if (side_data) {
612  if (side_data->size <= A53_MAX_CC_COUNT * 3 && side_data->size % 3 == 0) {
614 
615  put_bits32(&s->pb, MKBETAG('G','A','9','4')); // user_identifier
616  put_bits(&s->pb, 8, 3); // user_data_type_code
617  put_bits(&s->pb, 8,
618  (side_data->size / 3 & A53_MAX_CC_COUNT) | 0x40); // flags, cc_count
619  put_bits(&s->pb, 8, 0xff); // em_data
620 
621  ff_copy_bits(&s->pb, side_data->data, side_data->size);
622 
623  put_bits(&s->pb, 8, 0xff); // marker_bits
624  } else {
625  av_log(s->avctx, AV_LOG_WARNING,
626  "Closed Caption size (%"SIZE_SPECIFIER") can not exceed "
627  "93 bytes and must be a multiple of 3\n", side_data->size);
628  }
629  }
630  }
631 
632  s->mb_y = 0;
634 }
635 
636 static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
637  int has_mv, int field_motion)
638 {
639  put_bits(&s->pb, n, bits);
640  if (!s->frame_pred_frame_dct) {
641  if (has_mv)
642  /* motion_type: frame/field */
643  put_bits(&s->pb, 2, 2 - field_motion);
644  put_bits(&s->pb, 1, s->interlaced_dct);
645  }
646 }
647 
648 // RAL: Parameter added: f_or_b_code
649 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
650 {
651  if (val == 0) {
652  /* zero vector, corresponds to ff_mpeg12_mbMotionVectorTable[0] */
653  put_bits(&s->pb, 1, 0x01);
654  } else {
655  int code, sign, bits;
656  int bit_size = f_or_b_code - 1;
657  int range = 1 << bit_size;
658  /* modulo encoding */
659  val = sign_extend(val, 5 + bit_size);
660 
661  if (val >= 0) {
662  val--;
663  code = (val >> bit_size) + 1;
664  bits = val & (range - 1);
665  sign = 0;
666  } else {
667  val = -val;
668  val--;
669  code = (val >> bit_size) + 1;
670  bits = val & (range - 1);
671  sign = 1;
672  }
673 
674  av_assert2(code > 0 && code <= 16);
675 
676  put_bits(&s->pb,
679 
680  put_bits(&s->pb, 1, sign);
681  if (bit_size > 0)
682  put_bits(&s->pb, bit_size, bits);
683  }
684 }
685 
686 static inline void encode_dc(MpegEncContext *s, int diff, int component)
687 {
688  unsigned int diff_u = diff + 255;
689  if (diff_u >= 511) {
690  int index;
691 
692  if (diff < 0) {
693  index = av_log2_16bit(-2 * diff);
694  diff--;
695  } else {
696  index = av_log2_16bit(2 * diff);
697  }
698  if (component == 0)
699  put_bits(&s->pb,
703  else
704  put_bits(&s->pb,
708  } else {
709  if (component == 0)
710  put_bits(&s->pb,
711  mpeg1_lum_dc_uni[diff + 255] & 0xFF,
712  mpeg1_lum_dc_uni[diff + 255] >> 8);
713  else
714  put_bits(&s->pb,
715  mpeg1_chr_dc_uni[diff + 255] & 0xFF,
716  mpeg1_chr_dc_uni[diff + 255] >> 8);
717  }
718 }
719 
720 static void mpeg1_encode_block(MpegEncContext *s, const int16_t *block, int n)
721 {
722  int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
723  int code, component;
724  const uint16_t (*table_vlc)[2] = ff_mpeg1_vlc_table;
725 
726  last_index = s->block_last_index[n];
727 
728  /* DC coef */
729  if (s->mb_intra) {
730  component = (n <= 3 ? 0 : (n & 1) + 1);
731  dc = block[0]; /* overflow is impossible */
732  diff = dc - s->last_dc[component];
733  encode_dc(s, diff, component);
734  s->last_dc[component] = dc;
735  i = 1;
736  if (s->intra_vlc_format)
737  table_vlc = ff_mpeg2_vlc_table;
738  } else {
739  /* encode the first coefficient: needs to be done here because
740  * it is handled slightly differently */
741  level = block[0];
742  if (abs(level) == 1) {
743  code = ((uint32_t)level >> 31); /* the sign bit */
744  put_bits(&s->pb, 2, code | 0x02);
745  i = 1;
746  } else {
747  i = 0;
748  last_non_zero = -1;
749  goto next_coef;
750  }
751  }
752 
753  /* now quantify & encode AC coefs */
754  last_non_zero = i - 1;
755 
756  for (; i <= last_index; i++) {
757  j = s->intra_scantable.permutated[i];
758  level = block[j];
759 
760 next_coef:
761  /* encode using VLC */
762  if (level != 0) {
763  run = i - last_non_zero - 1;
764 
765  alevel = level;
766  MASK_ABS(sign, alevel);
767  sign &= 1;
768 
769  if (alevel <= mpeg12_max_level[run]) {
770  code = mpeg12_index_run[run] + alevel - 1;
771  /* store the VLC & sign at once */
772  put_bits(&s->pb, table_vlc[code][1] + 1,
773  (table_vlc[code][0] << 1) + sign);
774  } else {
775  /* Escape seems to be pretty rare <5% so I do not optimize it;
776  * the following value is the common escape value for both
777  * possible tables (i.e. table_vlc[111]). */
778  put_bits(&s->pb, 6, 0x01);
779  /* escape: only clip in this case */
780  put_bits(&s->pb, 6, run);
781  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
782  if (alevel < 128) {
783  put_sbits(&s->pb, 8, level);
784  } else {
785  if (level < 0)
786  put_bits(&s->pb, 16, 0x8001 + level + 255);
787  else
788  put_sbits(&s->pb, 16, level);
789  }
790  } else {
791  put_sbits(&s->pb, 12, level);
792  }
793  }
794  last_non_zero = i;
795  }
796  }
797  /* end of block */
798  put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
799 }
800 
801 static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s,
802  const int16_t block[8][64],
803  int motion_x, int motion_y,
804  int mb_block_count,
805  int chroma_y_shift)
806 {
807 /* MPEG-1 is always 420. */
808 #define IS_MPEG1(s) (chroma_y_shift == 1 && (s)->codec_id == AV_CODEC_ID_MPEG1VIDEO)
809  int i, cbp;
810  const int mb_x = s->mb_x;
811  const int mb_y = s->mb_y;
812  const int first_mb = mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
813 
814  /* compute cbp */
815  cbp = 0;
816  for (i = 0; i < mb_block_count; i++)
817  if (s->block_last_index[i] >= 0)
818  cbp |= 1 << (mb_block_count - 1 - i);
819 
820  if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 &&
821  (mb_x != s->mb_width - 1 ||
822  (mb_y != s->end_mb_y - 1 && IS_MPEG1(s))) &&
823  ((s->pict_type == AV_PICTURE_TYPE_P && (motion_x | motion_y) == 0) ||
824  (s->pict_type == AV_PICTURE_TYPE_B && s->mv_dir == s->last_mv_dir &&
825  (((s->mv_dir & MV_DIR_FORWARD)
826  ? ((s->mv[0][0][0] - s->last_mv[0][0][0]) |
827  (s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
828  ((s->mv_dir & MV_DIR_BACKWARD)
829  ? ((s->mv[1][0][0] - s->last_mv[1][0][0]) |
830  (s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
831  s->mb_skip_run++;
832  s->qscale -= s->dquant;
833  s->misc_bits++;
834  s->last_bits++;
835  if (s->pict_type == AV_PICTURE_TYPE_P) {
836  s->last_mv[0][0][0] =
837  s->last_mv[0][0][1] =
838  s->last_mv[0][1][0] =
839  s->last_mv[0][1][1] = 0;
840  }
841  } else {
842  if (first_mb) {
843  av_assert0(s->mb_skip_run == 0);
844  encode_mb_skip_run(s, s->mb_x);
845  } else {
846  encode_mb_skip_run(s, s->mb_skip_run);
847  }
848 
849  if (s->pict_type == AV_PICTURE_TYPE_I) {
850  if (s->dquant && cbp) {
851  /* macroblock_type: macroblock_quant = 1 */
852  put_mb_modes(s, 2, 1, 0, 0);
853  put_qscale(s);
854  } else {
855  /* macroblock_type: macroblock_quant = 0 */
856  put_mb_modes(s, 1, 1, 0, 0);
857  s->qscale -= s->dquant;
858  }
859  s->misc_bits += get_bits_diff(s);
860  s->i_count++;
861  } else if (s->mb_intra) {
862  if (s->dquant && cbp) {
863  put_mb_modes(s, 6, 0x01, 0, 0);
864  put_qscale(s);
865  } else {
866  put_mb_modes(s, 5, 0x03, 0, 0);
867  s->qscale -= s->dquant;
868  }
869  s->misc_bits += get_bits_diff(s);
870  s->i_count++;
871  memset(s->last_mv, 0, sizeof(s->last_mv));
872  } else if (s->pict_type == AV_PICTURE_TYPE_P) {
873  if (s->mv_type == MV_TYPE_16X16) {
874  if (cbp != 0) {
875  if ((motion_x | motion_y) == 0) {
876  if (s->dquant) {
877  /* macroblock_pattern & quant */
878  put_mb_modes(s, 5, 1, 0, 0);
879  put_qscale(s);
880  } else {
881  /* macroblock_pattern only */
882  put_mb_modes(s, 2, 1, 0, 0);
883  }
884  s->misc_bits += get_bits_diff(s);
885  } else {
886  if (s->dquant) {
887  put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */
888  put_qscale(s);
889  } else {
890  put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */
891  }
892  s->misc_bits += get_bits_diff(s);
893  // RAL: f_code parameter added
894  mpeg1_encode_motion(s,
895  motion_x - s->last_mv[0][0][0],
896  s->f_code);
897  // RAL: f_code parameter added
898  mpeg1_encode_motion(s,
899  motion_y - s->last_mv[0][0][1],
900  s->f_code);
901  s->mv_bits += get_bits_diff(s);
902  }
903  } else {
904  put_bits(&s->pb, 3, 1); /* motion only */
905  if (!s->frame_pred_frame_dct)
906  put_bits(&s->pb, 2, 2); /* motion_type: frame */
907  s->misc_bits += get_bits_diff(s);
908  // RAL: f_code parameter added
909  mpeg1_encode_motion(s,
910  motion_x - s->last_mv[0][0][0],
911  s->f_code);
912  // RAL: f_code parameter added
913  mpeg1_encode_motion(s,
914  motion_y - s->last_mv[0][0][1],
915  s->f_code);
916  s->qscale -= s->dquant;
917  s->mv_bits += get_bits_diff(s);
918  }
919  s->last_mv[0][1][0] = s->last_mv[0][0][0] = motion_x;
920  s->last_mv[0][1][1] = s->last_mv[0][0][1] = motion_y;
921  } else {
922  av_assert2(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD);
923 
924  if (cbp) {
925  if (s->dquant) {
926  put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
927  put_qscale(s);
928  } else {
929  put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
930  }
931  } else {
932  put_bits(&s->pb, 3, 1); /* motion only */
933  put_bits(&s->pb, 2, 1); /* motion_type: field */
934  s->qscale -= s->dquant;
935  }
936  s->misc_bits += get_bits_diff(s);
937  for (i = 0; i < 2; i++) {
938  put_bits(&s->pb, 1, s->field_select[0][i]);
939  mpeg1_encode_motion(s,
940  s->mv[0][i][0] - s->last_mv[0][i][0],
941  s->f_code);
942  mpeg1_encode_motion(s,
943  s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
944  s->f_code);
945  s->last_mv[0][i][0] = s->mv[0][i][0];
946  s->last_mv[0][i][1] = 2 * s->mv[0][i][1];
947  }
948  s->mv_bits += get_bits_diff(s);
949  }
950  if (cbp) {
951  if (chroma_y_shift) {
952  put_bits(&s->pb,
953  ff_mpeg12_mbPatTable[cbp][1],
954  ff_mpeg12_mbPatTable[cbp][0]);
955  } else {
956  put_bits(&s->pb,
957  ff_mpeg12_mbPatTable[cbp >> 2][1],
958  ff_mpeg12_mbPatTable[cbp >> 2][0]);
959  put_sbits(&s->pb, 2, cbp);
960  }
961  }
962  } else {
963  if (s->mv_type == MV_TYPE_16X16) {
964  if (cbp) { // With coded bloc pattern
965  if (s->dquant) {
966  if (s->mv_dir == MV_DIR_FORWARD)
967  put_mb_modes(s, 6, 3, 1, 0);
968  else
969  put_mb_modes(s, 8 - s->mv_dir, 2, 1, 0);
970  put_qscale(s);
971  } else {
972  put_mb_modes(s, 5 - s->mv_dir, 3, 1, 0);
973  }
974  } else { // No coded bloc pattern
975  put_bits(&s->pb, 5 - s->mv_dir, 2);
976  if (!s->frame_pred_frame_dct)
977  put_bits(&s->pb, 2, 2); /* motion_type: frame */
978  s->qscale -= s->dquant;
979  }
980  s->misc_bits += get_bits_diff(s);
981  if (s->mv_dir & MV_DIR_FORWARD) {
982  mpeg1_encode_motion(s,
983  s->mv[0][0][0] - s->last_mv[0][0][0],
984  s->f_code);
985  mpeg1_encode_motion(s,
986  s->mv[0][0][1] - s->last_mv[0][0][1],
987  s->f_code);
988  s->last_mv[0][0][0] =
989  s->last_mv[0][1][0] = s->mv[0][0][0];
990  s->last_mv[0][0][1] =
991  s->last_mv[0][1][1] = s->mv[0][0][1];
992  }
993  if (s->mv_dir & MV_DIR_BACKWARD) {
994  mpeg1_encode_motion(s,
995  s->mv[1][0][0] - s->last_mv[1][0][0],
996  s->b_code);
997  mpeg1_encode_motion(s,
998  s->mv[1][0][1] - s->last_mv[1][0][1],
999  s->b_code);
1000  s->last_mv[1][0][0] =
1001  s->last_mv[1][1][0] = s->mv[1][0][0];
1002  s->last_mv[1][0][1] =
1003  s->last_mv[1][1][1] = s->mv[1][0][1];
1004  }
1005  } else {
1006  av_assert2(s->mv_type == MV_TYPE_FIELD);
1007  av_assert2(!s->frame_pred_frame_dct);
1008  if (cbp) { // With coded bloc pattern
1009  if (s->dquant) {
1010  if (s->mv_dir == MV_DIR_FORWARD)
1011  put_mb_modes(s, 6, 3, 1, 1);
1012  else
1013  put_mb_modes(s, 8 - s->mv_dir, 2, 1, 1);
1014  put_qscale(s);
1015  } else {
1016  put_mb_modes(s, 5 - s->mv_dir, 3, 1, 1);
1017  }
1018  } else { // No coded bloc pattern
1019  put_bits(&s->pb, 5 - s->mv_dir, 2);
1020  put_bits(&s->pb, 2, 1); /* motion_type: field */
1021  s->qscale -= s->dquant;
1022  }
1023  s->misc_bits += get_bits_diff(s);
1024  if (s->mv_dir & MV_DIR_FORWARD) {
1025  for (i = 0; i < 2; i++) {
1026  put_bits(&s->pb, 1, s->field_select[0][i]);
1027  mpeg1_encode_motion(s,
1028  s->mv[0][i][0] - s->last_mv[0][i][0],
1029  s->f_code);
1030  mpeg1_encode_motion(s,
1031  s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
1032  s->f_code);
1033  s->last_mv[0][i][0] = s->mv[0][i][0];
1034  s->last_mv[0][i][1] = s->mv[0][i][1] * 2;
1035  }
1036  }
1037  if (s->mv_dir & MV_DIR_BACKWARD) {
1038  for (i = 0; i < 2; i++) {
1039  put_bits(&s->pb, 1, s->field_select[1][i]);
1040  mpeg1_encode_motion(s,
1041  s->mv[1][i][0] - s->last_mv[1][i][0],
1042  s->b_code);
1043  mpeg1_encode_motion(s,
1044  s->mv[1][i][1] - (s->last_mv[1][i][1] >> 1),
1045  s->b_code);
1046  s->last_mv[1][i][0] = s->mv[1][i][0];
1047  s->last_mv[1][i][1] = s->mv[1][i][1] * 2;
1048  }
1049  }
1050  }
1051  s->mv_bits += get_bits_diff(s);
1052  if (cbp) {
1053  if (chroma_y_shift) {
1054  put_bits(&s->pb,
1055  ff_mpeg12_mbPatTable[cbp][1],
1056  ff_mpeg12_mbPatTable[cbp][0]);
1057  } else {
1058  put_bits(&s->pb,
1059  ff_mpeg12_mbPatTable[cbp >> 2][1],
1060  ff_mpeg12_mbPatTable[cbp >> 2][0]);
1061  put_sbits(&s->pb, 2, cbp);
1062  }
1063  }
1064  }
1065  for (i = 0; i < mb_block_count; i++)
1066  if (cbp & (1 << (mb_block_count - 1 - i)))
1067  mpeg1_encode_block(s, block[i], i);
1068  s->mb_skip_run = 0;
1069  if (s->mb_intra)
1070  s->i_tex_bits += get_bits_diff(s);
1071  else
1072  s->p_tex_bits += get_bits_diff(s);
1073  }
1074 }
1075 
1076 void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64],
1077  int motion_x, int motion_y)
1078 {
1079  if (!s->mb_intra)
1080  s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 128 << s->intra_dc_precision;
1081  if (s->chroma_format == CHROMA_420)
1082  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6, 1);
1083  else
1084  mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8, 0);
1085 }
1086 
1087 static av_cold void mpeg12_encode_init_static(void)
1088 {
1089  ff_rl_init_level_run(mpeg12_max_level, mpeg12_index_run,
1091 
1092  ff_mpeg1_init_uni_ac_vlc(mpeg12_max_level, mpeg12_index_run,
1093  ff_mpeg1_vlc_table, uni_mpeg1_ac_vlc_len);
1094  ff_mpeg1_init_uni_ac_vlc(mpeg12_max_level, mpeg12_index_run,
1095  ff_mpeg2_vlc_table, uni_mpeg2_ac_vlc_len);
1096 
1097  /* build unified dc encoding tables */
1098  for (int i = -255; i < 256; i++) {
1099  int adiff, index;
1100  int bits, code;
1101  int diff = i;
1102 
1103  adiff = FFABS(diff);
1104  if (diff < 0)
1105  diff--;
1106  index = av_log2(2 * adiff);
1107 
1111  mpeg1_lum_dc_uni[i + 255] = bits + (code << 8);
1112 
1116  mpeg1_chr_dc_uni[i + 255] = bits + (code << 8);
1117  }
1118 
1119  for (int f_code = 1; f_code <= MAX_FCODE; f_code++)
1120  for (int mv = -MAX_DMV; mv <= MAX_DMV; mv++) {
1121  int len;
1122 
1123  if (mv == 0) {
1124  len = 1; /* ff_mpeg12_mbMotionVectorTable[0][1] */
1125  } else {
1126  int val, bit_size, code;
1127 
1128  bit_size = f_code - 1;
1129 
1130  val = mv;
1131  if (val < 0)
1132  val = -val;
1133  val--;
1134  code = (val >> bit_size) + 1;
1135  if (code < 17)
1137  1 + bit_size;
1138  else
1139  len = 10 /* ff_mpeg12_mbMotionVectorTable[16][1] */ +
1140  2 + bit_size;
1141  }
1142 
1143  mv_penalty[f_code][mv + MAX_DMV] = len;
1144  }
1145 
1146 
1147  for (int f_code = MAX_FCODE; f_code > 0; f_code--)
1148  for (int mv = -(8 << f_code); mv < (8 << f_code); mv++)
1149  fcode_tab[mv + MAX_MV] = f_code;
1150 }
1151 
1153 {
1154  static AVOnce init_static_once = AV_ONCE_INIT;
1155 
1156  s->y_dc_scale_table =
1157  s->c_dc_scale_table = ff_mpeg12_dc_scale_table[s->intra_dc_precision];
1158 
1159  s->me.mv_penalty = mv_penalty;
1160  s->fcode_tab = fcode_tab + MAX_MV;
1161  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1162  s->min_qcoeff = -255;
1163  s->max_qcoeff = 255;
1164  } else {
1165  s->min_qcoeff = -2047;
1166  s->max_qcoeff = 2047;
1167  s->mpeg_quant = 1;
1168  }
1169  if (s->intra_vlc_format) {
1170  s->intra_ac_vlc_length =
1171  s->intra_ac_vlc_last_length = uni_mpeg2_ac_vlc_len;
1172  } else {
1173  s->intra_ac_vlc_length =
1174  s->intra_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1175  }
1176  s->inter_ac_vlc_length =
1177  s->inter_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1178 
1179  ff_thread_once(&init_static_once, mpeg12_encode_init_static);
1180 }
1181 
1182 #define OFFSET(x) offsetof(MPEG12EncContext, x)
1183 #define VE AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
1184 #define COMMON_OPTS \
1185  { "gop_timecode", "MPEG GOP Timecode in hh:mm:ss[:;.]ff format. Overrides timecode_frame_start.", \
1186  OFFSET(tc_opt_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE },\
1187  { "drop_frame_timecode", "Timecode is in drop frame format.", \
1188  OFFSET(drop_frame_timecode), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1189  { "scan_offset", "Reserve space for SVCD scan offset user data.", \
1190  OFFSET(scan_offset), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1191  { "timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", \
1192  OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = -1 }, -1, INT64_MAX, VE}, \
1193  FF_MPV_COMMON_BFRAME_OPTS
1194 
1195 static const AVOption mpeg1_options[] = {
1196  COMMON_OPTS
1199  { NULL },
1200 };
1201 
1202 static const AVOption mpeg2_options[] = {
1203  COMMON_OPTS
1204  { "intra_vlc", "Use MPEG-2 intra VLC table.",
1205  FF_MPV_OFFSET(intra_vlc_format), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1206  { "non_linear_quant", "Use nonlinear quantizer.", FF_MPV_OFFSET(q_scale_type), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1207  { "alternate_scan", "Enable alternate scantable.", FF_MPV_OFFSET(alternate_scan), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1208  { "a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
1209  { "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" },
1210  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, VE, .unit = "seq_disp_ext" },
1211  { "never", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, VE, .unit = "seq_disp_ext" },
1212  { "always", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, VE, .unit = "seq_disp_ext" },
1213  { "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" },
1214  { "component", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_COMPONENT }, 0, 0, VE, .unit = "video_format" },
1215  { "pal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_PAL }, 0, 0, VE, .unit = "video_format" },
1216  { "ntsc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_NTSC }, 0, 0, VE, .unit = "video_format" },
1217  { "secam", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_SECAM }, 0, 0, VE, .unit = "video_format" },
1218  { "mac", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_MAC }, 0, 0, VE, .unit = "video_format" },
1219  { "unspecified", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_UNSPECIFIED}, 0, 0, VE, .unit = "video_format" },
1220 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, { .i64 = value }, 0, 0, VE, .unit = "avctx.level"
1221  { LEVEL("high", 4) },
1222  { LEVEL("high1440", 6) },
1223  { LEVEL("main", 8) },
1224  { LEVEL("low", 10) },
1225 #undef LEVEL
1229  { NULL },
1230 };
1231 
1232 #define mpeg12_class(x) \
1233 static const AVClass mpeg ## x ## _class = { \
1234  .class_name = "mpeg" # x "video encoder", \
1235  .item_name = av_default_item_name, \
1236  .option = mpeg ## x ## _options, \
1237  .version = LIBAVUTIL_VERSION_INT, \
1238 };
1239 
1240 mpeg12_class(1)
1241 mpeg12_class(2)
1242 
1244  .p.name = "mpeg1video",
1245  CODEC_LONG_NAME("MPEG-1 video"),
1246  .p.type = AVMEDIA_TYPE_VIDEO,
1247  .p.id = AV_CODEC_ID_MPEG1VIDEO,
1248  .priv_data_size = sizeof(MPEG12EncContext),
1249  .init = encode_init,
1251  .close = ff_mpv_encode_end,
1254  .color_ranges = AVCOL_RANGE_MPEG,
1255  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1258  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1259  .p.priv_class = &mpeg1_class,
1260 };
1261 
1263  .p.name = "mpeg2video",
1264  CODEC_LONG_NAME("MPEG-2 video"),
1265  .p.type = AVMEDIA_TYPE_VIDEO,
1266  .p.id = AV_CODEC_ID_MPEG2VIDEO,
1267  .priv_data_size = sizeof(MPEG12EncContext),
1268  .init = encode_init,
1270  .close = ff_mpv_encode_end,
1273  .color_ranges = AVCOL_RANGE_MPEG,
1274  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1277  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1278  .p.priv_class = &mpeg2_class,
1279 };
1280 #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
CODEC_PIXFMTS
#define CODEC_PIXFMTS(...)
Definition: codec_internal.h:386
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:264
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
CODEC_FRAMERATES_ARRAY
#define CODEC_FRAMERATES_ARRAY(array)
Definition: codec_internal.h:384
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:160
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AV_STEREO3D_SIDEBYSIDE_QUINCUNX
@ AV_STEREO3D_SIDEBYSIDE_QUINCUNX
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:114
put_bits32
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:291
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
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:435
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:693
MAX_FCODE
#define MAX_FCODE
Definition: mpegvideoenc.h:36
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1317
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:242
mpegvideoenc.h
int64_t
long long int64_t
Definition: coverity.c:34
mv
static const int8_t mv[256][2]
Definition: 4xm.c:81
ff_rl_init_level_run
av_cold void ff_rl_init_level_run(uint8_t max_level[MAX_LEVEL+1], uint8_t index_run[MAX_RUN+1], const uint8_t table_run[], const uint8_t table_level[], int n)
Initialize max_level and index_run from table_run and table_level; this is equivalent to initializing...
Definition: rl.c:26
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:281
MAX_RUN
#define MAX_RUN
Definition: rl.h:35
av_log2_16bit
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
MPEG12_RL_NB_ELEMS
#define MPEG12_RL_NB_ELEMS
Definition: mpeg12vlc.h:52
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
MAX_DMV
#define MAX_DMV
Definition: motion_est.h:38
AVOption
AVOption.
Definition: opt.h:429
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:647
put_bytes_count
static int put_bytes_count(const PutBitContext *s, int round_up)
Definition: put_bits.h:100
AV_ROUND_ZERO
@ AV_ROUND_ZERO
Round toward zero.
Definition: mathematics.h:131
mv_penalty
static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
Definition: h261enc.c:52
FFCodec
Definition: codec_internal.h:127
MASK_ABS
#define MASK_ABS(mask, level)
Definition: mathops.h:165
ff_mpeg2video_encoder
const FFCodec ff_mpeg2video_encoder
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
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1281
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:261
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:674
FF_MPV_COMMON_MOTION_EST_OPTS
#define FF_MPV_COMMON_MOTION_EST_OPTS
Definition: mpegvideoenc.h:129
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:1867
FF_MPV_COMMON_OPTS
#define FF_MPV_COMMON_OPTS
Definition: mpegvideoenc.h:86
ff_copy_bits
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
Definition: bitstream.c:49
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:460
mpeg12enc.h
AV_STEREO3D_2D
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:52
timecode.h
ff_mpeg12_mbMotionVectorTable
const uint8_t ff_mpeg12_mbMotionVectorTable[17][2]
Definition: mpeg12data.c:273
AVPanScan::width
int width
width and height in 1/16 pel
Definition: defs.h:255
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:353
AVRational::num
int num
Numerator.
Definition: rational.h:59
GOP_START_CODE
#define GOP_START_CODE
Definition: mpeg12.h:30
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: asvenc.c: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:209
AVFrameSideData::size
size_t size
Definition: frame.h:268
av_cold
#define av_cold
Definition: attributes.h:90
MAX_MV
#define MAX_MV
Definition: motion_est.h:36
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:661
A53_MAX_CC_COUNT
#define A53_MAX_CC_COUNT
Definition: mpeg12dec.c:63
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:226
FF_MPV_OFFSET
#define FF_MPV_OFFSET(x)
Definition: mpegvideoenc.h:83
av_timecode_adjust_ntsc_framenum2
int av_timecode_adjust_ntsc_framenum2(int framenum, int fps)
Adjust frame number for NTSC drop frame time code.
Definition: timecode.c:36
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1310
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:622
ff_mpeg1video_encoder
const FFCodec ff_mpeg1video_encoder
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1295
framerate
float framerate
Definition: av1_levels.c:29
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:204
SLICE_MIN_START_CODE
#define SLICE_MIN_START_CODE
Definition: mpeg12.h:32
AV_LEVEL_UNKNOWN
#define AV_LEVEL_UNKNOWN
Definition: defs.h:198
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:1040
abs
#define abs(x)
Definition: cuda_runtime.h:35
COMMON_OPTS
#define COMMON_OPTS
Definition: f_segment.c:264
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1802
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:558
av_rescale_rnd
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
AV_FRAME_DATA_PANSCAN
@ AV_FRAME_DATA_PANSCAN
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:53
height
#define height
Definition: dsp.h:85
codec_internal.h
ff_mpeg12_level
const int8_t ff_mpeg12_level[MPEG12_RL_NB_ELEMS]
Definition: mpeg12data.c:133
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
PICTURE_START_CODE
#define PICTURE_START_CODE
Definition: mpeg12.h:31
USER_START_CODE
#define USER_START_CODE
Definition: cavs.h:40
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2594
header
static const uint8_t header[24]
Definition: sdr2.c:68
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
fcode_tab
static uint8_t fcode_tab[MAX_MV *2+1]
Minimal fcode that a motion vector component would need.
Definition: mpeg4videoenc.c:43
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:267
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: defs.h:61
av_zero_extend
#define av_zero_extend
Definition: common.h:151
UNI_AC_ENC_INDEX
#define UNI_AC_ENC_INDEX(run, level)
Definition: mpegvideoenc.h:37
encode_dc
static void encode_dc(PutBitContext *pb, int diff, int component)
Definition: speedhqenc.c:169
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
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:676
AVCodecContext::height
int height
Definition: avcodec.h:632
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:671
FF_MPEG2_PROFILE_OPTS
#define FF_MPEG2_PROFILE_OPTS
Definition: profiles.h:48
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:733
ff_mpeg1_init_uni_ac_vlc
av_cold void ff_mpeg1_init_uni_ac_vlc(const int8_t max_level[], const uint8_t index_run[], const uint16_t table_vlc[][2], uint8_t uni_ac_vlc_len[])
Definition: mpeg12enc.c: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:1397
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:207
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:451
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:101
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1658
ff_mpeg2_vlc_table
const uint16_t ff_mpeg2_vlc_table[MPEG12_RL_NB_ELEMS+2][2]
Definition: mpeg12data.c:100
AV_PROFILE_MPEG2_422
#define AV_PROFILE_MPEG2_422
Definition: defs.h:100
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:131
AV_PROFILE_MPEG2_MAIN
#define AV_PROFILE_MPEG2_MAIN
Definition: defs.h:104
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
LEVEL
#define LEVEL(name, value)
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h: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:420
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
av_nearer_q
int av_nearer_q(AVRational q, AVRational q1, AVRational q2)
Find which of the two rationals is closer to another rational.
Definition: rational.c:125
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:260
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
rl.h
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:632
ff_mpeg12_vlc_dc_lum_code
const uint16_t ff_mpeg12_vlc_dc_lum_code[12]
Definition: mpeg12data.c:53
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
VE
#define VE
Definition: amfenc_av1.c:30
AVPanScan::height
int height
Definition: defs.h:256
av_timecode_init_from_string
int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx)
Parse timecode representation (hh:mm:ss[:;.
Definition: timecode.c:232
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:203
width
#define width
Definition: dsp.h:85
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
Special option type for declaring named constants.
Definition: opt.h:299
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)