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