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