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