3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
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.
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.
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
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"
40 #include "bytestream.h"
43 #include "mpeg12data.h"
44 #include "mpegutils.h"
45 #include "mpegvideo.h"
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,
54 static uint8_t mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
55 static uint8_t fcode_tab[MAX_MV * 2 + 1];
57 static uint8_t uni_mpeg1_ac_vlc_len[64 * 64 * 2];
58 static uint8_t uni_mpeg2_ac_vlc_len[64 * 64 * 2];
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];
65 #define A53_MAX_CC_COUNT 0x1f
66 #endif /* CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER */
68 av_cold void ff_mpeg1_init_uni_ac_vlc(const RLTable *rl, uint8_t *uni_ac_vlc_len)
72 for (i = 0; i < 128; i++) {
77 for (run = 0; run < 64; run++) {
79 int alevel = FFABS(level);
81 if (alevel > rl->max_level[0][run])
82 code = 111; /* rl->n */
84 code = rl->index_run[0][run] + alevel - 1;
86 if (code < 111) { /* rl->n */
87 /* length of VLC and sign */
88 len = rl->table_vlc[code][1] + 1;
90 len = rl->table_vlc[111 /* rl->n */][1] + 6;
98 uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
103 #if CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER
104 static int find_frame_rate_index(MpegEncContext *s)
107 AVRational bestq = (AVRational) {0, 0};
109 AVRational target = av_inv_q(s->avctx->time_base);
111 for (i = 1; i < 14; i++) {
112 if (s->avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL &&
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]);
120 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO && (ext.den!=1 || ext.num!=1))
122 if (av_gcd(ext.den, ext.num) != 1)
126 || av_nearer_q(target, bestq, q) < 0
127 || ext.num==1 && ext.den==1 && av_nearer_q(target, bestq, q) == 0) {
129 s->frame_rate_index = i;
130 s->mpeg2_frame_rate_ext.num = ext.num;
131 s->mpeg2_frame_rate_ext.den = ext.den;
137 if (av_cmp_q(target, bestq))
143 static av_cold int encode_init(AVCodecContext *avctx)
146 MpegEncContext *s = avctx->priv_data;
147 int max_size = avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 16383 : 4095;
149 if (avctx->width > max_size || avctx->height > max_size) {
150 av_log(avctx, AV_LOG_ERROR, "%s does not support resolutions above %dx%d\n",
151 CONFIG_SMALL ? avctx->codec->name : avctx->codec->long_name,
153 return AVERROR(EINVAL);
155 if ((avctx->width & 0xFFF) == 0 && (avctx->height & 0xFFF) == 1) {
156 av_log(avctx, AV_LOG_ERROR, "Width / Height is invalid for MPEG2\n");
157 return AVERROR(EINVAL);
160 if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
161 if ((avctx->width & 0xFFF) == 0 || (avctx->height & 0xFFF) == 0) {
162 av_log(avctx, AV_LOG_ERROR, "Width or Height are not allowed to be multiples of 4096\n"
163 "add '-strict %d' if you want to use them anyway.\n", FF_COMPLIANCE_UNOFFICIAL);
164 return AVERROR(EINVAL);
168 if (avctx->profile == FF_PROFILE_UNKNOWN) {
169 if (avctx->level != FF_LEVEL_UNKNOWN) {
170 av_log(avctx, AV_LOG_ERROR, "Set profile and level\n");
171 return AVERROR(EINVAL);
174 avctx->profile = avctx->pix_fmt == AV_PIX_FMT_YUV420P ? FF_PROFILE_MPEG2_MAIN
175 : FF_PROFILE_MPEG2_422;
177 if (avctx->level == FF_LEVEL_UNKNOWN) {
178 if (avctx->profile == FF_PROFILE_MPEG2_422) { /* 4:2:2 */
179 if (avctx->width <= 720 && avctx->height <= 608)
180 avctx->level = 5; /* Main */
182 avctx->level = 2; /* High */
184 if (avctx->profile != FF_PROFILE_MPEG2_HIGH &&
185 avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
186 av_log(avctx, AV_LOG_ERROR,
187 "Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n");
188 return AVERROR(EINVAL);
190 if (avctx->width <= 720 && avctx->height <= 576)
191 avctx->level = 8; /* Main */
192 else if (avctx->width <= 1440)
193 avctx->level = 6; /* High 1440 */
195 avctx->level = 4; /* High */
199 if ((ret = ff_mpv_encode_init(avctx)) < 0)
202 if (find_frame_rate_index(s) < 0) {
203 if (s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
204 av_log(avctx, AV_LOG_ERROR, "MPEG-1/2 does not support %d/%d fps\n",
205 avctx->time_base.den, avctx->time_base.num);
206 return AVERROR(EINVAL);
208 av_log(avctx, AV_LOG_INFO,
209 "MPEG-1/2 does not support %d/%d fps, there may be AV sync issues\n",
210 avctx->time_base.den, avctx->time_base.num);
214 s->drop_frame_timecode = s->drop_frame_timecode || !!(avctx->flags2 & AV_CODEC_FLAG2_DROP_FRAME_TIMECODE);
215 if (s->drop_frame_timecode)
216 s->tc.flags |= AV_TIMECODE_FLAG_DROPFRAME;
217 if (s->drop_frame_timecode && s->frame_rate_index != 4) {
218 av_log(avctx, AV_LOG_ERROR,
219 "Drop frame time code only allowed with 1001/30000 fps\n");
220 return AVERROR(EINVAL);
224 AVRational rate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
225 int ret = av_timecode_init_from_string(&s->tc, rate, s->tc_opt_str, s);
228 s->drop_frame_timecode = !!(s->tc.flags & AV_TIMECODE_FLAG_DROPFRAME);
229 s->timecode_frame_start = s->tc.start;
231 s->timecode_frame_start = 0; // default is -1
237 static void put_header(MpegEncContext *s, int header)
239 align_put_bits(&s->pb);
240 put_bits(&s->pb, 16, header >> 16);
241 put_sbits(&s->pb, 16, header);
244 /* put sequence header if needed */
245 static void mpeg1_encode_sequence_header(MpegEncContext *s)
247 unsigned int vbv_buffer_size, fps, v;
248 int i, constraint_parameter_flag;
250 int64_t best_aspect_error = INT64_MAX;
251 AVRational aspect_ratio = s->avctx->sample_aspect_ratio;
253 if (aspect_ratio.num == 0 || aspect_ratio.den == 0)
254 aspect_ratio = (AVRational){1,1}; // pixel aspect 1.1 (VGA)
256 if (s->current_picture.f->key_frame) {
257 AVRational framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
259 /* MPEG-1 header repeated every GOP */
260 put_header(s, SEQ_START_CODE);
262 put_sbits(&s->pb, 12, s->width & 0xFFF);
263 put_sbits(&s->pb, 12, s->height & 0xFFF);
265 for (i = 1; i < 15; i++) {
266 int64_t error = aspect_ratio.num * (1LL<<32) / aspect_ratio.den;
267 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || i <= 1)
268 error -= (1LL<<32) / ff_mpeg1_aspect[i];
270 error -= (1LL<<32)*ff_mpeg2_aspect[i].num * s->height / s->width / ff_mpeg2_aspect[i].den;
272 error = FFABS(error);
274 if (error - 2 <= best_aspect_error) {
275 best_aspect_error = error;
276 s->aspect_ratio_info = i;
280 put_bits(&s->pb, 4, s->aspect_ratio_info);
281 put_bits(&s->pb, 4, s->frame_rate_index);
283 if (s->avctx->rc_max_rate) {
284 v = (s->avctx->rc_max_rate + 399) / 400;
285 if (v > 0x3ffff && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
291 if (s->avctx->rc_buffer_size)
292 vbv_buffer_size = s->avctx->rc_buffer_size;
294 /* VBV calculation: Scaled so that a VCD has the proper
295 * VBV size of 40 kilobytes */
296 vbv_buffer_size = ((20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
297 vbv_buffer_size = (vbv_buffer_size + 16383) / 16384;
299 put_sbits(&s->pb, 18, v);
300 put_bits(&s->pb, 1, 1); // marker
301 put_sbits(&s->pb, 10, vbv_buffer_size);
303 constraint_parameter_flag =
306 s->mb_width * s->mb_height <= 396 &&
307 s->mb_width * s->mb_height * framerate.num <= 396 * 25 * framerate.den &&
308 framerate.num <= framerate.den * 30 &&
309 s->avctx->me_range &&
310 s->avctx->me_range < 128 &&
311 vbv_buffer_size <= 20 &&
312 v <= 1856000 / 400 &&
313 s->codec_id == AV_CODEC_ID_MPEG1VIDEO;
315 put_bits(&s->pb, 1, constraint_parameter_flag);
317 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
318 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
320 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
321 AVFrameSideData *side_data;
322 int width = s->width;
323 int height = s->height;
324 int use_seq_disp_ext;
326 put_header(s, EXT_START_CODE);
327 put_bits(&s->pb, 4, 1); // seq ext
329 put_bits(&s->pb, 1, s->avctx->profile == FF_PROFILE_MPEG2_422); // escx 1 for 4:2:2 profile
331 put_bits(&s->pb, 3, s->avctx->profile); // profile
332 put_bits(&s->pb, 4, s->avctx->level); // level
334 put_bits(&s->pb, 1, s->progressive_sequence);
335 put_bits(&s->pb, 2, s->chroma_format);
336 put_bits(&s->pb, 2, s->width >> 12);
337 put_bits(&s->pb, 2, s->height >> 12);
338 put_bits(&s->pb, 12, v >> 18); // bitrate ext
339 put_bits(&s->pb, 1, 1); // marker
340 put_bits(&s->pb, 8, vbv_buffer_size >> 10); // vbv buffer ext
341 put_bits(&s->pb, 1, s->low_delay);
342 put_bits(&s->pb, 2, s->mpeg2_frame_rate_ext.num-1); // frame_rate_ext_n
343 put_bits(&s->pb, 5, s->mpeg2_frame_rate_ext.den-1); // frame_rate_ext_d
345 side_data = av_frame_get_side_data(s->current_picture_ptr->f, AV_FRAME_DATA_PANSCAN);
347 AVPanScan *pan_scan = (AVPanScan *)side_data->data;
348 if (pan_scan->width && pan_scan->height) {
349 width = pan_scan->width >> 4;
350 height = pan_scan->height >> 4;
354 use_seq_disp_ext = (width != s->width ||
355 height != s->height ||
356 s->avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
357 s->avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
358 s->avctx->colorspace != AVCOL_SPC_UNSPECIFIED ||
359 s->video_format != VIDEO_FORMAT_UNSPECIFIED);
361 if (s->seq_disp_ext == 1 || (s->seq_disp_ext == -1 && use_seq_disp_ext)) {
362 put_header(s, EXT_START_CODE);
363 put_bits(&s->pb, 4, 2); // sequence display extension
364 put_bits(&s->pb, 3, s->video_format); // video_format
365 put_bits(&s->pb, 1, 1); // colour_description
366 put_bits(&s->pb, 8, s->avctx->color_primaries); // colour_primaries
367 put_bits(&s->pb, 8, s->avctx->color_trc); // transfer_characteristics
368 put_bits(&s->pb, 8, s->avctx->colorspace); // matrix_coefficients
369 put_bits(&s->pb, 14, width); // display_horizontal_size
370 put_bits(&s->pb, 1, 1); // marker_bit
371 put_bits(&s->pb, 14, height); // display_vertical_size
372 put_bits(&s->pb, 3, 0); // remaining 3 bits are zero padding
376 put_header(s, GOP_START_CODE);
377 put_bits(&s->pb, 1, s->drop_frame_timecode); // drop frame flag
378 /* time code: we must convert from the real frame rate to a
379 * fake MPEG frame rate in case of low frame rate */
380 fps = (framerate.num + framerate.den / 2) / framerate.den;
381 time_code = s->current_picture_ptr->f->coded_picture_number +
382 s->timecode_frame_start;
384 s->gop_picture_number = s->current_picture_ptr->f->coded_picture_number;
386 av_assert0(s->drop_frame_timecode == !!(s->tc.flags & AV_TIMECODE_FLAG_DROPFRAME));
387 if (s->drop_frame_timecode)
388 time_code = av_timecode_adjust_ntsc_framenum2(time_code, fps);
390 put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
391 put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
392 put_bits(&s->pb, 1, 1);
393 put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
394 put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
395 put_bits(&s->pb, 1, !!(s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) || s->intra_only || !s->gop_picture_number);
396 put_bits(&s->pb, 1, 0); // broken link
400 static inline void encode_mb_skip_run(MpegEncContext *s, int run)
403 put_bits(&s->pb, 11, 0x008);
406 put_bits(&s->pb, ff_mpeg12_mbAddrIncrTable[run][1],
407 ff_mpeg12_mbAddrIncrTable[run][0]);
410 static av_always_inline void put_qscale(MpegEncContext *s)
412 put_bits(&s->pb, 5, s->qscale);
415 void ff_mpeg1_encode_slice_header(MpegEncContext *s)
417 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->height > 2800) {
418 put_header(s, SLICE_MIN_START_CODE + (s->mb_y & 127));
419 /* slice_vertical_position_extension */
420 put_bits(&s->pb, 3, s->mb_y >> 7);
422 put_header(s, SLICE_MIN_START_CODE + s->mb_y);
425 /* slice extra information */
426 put_bits(&s->pb, 1, 0);
429 void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
431 AVFrameSideData *side_data;
432 mpeg1_encode_sequence_header(s);
434 /* MPEG-1 picture header */
435 put_header(s, PICTURE_START_CODE);
436 /* temporal reference */
438 // RAL: s->picture_number instead of s->fake_picture_number
440 (s->picture_number - s->gop_picture_number) & 0x3ff);
441 put_bits(&s->pb, 3, s->pict_type);
443 s->vbv_delay_ptr = s->pb.buf + put_bytes_count(&s->pb, 0);
444 put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
446 // RAL: Forward f_code also needed for B-frames
447 if (s->pict_type == AV_PICTURE_TYPE_P ||
448 s->pict_type == AV_PICTURE_TYPE_B) {
449 put_bits(&s->pb, 1, 0); /* half pel coordinates */
450 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
451 put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
453 put_bits(&s->pb, 3, 7); /* forward_f_code */
456 // RAL: Backward f_code necessary for B-frames
457 if (s->pict_type == AV_PICTURE_TYPE_B) {
458 put_bits(&s->pb, 1, 0); /* half pel coordinates */
459 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
460 put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
462 put_bits(&s->pb, 3, 7); /* backward_f_code */
465 put_bits(&s->pb, 1, 0); /* extra bit picture */
467 s->frame_pred_frame_dct = 1;
468 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
469 put_header(s, EXT_START_CODE);
470 put_bits(&s->pb, 4, 8); /* pic ext */
471 if (s->pict_type == AV_PICTURE_TYPE_P ||
472 s->pict_type == AV_PICTURE_TYPE_B) {
473 put_bits(&s->pb, 4, s->f_code);
474 put_bits(&s->pb, 4, s->f_code);
476 put_bits(&s->pb, 8, 255);
478 if (s->pict_type == AV_PICTURE_TYPE_B) {
479 put_bits(&s->pb, 4, s->b_code);
480 put_bits(&s->pb, 4, s->b_code);
482 put_bits(&s->pb, 8, 255);
484 put_bits(&s->pb, 2, s->intra_dc_precision);
486 av_assert0(s->picture_structure == PICT_FRAME);
487 put_bits(&s->pb, 2, s->picture_structure);
488 if (s->progressive_sequence)
489 put_bits(&s->pb, 1, 0); /* no repeat */
491 put_bits(&s->pb, 1, s->current_picture_ptr->f->top_field_first);
492 /* XXX: optimize the generation of this flag with entropy measures */
493 s->frame_pred_frame_dct = s->progressive_sequence;
495 put_bits(&s->pb, 1, s->frame_pred_frame_dct);
496 put_bits(&s->pb, 1, s->concealment_motion_vectors);
497 put_bits(&s->pb, 1, s->q_scale_type);
498 put_bits(&s->pb, 1, s->intra_vlc_format);
499 put_bits(&s->pb, 1, s->alternate_scan);
500 put_bits(&s->pb, 1, s->repeat_first_field);
501 s->progressive_frame = s->progressive_sequence;
502 /* chroma_420_type */
503 put_bits(&s->pb, 1, s->chroma_format ==
504 CHROMA_420 ? s->progressive_frame : 0);
505 put_bits(&s->pb, 1, s->progressive_frame);
506 put_bits(&s->pb, 1, 0); /* composite_display_flag */
508 if (s->scan_offset) {
511 put_header(s, USER_START_CODE);
512 for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
513 put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
515 side_data = av_frame_get_side_data(s->current_picture_ptr->f,
516 AV_FRAME_DATA_STEREO3D);
518 AVStereo3D *stereo = (AVStereo3D *)side_data->data;
521 switch (stereo->type) {
522 case AV_STEREO3D_SIDEBYSIDE:
525 case AV_STEREO3D_TOPBOTTOM:
531 case AV_STEREO3D_SIDEBYSIDE_QUINCUNX:
540 put_header(s, USER_START_CODE);
541 put_bits(&s->pb, 8, 'J'); // S3D_video_format_signaling_identifier
542 put_bits(&s->pb, 8, 'P');
543 put_bits(&s->pb, 8, '3');
544 put_bits(&s->pb, 8, 'D');
545 put_bits(&s->pb, 8, 0x03); // S3D_video_format_length
547 put_bits(&s->pb, 1, 1); // reserved_bit
548 put_bits(&s->pb, 7, fpa_type); // S3D_video_format_type
549 put_bits(&s->pb, 8, 0x04); // reserved_data[0]
550 put_bits(&s->pb, 8, 0xFF); // reserved_data[1]
554 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->a53_cc) {
555 side_data = av_frame_get_side_data(s->current_picture_ptr->f,
556 AV_FRAME_DATA_A53_CC);
558 if (side_data->size <= A53_MAX_CC_COUNT * 3 && side_data->size % 3 == 0) {
561 put_header (s, USER_START_CODE);
563 put_bits(&s->pb, 8, 'G'); // user_identifier
564 put_bits(&s->pb, 8, 'A');
565 put_bits(&s->pb, 8, '9');
566 put_bits(&s->pb, 8, '4');
567 put_bits(&s->pb, 8, 3); // user_data_type_code
569 (side_data->size / 3 & A53_MAX_CC_COUNT) | 0x40); // flags, cc_count
570 put_bits(&s->pb, 8, 0xff); // em_data
572 for (i = 0; i < side_data->size; i++)
573 put_bits(&s->pb, 8, side_data->data[i]);
575 put_bits(&s->pb, 8, 0xff); // marker_bits
577 av_log(s->avctx, AV_LOG_WARNING,
578 "Warning Closed Caption size (%d) can not exceed 93 bytes "
579 "and must be a multiple of 3\n", side_data->size);
585 ff_mpeg1_encode_slice_header(s);
588 static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
589 int has_mv, int field_motion)
591 put_bits(&s->pb, n, bits);
592 if (!s->frame_pred_frame_dct) {
594 /* motion_type: frame/field */
595 put_bits(&s->pb, 2, 2 - field_motion);
596 put_bits(&s->pb, 1, s->interlaced_dct);
600 // RAL: Parameter added: f_or_b_code
601 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
606 ff_mpeg12_mbMotionVectorTable[0][1],
607 ff_mpeg12_mbMotionVectorTable[0][0]);
609 int code, sign, bits;
610 int bit_size = f_or_b_code - 1;
611 int range = 1 << bit_size;
612 /* modulo encoding */
613 val = sign_extend(val, 5 + bit_size);
617 code = (val >> bit_size) + 1;
618 bits = val & (range - 1);
623 code = (val >> bit_size) + 1;
624 bits = val & (range - 1);
628 av_assert2(code > 0 && code <= 16);
631 ff_mpeg12_mbMotionVectorTable[code][1],
632 ff_mpeg12_mbMotionVectorTable[code][0]);
634 put_bits(&s->pb, 1, sign);
636 put_bits(&s->pb, bit_size, bits);
640 static inline void encode_dc(MpegEncContext *s, int diff, int component)
642 unsigned int diff_u = diff + 255;
647 index = av_log2_16bit(-2 * diff);
650 index = av_log2_16bit(2 * diff);
654 ff_mpeg12_vlc_dc_lum_bits[index] + index,
655 (ff_mpeg12_vlc_dc_lum_code[index] << index) +
656 av_mod_uintp2(diff, index));
659 ff_mpeg12_vlc_dc_chroma_bits[index] + index,
660 (ff_mpeg12_vlc_dc_chroma_code[index] << index) +
661 av_mod_uintp2(diff, index));
665 mpeg1_lum_dc_uni[diff + 255] & 0xFF,
666 mpeg1_lum_dc_uni[diff + 255] >> 8);
669 mpeg1_chr_dc_uni[diff + 255] & 0xFF,
670 mpeg1_chr_dc_uni[diff + 255] >> 8);
674 static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n)
676 int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
678 const uint16_t (*table_vlc)[2] = ff_rl_mpeg1.table_vlc;
680 last_index = s->block_last_index[n];
684 component = (n <= 3 ? 0 : (n & 1) + 1);
685 dc = block[0]; /* overflow is impossible */
686 diff = dc - s->last_dc[component];
687 encode_dc(s, diff, component);
688 s->last_dc[component] = dc;
690 if (s->intra_vlc_format)
691 table_vlc = ff_rl_mpeg2.table_vlc;
693 /* encode the first coefficient: needs to be done here because
694 * it is handled slightly differently */
696 if (abs(level) == 1) {
697 code = ((uint32_t)level >> 31); /* the sign bit */
698 put_bits(&s->pb, 2, code | 0x02);
707 /* now quantify & encode AC coefs */
708 last_non_zero = i - 1;
710 for (; i <= last_index; i++) {
711 j = s->intra_scantable.permutated[i];
715 /* encode using VLC */
717 run = i - last_non_zero - 1;
720 MASK_ABS(sign, alevel);
723 if (alevel <= ff_rl_mpeg1.max_level[0][run]) {
724 code = ff_rl_mpeg1.index_run[0][run] + alevel - 1;
725 /* store the VLC & sign at once */
726 put_bits(&s->pb, table_vlc[code][1] + 1,
727 (table_vlc[code][0] << 1) + sign);
729 /* escape seems to be pretty rare <5% so I do not optimize it */
730 put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]);
731 /* escape: only clip in this case */
732 put_bits(&s->pb, 6, run);
733 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
735 put_sbits(&s->pb, 8, level);
738 put_bits(&s->pb, 16, 0x8001 + level + 255);
740 put_sbits(&s->pb, 16, level);
743 put_sbits(&s->pb, 12, level);
750 put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
753 static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s,
754 int16_t block[8][64],
755 int motion_x, int motion_y,
759 const int mb_x = s->mb_x;
760 const int mb_y = s->mb_y;
761 const int first_mb = mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
765 for (i = 0; i < mb_block_count; i++)
766 if (s->block_last_index[i] >= 0)
767 cbp |= 1 << (mb_block_count - 1 - i);
769 if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 &&
770 (mb_x != s->mb_width - 1 ||
771 (mb_y != s->end_mb_y - 1 && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)) &&
772 ((s->pict_type == AV_PICTURE_TYPE_P && (motion_x | motion_y) == 0) ||
773 (s->pict_type == AV_PICTURE_TYPE_B && s->mv_dir == s->last_mv_dir &&
774 (((s->mv_dir & MV_DIR_FORWARD)
775 ? ((s->mv[0][0][0] - s->last_mv[0][0][0]) |
776 (s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
777 ((s->mv_dir & MV_DIR_BACKWARD)
778 ? ((s->mv[1][0][0] - s->last_mv[1][0][0]) |
779 (s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
781 s->qscale -= s->dquant;
785 if (s->pict_type == AV_PICTURE_TYPE_P) {
786 s->last_mv[0][0][0] =
787 s->last_mv[0][0][1] =
788 s->last_mv[0][1][0] =
789 s->last_mv[0][1][1] = 0;
793 av_assert0(s->mb_skip_run == 0);
794 encode_mb_skip_run(s, s->mb_x);
796 encode_mb_skip_run(s, s->mb_skip_run);
799 if (s->pict_type == AV_PICTURE_TYPE_I) {
800 if (s->dquant && cbp) {
801 /* macroblock_type: macroblock_quant = 1 */
802 put_mb_modes(s, 2, 1, 0, 0);
805 /* macroblock_type: macroblock_quant = 0 */
806 put_mb_modes(s, 1, 1, 0, 0);
807 s->qscale -= s->dquant;
809 s->misc_bits += get_bits_diff(s);
811 } else if (s->mb_intra) {
812 if (s->dquant && cbp) {
813 put_mb_modes(s, 6, 0x01, 0, 0);
816 put_mb_modes(s, 5, 0x03, 0, 0);
817 s->qscale -= s->dquant;
819 s->misc_bits += get_bits_diff(s);
821 memset(s->last_mv, 0, sizeof(s->last_mv));
822 } else if (s->pict_type == AV_PICTURE_TYPE_P) {
823 if (s->mv_type == MV_TYPE_16X16) {
825 if ((motion_x | motion_y) == 0) {
827 /* macroblock_pattern & quant */
828 put_mb_modes(s, 5, 1, 0, 0);
831 /* macroblock_pattern only */
832 put_mb_modes(s, 2, 1, 0, 0);
834 s->misc_bits += get_bits_diff(s);
837 put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */
840 put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */
842 s->misc_bits += get_bits_diff(s);
843 // RAL: f_code parameter added
844 mpeg1_encode_motion(s,
845 motion_x - s->last_mv[0][0][0],
847 // RAL: f_code parameter added
848 mpeg1_encode_motion(s,
849 motion_y - s->last_mv[0][0][1],
851 s->mv_bits += get_bits_diff(s);
854 put_bits(&s->pb, 3, 1); /* motion only */
855 if (!s->frame_pred_frame_dct)
856 put_bits(&s->pb, 2, 2); /* motion_type: frame */
857 s->misc_bits += get_bits_diff(s);
858 // RAL: f_code parameter added
859 mpeg1_encode_motion(s,
860 motion_x - s->last_mv[0][0][0],
862 // RAL: f_code parameter added
863 mpeg1_encode_motion(s,
864 motion_y - s->last_mv[0][0][1],
866 s->qscale -= s->dquant;
867 s->mv_bits += get_bits_diff(s);
869 s->last_mv[0][1][0] = s->last_mv[0][0][0] = motion_x;
870 s->last_mv[0][1][1] = s->last_mv[0][0][1] = motion_y;
872 av_assert2(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD);
876 put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
879 put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
882 put_bits(&s->pb, 3, 1); /* motion only */
883 put_bits(&s->pb, 2, 1); /* motion_type: field */
884 s->qscale -= s->dquant;
886 s->misc_bits += get_bits_diff(s);
887 for (i = 0; i < 2; i++) {
888 put_bits(&s->pb, 1, s->field_select[0][i]);
889 mpeg1_encode_motion(s,
890 s->mv[0][i][0] - s->last_mv[0][i][0],
892 mpeg1_encode_motion(s,
893 s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
895 s->last_mv[0][i][0] = s->mv[0][i][0];
896 s->last_mv[0][i][1] = 2 * s->mv[0][i][1];
898 s->mv_bits += get_bits_diff(s);
901 if (s->chroma_y_shift) {
903 ff_mpeg12_mbPatTable[cbp][1],
904 ff_mpeg12_mbPatTable[cbp][0]);
907 ff_mpeg12_mbPatTable[cbp >> 2][1],
908 ff_mpeg12_mbPatTable[cbp >> 2][0]);
909 put_sbits(&s->pb, 2, cbp);
914 if (s->mv_type == MV_TYPE_16X16) {
915 if (cbp) { // With coded bloc pattern
917 if (s->mv_dir == MV_DIR_FORWARD)
918 put_mb_modes(s, 6, 3, 1, 0);
920 put_mb_modes(s, 8 - s->mv_dir, 2, 1, 0);
923 put_mb_modes(s, 5 - s->mv_dir, 3, 1, 0);
925 } else { // No coded bloc pattern
926 put_bits(&s->pb, 5 - s->mv_dir, 2);
927 if (!s->frame_pred_frame_dct)
928 put_bits(&s->pb, 2, 2); /* motion_type: frame */
929 s->qscale -= s->dquant;
931 s->misc_bits += get_bits_diff(s);
932 if (s->mv_dir & MV_DIR_FORWARD) {
933 mpeg1_encode_motion(s,
934 s->mv[0][0][0] - s->last_mv[0][0][0],
936 mpeg1_encode_motion(s,
937 s->mv[0][0][1] - s->last_mv[0][0][1],
939 s->last_mv[0][0][0] =
940 s->last_mv[0][1][0] = s->mv[0][0][0];
941 s->last_mv[0][0][1] =
942 s->last_mv[0][1][1] = s->mv[0][0][1];
945 if (s->mv_dir & MV_DIR_BACKWARD) {
946 mpeg1_encode_motion(s,
947 s->mv[1][0][0] - s->last_mv[1][0][0],
949 mpeg1_encode_motion(s,
950 s->mv[1][0][1] - s->last_mv[1][0][1],
952 s->last_mv[1][0][0] =
953 s->last_mv[1][1][0] = s->mv[1][0][0];
954 s->last_mv[1][0][1] =
955 s->last_mv[1][1][1] = s->mv[1][0][1];
959 av_assert2(s->mv_type == MV_TYPE_FIELD);
960 av_assert2(!s->frame_pred_frame_dct);
961 if (cbp) { // With coded bloc pattern
963 if (s->mv_dir == MV_DIR_FORWARD)
964 put_mb_modes(s, 6, 3, 1, 1);
966 put_mb_modes(s, 8 - s->mv_dir, 2, 1, 1);
969 put_mb_modes(s, 5 - s->mv_dir, 3, 1, 1);
971 } else { // No coded bloc pattern
972 put_bits(&s->pb, 5 - s->mv_dir, 2);
973 put_bits(&s->pb, 2, 1); /* motion_type: field */
974 s->qscale -= s->dquant;
976 s->misc_bits += get_bits_diff(s);
977 if (s->mv_dir & MV_DIR_FORWARD) {
978 for (i = 0; i < 2; i++) {
979 put_bits(&s->pb, 1, s->field_select[0][i]);
980 mpeg1_encode_motion(s,
981 s->mv[0][i][0] - s->last_mv[0][i][0],
983 mpeg1_encode_motion(s,
984 s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
986 s->last_mv[0][i][0] = s->mv[0][i][0];
987 s->last_mv[0][i][1] = s->mv[0][i][1] * 2;
991 if (s->mv_dir & MV_DIR_BACKWARD) {
992 for (i = 0; i < 2; i++) {
993 put_bits(&s->pb, 1, s->field_select[1][i]);
994 mpeg1_encode_motion(s,
995 s->mv[1][i][0] - s->last_mv[1][i][0],
997 mpeg1_encode_motion(s,
998 s->mv[1][i][1] - (s->last_mv[1][i][1] >> 1),
1000 s->last_mv[1][i][0] = s->mv[1][i][0];
1001 s->last_mv[1][i][1] = s->mv[1][i][1] * 2;
1006 s->mv_bits += get_bits_diff(s);
1008 if (s->chroma_y_shift) {
1010 ff_mpeg12_mbPatTable[cbp][1],
1011 ff_mpeg12_mbPatTable[cbp][0]);
1014 ff_mpeg12_mbPatTable[cbp >> 2][1],
1015 ff_mpeg12_mbPatTable[cbp >> 2][0]);
1016 put_sbits(&s->pb, 2, cbp);
1020 for (i = 0; i < mb_block_count; i++)
1021 if (cbp & (1 << (mb_block_count - 1 - i)))
1022 mpeg1_encode_block(s, block[i], i);
1025 s->i_tex_bits += get_bits_diff(s);
1027 s->p_tex_bits += get_bits_diff(s);
1031 void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64],
1032 int motion_x, int motion_y)
1034 if (s->chroma_format == CHROMA_420)
1035 mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6);
1037 mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8);
1040 static av_cold void mpeg12_encode_init_static(void)
1042 static uint8_t mpeg12_static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3];
1044 ff_rl_init(&ff_rl_mpeg1, mpeg12_static_rl_table_store[0]);
1045 ff_rl_init(&ff_rl_mpeg2, mpeg12_static_rl_table_store[1]);
1047 ff_mpeg1_init_uni_ac_vlc(&ff_rl_mpeg1, uni_mpeg1_ac_vlc_len);
1048 ff_mpeg1_init_uni_ac_vlc(&ff_rl_mpeg2, uni_mpeg2_ac_vlc_len);
1050 /* build unified dc encoding tables */
1051 for (int i = -255; i < 256; i++) {
1056 adiff = FFABS(diff);
1059 index = av_log2(2 * adiff);
1061 bits = ff_mpeg12_vlc_dc_lum_bits[index] + index;
1062 code = (ff_mpeg12_vlc_dc_lum_code[index] << index) +
1063 av_mod_uintp2(diff, index);
1064 mpeg1_lum_dc_uni[i + 255] = bits + (code << 8);
1066 bits = ff_mpeg12_vlc_dc_chroma_bits[index] + index;
1067 code = (ff_mpeg12_vlc_dc_chroma_code[index] << index) +
1068 av_mod_uintp2(diff, index);
1069 mpeg1_chr_dc_uni[i + 255] = bits + (code << 8);
1072 for (int f_code = 1; f_code <= MAX_FCODE; f_code++)
1073 for (int mv = -MAX_DMV; mv <= MAX_DMV; mv++) {
1077 len = ff_mpeg12_mbMotionVectorTable[0][1];
1079 int val, bit_size, code;
1081 bit_size = f_code - 1;
1087 code = (val >> bit_size) + 1;
1089 len = ff_mpeg12_mbMotionVectorTable[code][1] +
1092 len = ff_mpeg12_mbMotionVectorTable[16][1] +
1096 mv_penalty[f_code][mv + MAX_DMV] = len;
1100 for (int f_code = MAX_FCODE; f_code > 0; f_code--)
1101 for (int mv = -(8 << f_code); mv < (8 << f_code); mv++)
1102 fcode_tab[mv + MAX_MV] = f_code;
1105 av_cold void ff_mpeg1_encode_init(MpegEncContext *s)
1107 static AVOnce init_static_once = AV_ONCE_INIT;
1109 ff_mpeg12_common_init(s);
1111 s->me.mv_penalty = mv_penalty;
1112 s->fcode_tab = fcode_tab;
1113 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1114 s->min_qcoeff = -255;
1115 s->max_qcoeff = 255;
1117 s->min_qcoeff = -2047;
1118 s->max_qcoeff = 2047;
1120 if (s->intra_vlc_format) {
1121 s->intra_ac_vlc_length =
1122 s->intra_ac_vlc_last_length = uni_mpeg2_ac_vlc_len;
1124 s->intra_ac_vlc_length =
1125 s->intra_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1127 s->inter_ac_vlc_length =
1128 s->inter_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1130 ff_thread_once(&init_static_once, mpeg12_encode_init_static);
1133 #define OFFSET(x) offsetof(MpegEncContext, x)
1134 #define VE AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
1135 #define COMMON_OPTS \
1136 { "gop_timecode", "MPEG GOP Timecode in hh:mm:ss[:;.]ff format. Overrides timecode_frame_start.", \
1137 OFFSET(tc_opt_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE },\
1138 { "drop_frame_timecode", "Timecode is in drop frame format.", \
1139 OFFSET(drop_frame_timecode), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1140 { "scan_offset", "Reserve space for SVCD scan offset user data.", \
1141 OFFSET(scan_offset), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1142 { "timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", \
1143 OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = -1 }, -1, INT64_MAX, VE}, \
1144 FF_MPV_COMMON_BFRAME_OPTS
1146 static const AVOption mpeg1_options[] = {
1149 #if FF_API_MPEGVIDEO_OPTS
1150 FF_MPV_DEPRECATED_MPEG_QUANT_OPT
1151 FF_MPV_DEPRECATED_A53_CC_OPT
1152 FF_MPV_DEPRECATED_MATRIX_OPT
1157 static const AVOption mpeg2_options[] = {
1159 { "intra_vlc", "Use MPEG-2 intra VLC table.",
1160 OFFSET(intra_vlc_format), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1161 { "non_linear_quant", "Use nonlinear quantizer.", OFFSET(q_scale_type), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1162 { "alternate_scan", "Enable alternate scantable.", OFFSET(alternate_scan), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1163 { "a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
1164 { "seq_disp_ext", "Write sequence_display_extension blocks.", OFFSET(seq_disp_ext), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "seq_disp_ext" },
1165 { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, VE, "seq_disp_ext" },
1166 { "never", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, VE, "seq_disp_ext" },
1167 { "always", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, VE, "seq_disp_ext" },
1168 { "video_format", "Video_format in the sequence_display_extension indicating the source of the video.", OFFSET(video_format), AV_OPT_TYPE_INT, { .i64 = VIDEO_FORMAT_UNSPECIFIED }, 0, 7, VE, "video_format" },
1169 { "component", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_COMPONENT }, 0, 0, VE, "video_format" },
1170 { "pal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_PAL }, 0, 0, VE, "video_format" },
1171 { "ntsc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_NTSC }, 0, 0, VE, "video_format" },
1172 { "secam", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_SECAM }, 0, 0, VE, "video_format" },
1173 { "mac", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_MAC }, 0, 0, VE, "video_format" },
1174 { "unspecified", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_UNSPECIFIED}, 0, 0, VE, "video_format" },
1175 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, { .i64 = value }, 0, 0, VE, "avctx.level"
1176 { LEVEL("high", 4) },
1177 { LEVEL("high1440", 6) },
1178 { LEVEL("main", 8) },
1179 { LEVEL("low", 10) },
1182 #if FF_API_MPEGVIDEO_OPTS
1183 { "mpeg_quant", "Deprecated, does nothing", OFFSET(mpeg_quant),
1184 AV_OPT_TYPE_INT, {.i64 = 1 }, 0, 1, VE | AV_OPT_FLAG_DEPRECATED },
1185 FF_MPV_DEPRECATED_MATRIX_OPT
1187 FF_MPEG2_PROFILE_OPTS
1191 #define mpeg12_class(x) \
1192 static const AVClass mpeg ## x ## _class = { \
1193 .class_name = "mpeg" # x "video encoder", \
1194 .item_name = av_default_item_name, \
1195 .option = mpeg ## x ## _options, \
1196 .version = LIBAVUTIL_VERSION_INT, \
1202 AVCodec ff_mpeg1video_encoder = {
1203 .name = "mpeg1video",
1204 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
1205 .type = AVMEDIA_TYPE_VIDEO,
1206 .id = AV_CODEC_ID_MPEG1VIDEO,
1207 .priv_data_size = sizeof(MpegEncContext),
1208 .init = encode_init,
1209 .encode2 = ff_mpv_encode_picture,
1210 .close = ff_mpv_encode_end,
1211 .supported_framerates = ff_mpeg12_frame_rate_tab + 1,
1212 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
1214 .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
1215 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
1216 .priv_class = &mpeg1_class,
1219 AVCodec ff_mpeg2video_encoder = {
1220 .name = "mpeg2video",
1221 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
1222 .type = AVMEDIA_TYPE_VIDEO,
1223 .id = AV_CODEC_ID_MPEG2VIDEO,
1224 .priv_data_size = sizeof(MpegEncContext),
1225 .init = encode_init,
1226 .encode2 = ff_mpv_encode_picture,
1227 .close = ff_mpv_encode_end,
1228 .supported_framerates = ff_mpeg2_frame_rate_tab,
1229 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
1232 .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
1233 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
1234 .priv_class = &mpeg2_class,
1236 #endif /* CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER */