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