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