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