1/* 2 * MPEG-1/2 decoder 3 * Copyright (c) 2000, 2001 Fabrice Bellard 4 * Copyright (c) 2002-2013 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 decoder 26 */ 27 28#include "config_components.h" 29 30#define UNCHECKED_BITSTREAM_READER 1 31#include <inttypes.h> 32 33#include "libavutil/attributes.h" 34#include "libavutil/imgutils.h" 35#include "libavutil/internal.h" 36#include "libavutil/mem_internal.h" 37#include "libavutil/reverse.h" 38#include "libavutil/stereo3d.h" 39#include "libavutil/timecode.h" 40 41#include "avcodec.h" 42#include "codec_internal.h" 43#include "error_resilience.h" 44#include "hwconfig.h" 45#include "idctdsp.h" 46#include "internal.h" 47#include "mpeg_er.h" 48#include "mpeg12.h" 49#include "mpeg12data.h" 50#include "mpeg12dec.h" 51#include "mpegutils.h" 52#include "mpegvideo.h" 53#include "mpegvideodata.h" 54#include "mpegvideodec.h" 55#include "profiles.h" 56#include "startcode.h" 57#include "thread.h" 58 59#define A53_MAX_CC_COUNT 2000 60 61typedef struct Mpeg1Context { 62 MpegEncContext mpeg_enc_ctx; 63 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */ 64 int repeat_field; /* true if we must repeat the field */ 65 AVPanScan pan_scan; /* some temporary storage for the panscan */ 66 AVStereo3D stereo3d; 67 int has_stereo3d; 68 AVBufferRef *a53_buf_ref; 69 uint8_t afd; 70 int has_afd; 71 int slice_count; 72 unsigned aspect_ratio_info; 73 AVRational save_aspect; 74 int save_width, save_height, save_progressive_seq; 75 int rc_buffer_size; 76 AVRational frame_rate_ext; /* MPEG-2 specific framerate modificator */ 77 unsigned frame_rate_index; 78 int sync; /* Did we reach a sync point like a GOP/SEQ/KEYFrame? */ 79 int closed_gop; 80 int tmpgexs; 81 int first_slice; 82 int extradata_decoded; 83 int64_t timecode_frame_start; /*< GOP timecode frame start number, in non drop frame format */ 84} Mpeg1Context; 85 86#define MB_TYPE_ZERO_MV 0x20000000 87 88static const uint32_t ptype2mb_type[7] = { 89 MB_TYPE_INTRA, 90 MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16, 91 MB_TYPE_L0, 92 MB_TYPE_L0 | MB_TYPE_CBP, 93 MB_TYPE_QUANT | MB_TYPE_INTRA, 94 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16, 95 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP, 96}; 97 98static const uint32_t btype2mb_type[11] = { 99 MB_TYPE_INTRA, 100 MB_TYPE_L1, 101 MB_TYPE_L1 | MB_TYPE_CBP, 102 MB_TYPE_L0, 103 MB_TYPE_L0 | MB_TYPE_CBP, 104 MB_TYPE_L0L1, 105 MB_TYPE_L0L1 | MB_TYPE_CBP, 106 MB_TYPE_QUANT | MB_TYPE_INTRA, 107 MB_TYPE_QUANT | MB_TYPE_L1 | MB_TYPE_CBP, 108 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP, 109 MB_TYPE_QUANT | MB_TYPE_L0L1 | MB_TYPE_CBP, 110}; 111 112/* as H.263, but only 17 codes */ 113static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred) 114{ 115 int code, sign, val, shift; 116 117 code = get_vlc2(&s->gb, ff_mv_vlc.table, MV_VLC_BITS, 2); 118 if (code == 0) 119 return pred; 120 if (code < 0) 121 return 0xffff; 122 123 sign = get_bits1(&s->gb); 124 shift = fcode - 1; 125 val = code; 126 if (shift) { 127 val = (val - 1) << shift; 128 val |= get_bits(&s->gb, shift); 129 val++; 130 } 131 if (sign) 132 val = -val; 133 val += pred; 134 135 /* modulo decoding */ 136 return sign_extend(val, 5 + shift); 137} 138 139#define MAX_INDEX (64 - 1) 140#define check_scantable_index(ctx, x) \ 141 do { \ 142 if ((x) > MAX_INDEX) { \ 143 av_log(ctx->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", \ 144 ctx->mb_x, ctx->mb_y); \ 145 return AVERROR_INVALIDDATA; \ 146 } \ 147 } while (0) 148 149static inline int mpeg1_decode_block_inter(MpegEncContext *s, 150 int16_t *block, int n) 151{ 152 int level, i, j, run; 153 RLTable *rl = &ff_rl_mpeg1; 154 uint8_t *const scantable = s->intra_scantable.permutated; 155 const uint16_t *quant_matrix = s->inter_matrix; 156 const int qscale = s->qscale; 157 158 { 159 OPEN_READER(re, &s->gb); 160 i = -1; 161 // special case for first coefficient, no need to add second VLC table 162 UPDATE_CACHE(re, &s->gb); 163 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) { 164 level = (3 * qscale * quant_matrix[0]) >> 5; 165 level = (level - 1) | 1; 166 if (GET_CACHE(re, &s->gb) & 0x40000000) 167 level = -level; 168 block[0] = level; 169 i++; 170 SKIP_BITS(re, &s->gb, 2); 171 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF) 172 goto end; 173 } 174 /* now quantify & encode AC coefficients */ 175 for (;;) { 176 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], 177 TEX_VLC_BITS, 2, 0); 178 179 if (level != 0) { 180 i += run; 181 if (i > MAX_INDEX) 182 break; 183 j = scantable[i]; 184 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5; 185 level = (level - 1) | 1; 186 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - 187 SHOW_SBITS(re, &s->gb, 1); 188 SKIP_BITS(re, &s->gb, 1); 189 } else { 190 /* escape */ 191 run = SHOW_UBITS(re, &s->gb, 6) + 1; 192 LAST_SKIP_BITS(re, &s->gb, 6); 193 UPDATE_CACHE(re, &s->gb); 194 level = SHOW_SBITS(re, &s->gb, 8); 195 SKIP_BITS(re, &s->gb, 8); 196 if (level == -128) { 197 level = SHOW_UBITS(re, &s->gb, 8) - 256; 198 SKIP_BITS(re, &s->gb, 8); 199 } else if (level == 0) { 200 level = SHOW_UBITS(re, &s->gb, 8); 201 SKIP_BITS(re, &s->gb, 8); 202 } 203 i += run; 204 if (i > MAX_INDEX) 205 break; 206 j = scantable[i]; 207 if (level < 0) { 208 level = -level; 209 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5; 210 level = (level - 1) | 1; 211 level = -level; 212 } else { 213 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5; 214 level = (level - 1) | 1; 215 } 216 } 217 218 block[j] = level; 219 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF) 220 break; 221 UPDATE_CACHE(re, &s->gb); 222 } 223end: 224 LAST_SKIP_BITS(re, &s->gb, 2); 225 CLOSE_READER(re, &s->gb); 226 } 227 228 check_scantable_index(s, i); 229 230 s->block_last_index[n] = i; 231 return 0; 232} 233 234/** 235 * Changing this would eat up any speed benefits it has. 236 * Do not use "fast" flag if you need the code to be robust. 237 */ 238static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, 239 int16_t *block, int n) 240{ 241 int level, i, j, run; 242 RLTable *rl = &ff_rl_mpeg1; 243 uint8_t *const scantable = s->intra_scantable.permutated; 244 const int qscale = s->qscale; 245 246 { 247 OPEN_READER(re, &s->gb); 248 i = -1; 249 // Special case for first coefficient, no need to add second VLC table. 250 UPDATE_CACHE(re, &s->gb); 251 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) { 252 level = (3 * qscale) >> 1; 253 level = (level - 1) | 1; 254 if (GET_CACHE(re, &s->gb) & 0x40000000) 255 level = -level; 256 block[0] = level; 257 i++; 258 SKIP_BITS(re, &s->gb, 2); 259 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF) 260 goto end; 261 } 262 263 /* now quantify & encode AC coefficients */ 264 for (;;) { 265 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], 266 TEX_VLC_BITS, 2, 0); 267 268 if (level != 0) { 269 i += run; 270 if (i > MAX_INDEX) 271 break; 272 j = scantable[i]; 273 level = ((level * 2 + 1) * qscale) >> 1; 274 level = (level - 1) | 1; 275 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - 276 SHOW_SBITS(re, &s->gb, 1); 277 SKIP_BITS(re, &s->gb, 1); 278 } else { 279 /* escape */ 280 run = SHOW_UBITS(re, &s->gb, 6) + 1; 281 LAST_SKIP_BITS(re, &s->gb, 6); 282 UPDATE_CACHE(re, &s->gb); 283 level = SHOW_SBITS(re, &s->gb, 8); 284 SKIP_BITS(re, &s->gb, 8); 285 if (level == -128) { 286 level = SHOW_UBITS(re, &s->gb, 8) - 256; 287 SKIP_BITS(re, &s->gb, 8); 288 } else if (level == 0) { 289 level = SHOW_UBITS(re, &s->gb, 8); 290 SKIP_BITS(re, &s->gb, 8); 291 } 292 i += run; 293 if (i > MAX_INDEX) 294 break; 295 j = scantable[i]; 296 if (level < 0) { 297 level = -level; 298 level = ((level * 2 + 1) * qscale) >> 1; 299 level = (level - 1) | 1; 300 level = -level; 301 } else { 302 level = ((level * 2 + 1) * qscale) >> 1; 303 level = (level - 1) | 1; 304 } 305 } 306 307 block[j] = level; 308 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF) 309 break; 310 UPDATE_CACHE(re, &s->gb); 311 } 312end: 313 LAST_SKIP_BITS(re, &s->gb, 2); 314 CLOSE_READER(re, &s->gb); 315 } 316 317 check_scantable_index(s, i); 318 319 s->block_last_index[n] = i; 320 return 0; 321} 322 323static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 324 int16_t *block, int n) 325{ 326 int level, i, j, run; 327 RLTable *rl = &ff_rl_mpeg1; 328 uint8_t *const scantable = s->intra_scantable.permutated; 329 const uint16_t *quant_matrix; 330 const int qscale = s->qscale; 331 int mismatch; 332 333 mismatch = 1; 334 335 { 336 OPEN_READER(re, &s->gb); 337 i = -1; 338 if (n < 4) 339 quant_matrix = s->inter_matrix; 340 else 341 quant_matrix = s->chroma_inter_matrix; 342 343 // Special case for first coefficient, no need to add second VLC table. 344 UPDATE_CACHE(re, &s->gb); 345 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) { 346 level = (3 * qscale * quant_matrix[0]) >> 5; 347 if (GET_CACHE(re, &s->gb) & 0x40000000) 348 level = -level; 349 block[0] = level; 350 mismatch ^= level; 351 i++; 352 SKIP_BITS(re, &s->gb, 2); 353 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF) 354 goto end; 355 } 356 357 /* now quantify & encode AC coefficients */ 358 for (;;) { 359 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], 360 TEX_VLC_BITS, 2, 0); 361 362 if (level != 0) { 363 i += run; 364 if (i > MAX_INDEX) 365 break; 366 j = scantable[i]; 367 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5; 368 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - 369 SHOW_SBITS(re, &s->gb, 1); 370 SKIP_BITS(re, &s->gb, 1); 371 } else { 372 /* escape */ 373 run = SHOW_UBITS(re, &s->gb, 6) + 1; 374 LAST_SKIP_BITS(re, &s->gb, 6); 375 UPDATE_CACHE(re, &s->gb); 376 level = SHOW_SBITS(re, &s->gb, 12); 377 SKIP_BITS(re, &s->gb, 12); 378 379 i += run; 380 if (i > MAX_INDEX) 381 break; 382 j = scantable[i]; 383 if (level < 0) { 384 level = ((-level * 2 + 1) * qscale * quant_matrix[j]) >> 5; 385 level = -level; 386 } else { 387 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5; 388 } 389 } 390 391 mismatch ^= level; 392 block[j] = level; 393 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF) 394 break; 395 UPDATE_CACHE(re, &s->gb); 396 } 397end: 398 LAST_SKIP_BITS(re, &s->gb, 2); 399 CLOSE_READER(re, &s->gb); 400 } 401 block[63] ^= (mismatch & 1); 402 403 check_scantable_index(s, i); 404 405 s->block_last_index[n] = i; 406 return 0; 407} 408 409/** 410 * Changing this would eat up any speed benefits it has. 411 * Do not use "fast" flag if you need the code to be robust. 412 */ 413static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, 414 int16_t *block, int n) 415{ 416 int level, i, j, run; 417 RLTable *rl = &ff_rl_mpeg1; 418 uint8_t *const scantable = s->intra_scantable.permutated; 419 const int qscale = s->qscale; 420 OPEN_READER(re, &s->gb); 421 i = -1; 422 423 // special case for first coefficient, no need to add second VLC table 424 UPDATE_CACHE(re, &s->gb); 425 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) { 426 level = (3 * qscale) >> 1; 427 if (GET_CACHE(re, &s->gb) & 0x40000000) 428 level = -level; 429 block[0] = level; 430 i++; 431 SKIP_BITS(re, &s->gb, 2); 432 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF) 433 goto end; 434 } 435 436 /* now quantify & encode AC coefficients */ 437 for (;;) { 438 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); 439 440 if (level != 0) { 441 i += run; 442 if (i > MAX_INDEX) 443 break; 444 j = scantable[i]; 445 level = ((level * 2 + 1) * qscale) >> 1; 446 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - 447 SHOW_SBITS(re, &s->gb, 1); 448 SKIP_BITS(re, &s->gb, 1); 449 } else { 450 /* escape */ 451 run = SHOW_UBITS(re, &s->gb, 6) + 1; 452 LAST_SKIP_BITS(re, &s->gb, 6); 453 UPDATE_CACHE(re, &s->gb); 454 level = SHOW_SBITS(re, &s->gb, 12); 455 SKIP_BITS(re, &s->gb, 12); 456 457 i += run; 458 if (i > MAX_INDEX) 459 break; 460 j = scantable[i]; 461 if (level < 0) { 462 level = ((-level * 2 + 1) * qscale) >> 1; 463 level = -level; 464 } else { 465 level = ((level * 2 + 1) * qscale) >> 1; 466 } 467 } 468 469 block[j] = level; 470 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF || i > 63) 471 break; 472 473 UPDATE_CACHE(re, &s->gb); 474 } 475end: 476 LAST_SKIP_BITS(re, &s->gb, 2); 477 CLOSE_READER(re, &s->gb); 478 479 check_scantable_index(s, i); 480 481 s->block_last_index[n] = i; 482 return 0; 483} 484 485static inline int mpeg2_decode_block_intra(MpegEncContext *s, 486 int16_t *block, int n) 487{ 488 int level, dc, diff, i, j, run; 489 int component; 490 RLTable *rl; 491 uint8_t *const scantable = s->intra_scantable.permutated; 492 const uint16_t *quant_matrix; 493 const int qscale = s->qscale; 494 int mismatch; 495 496 /* DC coefficient */ 497 if (n < 4) { 498 quant_matrix = s->intra_matrix; 499 component = 0; 500 } else { 501 quant_matrix = s->chroma_intra_matrix; 502 component = (n & 1) + 1; 503 } 504 diff = decode_dc(&s->gb, component); 505 dc = s->last_dc[component]; 506 dc += diff; 507 s->last_dc[component] = dc; 508 block[0] = dc * (1 << (3 - s->intra_dc_precision)); 509 ff_tlog(s->avctx, "dc=%d\n", block[0]); 510 mismatch = block[0] ^ 1; 511 i = 0; 512 if (s->intra_vlc_format) 513 rl = &ff_rl_mpeg2; 514 else 515 rl = &ff_rl_mpeg1; 516 517 { 518 OPEN_READER(re, &s->gb); 519 /* now quantify & encode AC coefficients */ 520 for (;;) { 521 UPDATE_CACHE(re, &s->gb); 522 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], 523 TEX_VLC_BITS, 2, 0); 524 525 if (level == 127) { 526 break; 527 } else if (level != 0) { 528 i += run; 529 if (i > MAX_INDEX) 530 break; 531 j = scantable[i]; 532 level = (level * qscale * quant_matrix[j]) >> 4; 533 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - 534 SHOW_SBITS(re, &s->gb, 1); 535 LAST_SKIP_BITS(re, &s->gb, 1); 536 } else { 537 /* escape */ 538 run = SHOW_UBITS(re, &s->gb, 6) + 1; 539 SKIP_BITS(re, &s->gb, 6); 540 level = SHOW_SBITS(re, &s->gb, 12); 541 LAST_SKIP_BITS(re, &s->gb, 12); 542 i += run; 543 if (i > MAX_INDEX) 544 break; 545 j = scantable[i]; 546 if (level < 0) { 547 level = (-level * qscale * quant_matrix[j]) >> 4; 548 level = -level; 549 } else { 550 level = (level * qscale * quant_matrix[j]) >> 4; 551 } 552 } 553 554 mismatch ^= level; 555 block[j] = level; 556 } 557 CLOSE_READER(re, &s->gb); 558 } 559 block[63] ^= mismatch & 1; 560 561 check_scantable_index(s, i); 562 563 s->block_last_index[n] = i; 564 return 0; 565} 566 567/** 568 * Changing this would eat up any speed benefits it has. 569 * Do not use "fast" flag if you need the code to be robust. 570 */ 571static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, 572 int16_t *block, int n) 573{ 574 int level, dc, diff, i, j, run; 575 int component; 576 RLTable *rl; 577 uint8_t *const scantable = s->intra_scantable.permutated; 578 const uint16_t *quant_matrix; 579 const int qscale = s->qscale; 580 581 /* DC coefficient */ 582 if (n < 4) { 583 quant_matrix = s->intra_matrix; 584 component = 0; 585 } else { 586 quant_matrix = s->chroma_intra_matrix; 587 component = (n & 1) + 1; 588 } 589 diff = decode_dc(&s->gb, component); 590 dc = s->last_dc[component]; 591 dc += diff; 592 s->last_dc[component] = dc; 593 block[0] = dc * (1 << (3 - s->intra_dc_precision)); 594 i = 0; 595 if (s->intra_vlc_format) 596 rl = &ff_rl_mpeg2; 597 else 598 rl = &ff_rl_mpeg1; 599 600 { 601 OPEN_READER(re, &s->gb); 602 /* now quantify & encode AC coefficients */ 603 for (;;) { 604 UPDATE_CACHE(re, &s->gb); 605 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], 606 TEX_VLC_BITS, 2, 0); 607 608 if (level >= 64 || i > 63) { 609 break; 610 } else if (level != 0) { 611 i += run; 612 j = scantable[i]; 613 level = (level * qscale * quant_matrix[j]) >> 4; 614 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - 615 SHOW_SBITS(re, &s->gb, 1); 616 LAST_SKIP_BITS(re, &s->gb, 1); 617 } else { 618 /* escape */ 619 run = SHOW_UBITS(re, &s->gb, 6) + 1; 620 SKIP_BITS(re, &s->gb, 6); 621 level = SHOW_SBITS(re, &s->gb, 12); 622 LAST_SKIP_BITS(re, &s->gb, 12); 623 i += run; 624 j = scantable[i]; 625 if (level < 0) { 626 level = (-level * qscale * quant_matrix[j]) >> 4; 627 level = -level; 628 } else { 629 level = (level * qscale * quant_matrix[j]) >> 4; 630 } 631 } 632 633 block[j] = level; 634 } 635 CLOSE_READER(re, &s->gb); 636 } 637 638 check_scantable_index(s, i); 639 640 s->block_last_index[n] = i; 641 return 0; 642} 643 644/******************************************/ 645/* decoding */ 646 647static inline int get_dmv(MpegEncContext *s) 648{ 649 if (get_bits1(&s->gb)) 650 return 1 - (get_bits1(&s->gb) << 1); 651 else 652 return 0; 653} 654 655/* motion type (for MPEG-2) */ 656#define MT_FIELD 1 657#define MT_FRAME 2 658#define MT_16X8 2 659#define MT_DMV 3 660 661static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64]) 662{ 663 int i, j, k, cbp, val, mb_type, motion_type; 664 const int mb_block_count = 4 + (1 << s->chroma_format); 665 int ret; 666 667 ff_tlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y); 668 669 av_assert2(s->mb_skipped == 0); 670 671 if (s->mb_skip_run-- != 0) { 672 if (s->pict_type == AV_PICTURE_TYPE_P) { 673 s->mb_skipped = 1; 674 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = 675 MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16; 676 } else { 677 int mb_type; 678 679 if (s->mb_x) 680 mb_type = s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1]; 681 else 682 // FIXME not sure if this is allowed in MPEG at all 683 mb_type = s->current_picture.mb_type[s->mb_width + (s->mb_y - 1) * s->mb_stride - 1]; 684 if (IS_INTRA(mb_type)) { 685 av_log(s->avctx, AV_LOG_ERROR, "skip with previntra\n"); 686 return AVERROR_INVALIDDATA; 687 } 688 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = 689 mb_type | MB_TYPE_SKIP; 690 691 if ((s->mv[0][0][0] | s->mv[0][0][1] | s->mv[1][0][0] | s->mv[1][0][1]) == 0) 692 s->mb_skipped = 1; 693 } 694 695 return 0; 696 } 697 698 switch (s->pict_type) { 699 default: 700 case AV_PICTURE_TYPE_I: 701 if (get_bits1(&s->gb) == 0) { 702 if (get_bits1(&s->gb) == 0) { 703 av_log(s->avctx, AV_LOG_ERROR, 704 "Invalid mb type in I-frame at %d %d\n", 705 s->mb_x, s->mb_y); 706 return AVERROR_INVALIDDATA; 707 } 708 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA; 709 } else { 710 mb_type = MB_TYPE_INTRA; 711 } 712 break; 713 case AV_PICTURE_TYPE_P: 714 mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1); 715 if (mb_type < 0) { 716 av_log(s->avctx, AV_LOG_ERROR, 717 "Invalid mb type in P-frame at %d %d\n", s->mb_x, s->mb_y); 718 return AVERROR_INVALIDDATA; 719 } 720 mb_type = ptype2mb_type[mb_type]; 721 break; 722 case AV_PICTURE_TYPE_B: 723 mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1); 724 if (mb_type < 0) { 725 av_log(s->avctx, AV_LOG_ERROR, 726 "Invalid mb type in B-frame at %d %d\n", s->mb_x, s->mb_y); 727 return AVERROR_INVALIDDATA; 728 } 729 mb_type = btype2mb_type[mb_type]; 730 break; 731 } 732 ff_tlog(s->avctx, "mb_type=%x\n", mb_type); 733// motion_type = 0; /* avoid warning */ 734 if (IS_INTRA(mb_type)) { 735 s->bdsp.clear_blocks(s->block[0]); 736 737 if (!s->chroma_y_shift) 738 s->bdsp.clear_blocks(s->block[6]); 739 740 /* compute DCT type */ 741 // FIXME: add an interlaced_dct coded var? 742 if (s->picture_structure == PICT_FRAME && 743 !s->frame_pred_frame_dct) 744 s->interlaced_dct = get_bits1(&s->gb); 745 746 if (IS_QUANT(mb_type)) 747 s->qscale = mpeg_get_qscale(s); 748 749 if (s->concealment_motion_vectors) { 750 /* just parse them */ 751 if (s->picture_structure != PICT_FRAME) 752 skip_bits1(&s->gb); /* field select */ 753 754 s->mv[0][0][0] = 755 s->last_mv[0][0][0] = 756 s->last_mv[0][1][0] = mpeg_decode_motion(s, s->mpeg_f_code[0][0], 757 s->last_mv[0][0][0]); 758 s->mv[0][0][1] = 759 s->last_mv[0][0][1] = 760 s->last_mv[0][1][1] = mpeg_decode_motion(s, s->mpeg_f_code[0][1], 761 s->last_mv[0][0][1]); 762 763 check_marker(s->avctx, &s->gb, "after concealment_motion_vectors"); 764 } else { 765 /* reset mv prediction */ 766 memset(s->last_mv, 0, sizeof(s->last_mv)); 767 } 768 s->mb_intra = 1; 769 770 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) { 771 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) { 772 for (i = 0; i < 6; i++) 773 mpeg2_fast_decode_block_intra(s, *s->pblocks[i], i); 774 } else { 775 for (i = 0; i < mb_block_count; i++) 776 if ((ret = mpeg2_decode_block_intra(s, *s->pblocks[i], i)) < 0) 777 return ret; 778 } 779 } else { 780 for (i = 0; i < 6; i++) { 781 ret = ff_mpeg1_decode_block_intra(&s->gb, 782 s->intra_matrix, 783 s->intra_scantable.permutated, 784 s->last_dc, *s->pblocks[i], 785 i, s->qscale); 786 if (ret < 0) { 787 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", 788 s->mb_x, s->mb_y); 789 return ret; 790 } 791 792 s->block_last_index[i] = ret; 793 } 794 } 795 } else { 796 if (mb_type & MB_TYPE_ZERO_MV) { 797 av_assert2(mb_type & MB_TYPE_CBP); 798 799 s->mv_dir = MV_DIR_FORWARD; 800 if (s->picture_structure == PICT_FRAME) { 801 if (s->picture_structure == PICT_FRAME 802 && !s->frame_pred_frame_dct) 803 s->interlaced_dct = get_bits1(&s->gb); 804 s->mv_type = MV_TYPE_16X16; 805 } else { 806 s->mv_type = MV_TYPE_FIELD; 807 mb_type |= MB_TYPE_INTERLACED; 808 s->field_select[0][0] = s->picture_structure - 1; 809 } 810 811 if (IS_QUANT(mb_type)) 812 s->qscale = mpeg_get_qscale(s); 813 814 s->last_mv[0][0][0] = 0; 815 s->last_mv[0][0][1] = 0; 816 s->last_mv[0][1][0] = 0; 817 s->last_mv[0][1][1] = 0; 818 s->mv[0][0][0] = 0; 819 s->mv[0][0][1] = 0; 820 } else { 821 av_assert2(mb_type & MB_TYPE_L0L1); 822 // FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED 823 /* get additional motion vector type */ 824 if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) { 825 motion_type = MT_FRAME; 826 } else { 827 motion_type = get_bits(&s->gb, 2); 828 if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type)) 829 s->interlaced_dct = get_bits1(&s->gb); 830 } 831 832 if (IS_QUANT(mb_type)) 833 s->qscale = mpeg_get_qscale(s); 834 835 /* motion vectors */ 836 s->mv_dir = (mb_type >> 13) & 3; 837 ff_tlog(s->avctx, "motion_type=%d\n", motion_type); 838 switch (motion_type) { 839 case MT_FRAME: /* or MT_16X8 */ 840 if (s->picture_structure == PICT_FRAME) { 841 mb_type |= MB_TYPE_16x16; 842 s->mv_type = MV_TYPE_16X16; 843 for (i = 0; i < 2; i++) { 844 if (USES_LIST(mb_type, i)) { 845 /* MT_FRAME */ 846 s->mv[i][0][0] = 847 s->last_mv[i][0][0] = 848 s->last_mv[i][1][0] = 849 mpeg_decode_motion(s, s->mpeg_f_code[i][0], 850 s->last_mv[i][0][0]); 851 s->mv[i][0][1] = 852 s->last_mv[i][0][1] = 853 s->last_mv[i][1][1] = 854 mpeg_decode_motion(s, s->mpeg_f_code[i][1], 855 s->last_mv[i][0][1]); 856 /* full_pel: only for MPEG-1 */ 857 if (s->full_pel[i]) { 858 s->mv[i][0][0] *= 2; 859 s->mv[i][0][1] *= 2; 860 } 861 } 862 } 863 } else { 864 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; 865 s->mv_type = MV_TYPE_16X8; 866 for (i = 0; i < 2; i++) { 867 if (USES_LIST(mb_type, i)) { 868 /* MT_16X8 */ 869 for (j = 0; j < 2; j++) { 870 s->field_select[i][j] = get_bits1(&s->gb); 871 for (k = 0; k < 2; k++) { 872 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], 873 s->last_mv[i][j][k]); 874 s->last_mv[i][j][k] = val; 875 s->mv[i][j][k] = val; 876 } 877 } 878 } 879 } 880 } 881 break; 882 case MT_FIELD: 883 s->mv_type = MV_TYPE_FIELD; 884 if (s->picture_structure == PICT_FRAME) { 885 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; 886 for (i = 0; i < 2; i++) { 887 if (USES_LIST(mb_type, i)) { 888 for (j = 0; j < 2; j++) { 889 s->field_select[i][j] = get_bits1(&s->gb); 890 val = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 891 s->last_mv[i][j][0]); 892 s->last_mv[i][j][0] = val; 893 s->mv[i][j][0] = val; 894 ff_tlog(s->avctx, "fmx=%d\n", val); 895 val = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 896 s->last_mv[i][j][1] >> 1); 897 s->last_mv[i][j][1] = 2 * val; 898 s->mv[i][j][1] = val; 899 ff_tlog(s->avctx, "fmy=%d\n", val); 900 } 901 } 902 } 903 } else { 904 av_assert0(!s->progressive_sequence); 905 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED; 906 for (i = 0; i < 2; i++) { 907 if (USES_LIST(mb_type, i)) { 908 s->field_select[i][0] = get_bits1(&s->gb); 909 for (k = 0; k < 2; k++) { 910 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], 911 s->last_mv[i][0][k]); 912 s->last_mv[i][0][k] = val; 913 s->last_mv[i][1][k] = val; 914 s->mv[i][0][k] = val; 915 } 916 } 917 } 918 } 919 break; 920 case MT_DMV: 921 if (s->progressive_sequence){ 922 av_log(s->avctx, AV_LOG_ERROR, "MT_DMV in progressive_sequence\n"); 923 return AVERROR_INVALIDDATA; 924 } 925 s->mv_type = MV_TYPE_DMV; 926 for (i = 0; i < 2; i++) { 927 if (USES_LIST(mb_type, i)) { 928 int dmx, dmy, mx, my, m; 929 const int my_shift = s->picture_structure == PICT_FRAME; 930 931 mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 932 s->last_mv[i][0][0]); 933 s->last_mv[i][0][0] = mx; 934 s->last_mv[i][1][0] = mx; 935 dmx = get_dmv(s); 936 my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 937 s->last_mv[i][0][1] >> my_shift); 938 dmy = get_dmv(s); 939 940 941 s->last_mv[i][0][1] = my * (1 << my_shift); 942 s->last_mv[i][1][1] = my * (1 << my_shift); 943 944 s->mv[i][0][0] = mx; 945 s->mv[i][0][1] = my; 946 s->mv[i][1][0] = mx; // not used 947 s->mv[i][1][1] = my; // not used 948 949 if (s->picture_structure == PICT_FRAME) { 950 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED; 951 952 // m = 1 + 2 * s->top_field_first; 953 m = s->top_field_first ? 1 : 3; 954 955 /* top -> top pred */ 956 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx; 957 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1; 958 m = 4 - m; 959 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx; 960 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1; 961 } else { 962 mb_type |= MB_TYPE_16x16; 963 964 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx; 965 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy; 966 if (s->picture_structure == PICT_TOP_FIELD) 967 s->mv[i][2][1]--; 968 else 969 s->mv[i][2][1]++; 970 } 971 } 972 } 973 break; 974 default: 975 av_log(s->avctx, AV_LOG_ERROR, 976 "00 motion_type at %d %d\n", s->mb_x, s->mb_y); 977 return AVERROR_INVALIDDATA; 978 } 979 } 980 981 s->mb_intra = 0; 982 if (HAS_CBP(mb_type)) { 983 s->bdsp.clear_blocks(s->block[0]); 984 985 cbp = get_vlc2(&s->gb, ff_mb_pat_vlc.table, MB_PAT_VLC_BITS, 1); 986 if (mb_block_count > 6) { 987 cbp *= 1 << mb_block_count - 6; 988 cbp |= get_bits(&s->gb, mb_block_count - 6); 989 s->bdsp.clear_blocks(s->block[6]); 990 } 991 if (cbp <= 0) { 992 av_log(s->avctx, AV_LOG_ERROR, 993 "invalid cbp %d at %d %d\n", cbp, s->mb_x, s->mb_y); 994 return AVERROR_INVALIDDATA; 995 } 996 997 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) { 998 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) { 999 for (i = 0; i < 6; i++) { 1000 if (cbp & 32) 1001 mpeg2_fast_decode_block_non_intra(s, *s->pblocks[i], i); 1002 else 1003 s->block_last_index[i] = -1; 1004 cbp += cbp; 1005 } 1006 } else { 1007 cbp <<= 12 - mb_block_count; 1008 1009 for (i = 0; i < mb_block_count; i++) { 1010 if (cbp & (1 << 11)) { 1011 if ((ret = mpeg2_decode_block_non_intra(s, *s->pblocks[i], i)) < 0) 1012 return ret; 1013 } else { 1014 s->block_last_index[i] = -1; 1015 } 1016 cbp += cbp; 1017 } 1018 } 1019 } else { 1020 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) { 1021 for (i = 0; i < 6; i++) { 1022 if (cbp & 32) 1023 mpeg1_fast_decode_block_inter(s, *s->pblocks[i], i); 1024 else 1025 s->block_last_index[i] = -1; 1026 cbp += cbp; 1027 } 1028 } else { 1029 for (i = 0; i < 6; i++) { 1030 if (cbp & 32) { 1031 if ((ret = mpeg1_decode_block_inter(s, *s->pblocks[i], i)) < 0) 1032 return ret; 1033 } else { 1034 s->block_last_index[i] = -1; 1035 } 1036 cbp += cbp; 1037 } 1038 } 1039 } 1040 } else { 1041 for (i = 0; i < 12; i++) 1042 s->block_last_index[i] = -1; 1043 } 1044 } 1045 1046 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type; 1047 1048 return 0; 1049} 1050 1051static av_cold int mpeg_decode_init(AVCodecContext *avctx) 1052{ 1053 Mpeg1Context *s = avctx->priv_data; 1054 MpegEncContext *s2 = &s->mpeg_enc_ctx; 1055 1056 if ( avctx->codec_tag != AV_RL32("VCR2") 1057 && avctx->codec_tag != AV_RL32("BW10")) 1058 avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input 1059 ff_mpv_decode_init(s2, avctx); 1060 1061 /* we need some permutation to store matrices, 1062 * until the decoder sets the real permutation. */ 1063 ff_mpv_idct_init(s2); 1064 ff_mpeg12_common_init(&s->mpeg_enc_ctx); 1065 ff_mpeg12_init_vlcs(); 1066 1067 s2->chroma_format = 1; 1068 s->mpeg_enc_ctx_allocated = 0; 1069 s->repeat_field = 0; 1070 avctx->color_range = AVCOL_RANGE_MPEG; 1071 return 0; 1072} 1073 1074#if HAVE_THREADS 1075static int mpeg_decode_update_thread_context(AVCodecContext *avctx, 1076 const AVCodecContext *avctx_from) 1077{ 1078 Mpeg1Context *ctx = avctx->priv_data, *ctx_from = avctx_from->priv_data; 1079 MpegEncContext *s = &ctx->mpeg_enc_ctx, *s1 = &ctx_from->mpeg_enc_ctx; 1080 int err; 1081 1082 if (avctx == avctx_from || 1083 !ctx_from->mpeg_enc_ctx_allocated || 1084 !s1->context_initialized) 1085 return 0; 1086 1087 err = ff_mpeg_update_thread_context(avctx, avctx_from); 1088 if (err) 1089 return err; 1090 1091 if (!ctx->mpeg_enc_ctx_allocated) 1092 memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MpegEncContext)); 1093 1094 return 0; 1095} 1096#endif 1097 1098static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm, 1099 const uint8_t *new_perm) 1100{ 1101 uint16_t temp_matrix[64]; 1102 int i; 1103 1104 memcpy(temp_matrix, matrix, 64 * sizeof(uint16_t)); 1105 1106 for (i = 0; i < 64; i++) 1107 matrix[new_perm[i]] = temp_matrix[old_perm[i]]; 1108} 1109 1110static const enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[] = { 1111#if CONFIG_MPEG1_NVDEC_HWACCEL 1112 AV_PIX_FMT_CUDA, 1113#endif 1114#if CONFIG_MPEG1_VDPAU_HWACCEL 1115 AV_PIX_FMT_VDPAU, 1116#endif 1117 AV_PIX_FMT_YUV420P, 1118 AV_PIX_FMT_NONE 1119}; 1120 1121static const enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[] = { 1122#if CONFIG_MPEG2_NVDEC_HWACCEL 1123 AV_PIX_FMT_CUDA, 1124#endif 1125#if CONFIG_MPEG2_VDPAU_HWACCEL 1126 AV_PIX_FMT_VDPAU, 1127#endif 1128#if CONFIG_MPEG2_DXVA2_HWACCEL 1129 AV_PIX_FMT_DXVA2_VLD, 1130#endif 1131#if CONFIG_MPEG2_D3D11VA_HWACCEL 1132 AV_PIX_FMT_D3D11VA_VLD, 1133 AV_PIX_FMT_D3D11, 1134#endif 1135#if CONFIG_MPEG2_VAAPI_HWACCEL 1136 AV_PIX_FMT_VAAPI, 1137#endif 1138#if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL 1139 AV_PIX_FMT_VIDEOTOOLBOX, 1140#endif 1141 AV_PIX_FMT_YUV420P, 1142 AV_PIX_FMT_NONE 1143}; 1144 1145static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = { 1146 AV_PIX_FMT_YUV422P, 1147 AV_PIX_FMT_NONE 1148}; 1149 1150static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = { 1151 AV_PIX_FMT_YUV444P, 1152 AV_PIX_FMT_NONE 1153}; 1154 1155static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx) 1156{ 1157 Mpeg1Context *s1 = avctx->priv_data; 1158 MpegEncContext *s = &s1->mpeg_enc_ctx; 1159 const enum AVPixelFormat *pix_fmts; 1160 1161 if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY)) 1162 return AV_PIX_FMT_GRAY8; 1163 1164 if (s->chroma_format < 2) 1165 pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ? 1166 mpeg1_hwaccel_pixfmt_list_420 : 1167 mpeg2_hwaccel_pixfmt_list_420; 1168 else if (s->chroma_format == 2) 1169 pix_fmts = mpeg12_pixfmt_list_422; 1170 else 1171 pix_fmts = mpeg12_pixfmt_list_444; 1172 1173 return ff_thread_get_format(avctx, pix_fmts); 1174} 1175 1176/* Call this function when we know all parameters. 1177 * It may be called in different places for MPEG-1 and MPEG-2. */ 1178static int mpeg_decode_postinit(AVCodecContext *avctx) 1179{ 1180 Mpeg1Context *s1 = avctx->priv_data; 1181 MpegEncContext *s = &s1->mpeg_enc_ctx; 1182 uint8_t old_permutation[64]; 1183 int ret; 1184 1185 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) { 1186 // MPEG-1 aspect 1187 AVRational aspect_inv = av_d2q(ff_mpeg1_aspect[s1->aspect_ratio_info], 255); 1188 avctx->sample_aspect_ratio = (AVRational) { aspect_inv.den, aspect_inv.num }; 1189 } else { // MPEG-2 1190 // MPEG-2 aspect 1191 if (s1->aspect_ratio_info > 1) { 1192 AVRational dar = 1193 av_mul_q(av_div_q(ff_mpeg2_aspect[s1->aspect_ratio_info], 1194 (AVRational) { s1->pan_scan.width, 1195 s1->pan_scan.height }), 1196 (AVRational) { s->width, s->height }); 1197 1198 /* We ignore the spec here and guess a bit as reality does not 1199 * match the spec, see for example res_change_ffmpeg_aspect.ts 1200 * and sequence-display-aspect.mpg. 1201 * issue1613, 621, 562 */ 1202 if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) || 1203 (av_cmp_q(dar, (AVRational) { 4, 3 }) && 1204 av_cmp_q(dar, (AVRational) { 16, 9 }))) { 1205 s->avctx->sample_aspect_ratio = 1206 av_div_q(ff_mpeg2_aspect[s1->aspect_ratio_info], 1207 (AVRational) { s->width, s->height }); 1208 } else { 1209 s->avctx->sample_aspect_ratio = 1210 av_div_q(ff_mpeg2_aspect[s1->aspect_ratio_info], 1211 (AVRational) { s1->pan_scan.width, s1->pan_scan.height }); 1212// issue1613 4/3 16/9 -> 16/9 1213// res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3 1214// widescreen-issue562.mpg 4/3 16/9 -> 16/9 1215// s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height}); 1216 ff_dlog(avctx, "aspect A %d/%d\n", 1217 ff_mpeg2_aspect[s1->aspect_ratio_info].num, 1218 ff_mpeg2_aspect[s1->aspect_ratio_info].den); 1219 ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num, 1220 s->avctx->sample_aspect_ratio.den); 1221 } 1222 } else { 1223 s->avctx->sample_aspect_ratio = 1224 ff_mpeg2_aspect[s1->aspect_ratio_info]; 1225 } 1226 } // MPEG-2 1227 1228 if (av_image_check_sar(s->width, s->height, 1229 avctx->sample_aspect_ratio) < 0) { 1230 av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n", 1231 avctx->sample_aspect_ratio.num, 1232 avctx->sample_aspect_ratio.den); 1233 avctx->sample_aspect_ratio = (AVRational){ 0, 1 }; 1234 } 1235 1236 if ((s1->mpeg_enc_ctx_allocated == 0) || 1237 avctx->coded_width != s->width || 1238 avctx->coded_height != s->height || 1239 s1->save_width != s->width || 1240 s1->save_height != s->height || 1241 av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) || 1242 (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) || 1243 0) { 1244 if (s1->mpeg_enc_ctx_allocated) { 1245#if FF_API_FLAG_TRUNCATED 1246 ParseContext pc = s->parse_context; 1247 s->parse_context.buffer = 0; 1248 ff_mpv_common_end(s); 1249 s->parse_context = pc; 1250#else 1251 ff_mpv_common_end(s); 1252#endif 1253 s1->mpeg_enc_ctx_allocated = 0; 1254 } 1255 1256 ret = ff_set_dimensions(avctx, s->width, s->height); 1257 if (ret < 0) 1258 return ret; 1259 1260 if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) { 1261 avctx->rc_max_rate = s->bit_rate; 1262 } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate && 1263 (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) { 1264 avctx->bit_rate = s->bit_rate; 1265 } 1266 s1->save_aspect = s->avctx->sample_aspect_ratio; 1267 s1->save_width = s->width; 1268 s1->save_height = s->height; 1269 s1->save_progressive_seq = s->progressive_sequence; 1270 1271 /* low_delay may be forced, in this case we will have B-frames 1272 * that behave like P-frames. */ 1273 avctx->has_b_frames = !s->low_delay; 1274 1275 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) { 1276 // MPEG-1 fps 1277 avctx->framerate = ff_mpeg12_frame_rate_tab[s1->frame_rate_index]; 1278 avctx->ticks_per_frame = 1; 1279 1280 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER; 1281 } else { // MPEG-2 1282 // MPEG-2 fps 1283 av_reduce(&s->avctx->framerate.num, 1284 &s->avctx->framerate.den, 1285 ff_mpeg12_frame_rate_tab[s1->frame_rate_index].num * s1->frame_rate_ext.num, 1286 ff_mpeg12_frame_rate_tab[s1->frame_rate_index].den * s1->frame_rate_ext.den, 1287 1 << 30); 1288 avctx->ticks_per_frame = 2; 1289 1290 switch (s->chroma_format) { 1291 case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break; 1292 case 2: 1293 case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break; 1294 default: av_assert0(0); 1295 } 1296 } // MPEG-2 1297 1298 avctx->pix_fmt = mpeg_get_pixelformat(avctx); 1299 1300 /* Quantization matrices may need reordering 1301 * if DCT permutation is changed. */ 1302 memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t)); 1303 1304 ff_mpv_idct_init(s); 1305 if ((ret = ff_mpv_common_init(s)) < 0) 1306 return ret; 1307 1308 quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation); 1309 quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation); 1310 quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation); 1311 quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation); 1312 1313 s1->mpeg_enc_ctx_allocated = 1; 1314 } 1315 return 0; 1316} 1317 1318static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf, 1319 int buf_size) 1320{ 1321 Mpeg1Context *s1 = avctx->priv_data; 1322 MpegEncContext *s = &s1->mpeg_enc_ctx; 1323 int ref, f_code, vbv_delay, ret; 1324 1325 ret = init_get_bits8(&s->gb, buf, buf_size); 1326 if (ret < 0) 1327 return ret; 1328 1329 ref = get_bits(&s->gb, 10); /* temporal ref */ 1330 s->pict_type = get_bits(&s->gb, 3); 1331 if (s->pict_type == 0 || s->pict_type > 3) 1332 return AVERROR_INVALIDDATA; 1333 1334 vbv_delay = get_bits(&s->gb, 16); 1335 s->vbv_delay = vbv_delay; 1336 if (s->pict_type == AV_PICTURE_TYPE_P || 1337 s->pict_type == AV_PICTURE_TYPE_B) { 1338 s->full_pel[0] = get_bits1(&s->gb); 1339 f_code = get_bits(&s->gb, 3); 1340 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) 1341 return AVERROR_INVALIDDATA; 1342 f_code += !f_code; 1343 s->mpeg_f_code[0][0] = f_code; 1344 s->mpeg_f_code[0][1] = f_code; 1345 } 1346 if (s->pict_type == AV_PICTURE_TYPE_B) { 1347 s->full_pel[1] = get_bits1(&s->gb); 1348 f_code = get_bits(&s->gb, 3); 1349 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) 1350 return AVERROR_INVALIDDATA; 1351 f_code += !f_code; 1352 s->mpeg_f_code[1][0] = f_code; 1353 s->mpeg_f_code[1][1] = f_code; 1354 } 1355 s->current_picture.f->pict_type = s->pict_type; 1356 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; 1357 1358 if (avctx->debug & FF_DEBUG_PICT_INFO) 1359 av_log(avctx, AV_LOG_DEBUG, 1360 "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type); 1361 1362 s->y_dc_scale = 8; 1363 s->c_dc_scale = 8; 1364 return 0; 1365} 1366 1367static void mpeg_decode_sequence_extension(Mpeg1Context *s1) 1368{ 1369 MpegEncContext *s = &s1->mpeg_enc_ctx; 1370 int horiz_size_ext, vert_size_ext; 1371 int bit_rate_ext; 1372 AVCPBProperties *cpb_props; 1373 1374 skip_bits(&s->gb, 1); /* profile and level esc*/ 1375 s->avctx->profile = get_bits(&s->gb, 3); 1376 s->avctx->level = get_bits(&s->gb, 4); 1377 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */ 1378 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */ 1379 1380 if (!s->chroma_format) { 1381 s->chroma_format = 1; 1382 av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n"); 1383 } 1384 1385 horiz_size_ext = get_bits(&s->gb, 2); 1386 vert_size_ext = get_bits(&s->gb, 2); 1387 s->width |= (horiz_size_ext << 12); 1388 s->height |= (vert_size_ext << 12); 1389 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */ 1390 s->bit_rate += (bit_rate_ext << 18) * 400LL; 1391 check_marker(s->avctx, &s->gb, "after bit rate extension"); 1392 s1->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10; 1393 1394 s->low_delay = get_bits1(&s->gb); 1395 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) 1396 s->low_delay = 1; 1397 1398 s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1; 1399 s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1; 1400 1401 ff_dlog(s->avctx, "sequence extension\n"); 1402 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO; 1403 1404 if (cpb_props = ff_add_cpb_side_data(s->avctx)) { 1405 cpb_props->buffer_size = s1->rc_buffer_size; 1406 if (s->bit_rate != 0x3FFFF*400) 1407 cpb_props->max_bitrate = s->bit_rate; 1408 } 1409 1410 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 1411 av_log(s->avctx, AV_LOG_DEBUG, 1412 "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%"PRId64"\n", 1413 s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format, 1414 s1->rc_buffer_size, s->bit_rate); 1415} 1416 1417static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1) 1418{ 1419 MpegEncContext *s = &s1->mpeg_enc_ctx; 1420 int color_description, w, h; 1421 1422 skip_bits(&s->gb, 3); /* video format */ 1423 color_description = get_bits1(&s->gb); 1424 if (color_description) { 1425 s->avctx->color_primaries = get_bits(&s->gb, 8); 1426 s->avctx->color_trc = get_bits(&s->gb, 8); 1427 s->avctx->colorspace = get_bits(&s->gb, 8); 1428 } 1429 w = get_bits(&s->gb, 14); 1430 skip_bits(&s->gb, 1); // marker 1431 h = get_bits(&s->gb, 14); 1432 // remaining 3 bits are zero padding 1433 1434 s1->pan_scan.width = 16 * w; 1435 s1->pan_scan.height = 16 * h; 1436 1437 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 1438 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h); 1439} 1440 1441static void mpeg_decode_picture_display_extension(Mpeg1Context *s1) 1442{ 1443 MpegEncContext *s = &s1->mpeg_enc_ctx; 1444 int i, nofco; 1445 1446 nofco = 1; 1447 if (s->progressive_sequence) { 1448 if (s->repeat_first_field) { 1449 nofco++; 1450 if (s->top_field_first) 1451 nofco++; 1452 } 1453 } else { 1454 if (s->picture_structure == PICT_FRAME) { 1455 nofco++; 1456 if (s->repeat_first_field) 1457 nofco++; 1458 } 1459 } 1460 for (i = 0; i < nofco; i++) { 1461 s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16); 1462 skip_bits(&s->gb, 1); // marker 1463 s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16); 1464 skip_bits(&s->gb, 1); // marker 1465 } 1466 1467 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 1468 av_log(s->avctx, AV_LOG_DEBUG, 1469 "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n", 1470 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1], 1471 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1], 1472 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]); 1473} 1474 1475static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], 1476 uint16_t matrix1[64], int intra) 1477{ 1478 int i; 1479 1480 for (i = 0; i < 64; i++) { 1481 int j = s->idsp.idct_permutation[ff_zigzag_direct[i]]; 1482 int v = get_bits(&s->gb, 8); 1483 if (v == 0) { 1484 av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n"); 1485 return AVERROR_INVALIDDATA; 1486 } 1487 if (intra && i == 0 && v != 8) { 1488 av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v); 1489 v = 8; // needed by pink.mpg / issue1046 1490 } 1491 matrix0[j] = v; 1492 if (matrix1) 1493 matrix1[j] = v; 1494 } 1495 return 0; 1496} 1497 1498static void mpeg_decode_quant_matrix_extension(MpegEncContext *s) 1499{ 1500 ff_dlog(s->avctx, "matrix extension\n"); 1501 1502 if (get_bits1(&s->gb)) 1503 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1); 1504 if (get_bits1(&s->gb)) 1505 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0); 1506 if (get_bits1(&s->gb)) 1507 load_matrix(s, s->chroma_intra_matrix, NULL, 1); 1508 if (get_bits1(&s->gb)) 1509 load_matrix(s, s->chroma_inter_matrix, NULL, 0); 1510} 1511 1512static int mpeg_decode_picture_coding_extension(Mpeg1Context *s1) 1513{ 1514 MpegEncContext *s = &s1->mpeg_enc_ctx; 1515 1516 s->full_pel[0] = s->full_pel[1] = 0; 1517 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4); 1518 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4); 1519 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4); 1520 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4); 1521 s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0]; 1522 s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1]; 1523 s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0]; 1524 s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1]; 1525 if (!s->pict_type && s1->mpeg_enc_ctx_allocated) { 1526 av_log(s->avctx, AV_LOG_ERROR, "Missing picture start code\n"); 1527 if (s->avctx->err_recognition & AV_EF_EXPLODE) 1528 return AVERROR_INVALIDDATA; 1529 av_log(s->avctx, AV_LOG_WARNING, "Guessing pict_type from mpeg_f_code\n"); 1530 if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) { 1531 if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15) 1532 s->pict_type = AV_PICTURE_TYPE_I; 1533 else 1534 s->pict_type = AV_PICTURE_TYPE_P; 1535 } else 1536 s->pict_type = AV_PICTURE_TYPE_B; 1537 s->current_picture.f->pict_type = s->pict_type; 1538 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; 1539 } 1540 1541 s->intra_dc_precision = get_bits(&s->gb, 2); 1542 s->picture_structure = get_bits(&s->gb, 2); 1543 s->top_field_first = get_bits1(&s->gb); 1544 s->frame_pred_frame_dct = get_bits1(&s->gb); 1545 s->concealment_motion_vectors = get_bits1(&s->gb); 1546 s->q_scale_type = get_bits1(&s->gb); 1547 s->intra_vlc_format = get_bits1(&s->gb); 1548 s->alternate_scan = get_bits1(&s->gb); 1549 s->repeat_first_field = get_bits1(&s->gb); 1550 s->chroma_420_type = get_bits1(&s->gb); 1551 s->progressive_frame = get_bits1(&s->gb); 1552 1553 if (s->alternate_scan) { 1554 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan); 1555 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan); 1556 } else { 1557 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct); 1558 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct); 1559 } 1560 1561 /* composite display not parsed */ 1562 ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision); 1563 ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure); 1564 ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first); 1565 ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field); 1566 ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors); 1567 ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format); 1568 ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan); 1569 ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct); 1570 ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame); 1571 1572 return 0; 1573} 1574 1575static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size) 1576{ 1577 AVCodecContext *avctx = s->avctx; 1578 Mpeg1Context *s1 = (Mpeg1Context *) s; 1579 int ret; 1580 1581 if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) { 1582 if (s->mb_width * s->mb_height * 11LL / (33 * 2 * 8) > buf_size) 1583 return AVERROR_INVALIDDATA; 1584 } 1585 1586 /* start frame decoding */ 1587 if (s->first_field || s->picture_structure == PICT_FRAME) { 1588 AVFrameSideData *pan_scan; 1589 1590 if ((ret = ff_mpv_frame_start(s, avctx)) < 0) 1591 return ret; 1592 1593 ff_mpeg_er_frame_start(s); 1594 1595 /* first check if we must repeat the frame */ 1596 s->current_picture_ptr->f->repeat_pict = 0; 1597 if (s->repeat_first_field) { 1598 if (s->progressive_sequence) { 1599 if (s->top_field_first) 1600 s->current_picture_ptr->f->repeat_pict = 4; 1601 else 1602 s->current_picture_ptr->f->repeat_pict = 2; 1603 } else if (s->progressive_frame) { 1604 s->current_picture_ptr->f->repeat_pict = 1; 1605 } 1606 } 1607 1608 pan_scan = av_frame_new_side_data(s->current_picture_ptr->f, 1609 AV_FRAME_DATA_PANSCAN, 1610 sizeof(s1->pan_scan)); 1611 if (!pan_scan) 1612 return AVERROR(ENOMEM); 1613 memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan)); 1614 1615 if (s1->a53_buf_ref) { 1616 AVFrameSideData *sd = av_frame_new_side_data_from_buf( 1617 s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC, 1618 s1->a53_buf_ref); 1619 if (!sd) 1620 av_buffer_unref(&s1->a53_buf_ref); 1621 s1->a53_buf_ref = NULL; 1622 } 1623 1624 if (s1->has_stereo3d) { 1625 AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f); 1626 if (!stereo) 1627 return AVERROR(ENOMEM); 1628 1629 *stereo = s1->stereo3d; 1630 s1->has_stereo3d = 0; 1631 } 1632 1633 if (s1->has_afd) { 1634 AVFrameSideData *sd = 1635 av_frame_new_side_data(s->current_picture_ptr->f, 1636 AV_FRAME_DATA_AFD, 1); 1637 if (!sd) 1638 return AVERROR(ENOMEM); 1639 1640 *sd->data = s1->afd; 1641 s1->has_afd = 0; 1642 } 1643 1644 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME)) 1645 ff_thread_finish_setup(avctx); 1646 } else { // second field 1647 int i; 1648 1649 if (!s->current_picture_ptr) { 1650 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n"); 1651 return AVERROR_INVALIDDATA; 1652 } 1653 1654 if (s->avctx->hwaccel) { 1655 if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) { 1656 av_log(avctx, AV_LOG_ERROR, 1657 "hardware accelerator failed to decode first field\n"); 1658 return ret; 1659 } 1660 } 1661 1662 for (i = 0; i < 4; i++) { 1663 s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i]; 1664 if (s->picture_structure == PICT_BOTTOM_FIELD) 1665 s->current_picture.f->data[i] += 1666 s->current_picture_ptr->f->linesize[i]; 1667 } 1668 } 1669 1670 if (avctx->hwaccel) { 1671 if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0) 1672 return ret; 1673 } 1674 1675 return 0; 1676} 1677 1678#define DECODE_SLICE_ERROR -1 1679#define DECODE_SLICE_OK 0 1680 1681/** 1682 * Decode a slice. 1683 * MpegEncContext.mb_y must be set to the MB row from the startcode. 1684 * @return DECODE_SLICE_ERROR if the slice is damaged, 1685 * DECODE_SLICE_OK if this slice is OK 1686 */ 1687static int mpeg_decode_slice(MpegEncContext *s, int mb_y, 1688 const uint8_t **buf, int buf_size) 1689{ 1690 AVCodecContext *avctx = s->avctx; 1691 const int lowres = s->avctx->lowres; 1692 const int field_pic = s->picture_structure != PICT_FRAME; 1693 int ret; 1694 1695 s->resync_mb_x = 1696 s->resync_mb_y = -1; 1697 1698 av_assert0(mb_y < s->mb_height); 1699 1700 init_get_bits(&s->gb, *buf, buf_size * 8); 1701 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16) 1702 skip_bits(&s->gb, 3); 1703 1704 ff_mpeg1_clean_buffers(s); 1705 s->interlaced_dct = 0; 1706 1707 s->qscale = mpeg_get_qscale(s); 1708 1709 if (s->qscale == 0) { 1710 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n"); 1711 return AVERROR_INVALIDDATA; 1712 } 1713 1714 /* extra slice info */ 1715 if (skip_1stop_8data_bits(&s->gb) < 0) 1716 return AVERROR_INVALIDDATA; 1717 1718 s->mb_x = 0; 1719 1720 if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) { 1721 skip_bits1(&s->gb); 1722 } else { 1723 while (get_bits_left(&s->gb) > 0) { 1724 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table, 1725 MBINCR_VLC_BITS, 2); 1726 if (code < 0) { 1727 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n"); 1728 return AVERROR_INVALIDDATA; 1729 } 1730 if (code >= 33) { 1731 if (code == 33) 1732 s->mb_x += 33; 1733 /* otherwise, stuffing, nothing to do */ 1734 } else { 1735 s->mb_x += code; 1736 break; 1737 } 1738 } 1739 } 1740 1741 if (s->mb_x >= (unsigned) s->mb_width) { 1742 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n"); 1743 return AVERROR_INVALIDDATA; 1744 } 1745 1746 if (avctx->hwaccel && avctx->hwaccel->decode_slice) { 1747 const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */ 1748 int start_code = -1; 1749 buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code); 1750 if (buf_end < *buf + buf_size) 1751 buf_end -= 4; 1752 s->mb_y = mb_y; 1753 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0) 1754 return DECODE_SLICE_ERROR; 1755 *buf = buf_end; 1756 return DECODE_SLICE_OK; 1757 } 1758 1759 s->resync_mb_x = s->mb_x; 1760 s->resync_mb_y = s->mb_y = mb_y; 1761 s->mb_skip_run = 0; 1762 ff_init_block_index(s); 1763 1764 if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) { 1765 if (s->avctx->debug & FF_DEBUG_PICT_INFO) { 1766 av_log(s->avctx, AV_LOG_DEBUG, 1767 "qp:%d fc:%2d%2d%2d%2d %c %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n", 1768 s->qscale, 1769 s->mpeg_f_code[0][0], s->mpeg_f_code[0][1], 1770 s->mpeg_f_code[1][0], s->mpeg_f_code[1][1], 1771 s->pict_type == AV_PICTURE_TYPE_I ? 'I' : 1772 (s->pict_type == AV_PICTURE_TYPE_P ? 'P' : 1773 (s->pict_type == AV_PICTURE_TYPE_B ? 'B' : 'S')), 1774 s->progressive_sequence ? "ps" : "", 1775 s->progressive_frame ? "pf" : "", 1776 s->alternate_scan ? "alt" : "", 1777 s->top_field_first ? "top" : "", 1778 s->intra_dc_precision, s->picture_structure, 1779 s->frame_pred_frame_dct, s->concealment_motion_vectors, 1780 s->q_scale_type, s->intra_vlc_format, 1781 s->repeat_first_field, s->chroma_420_type ? "420" : ""); 1782 } 1783 } 1784 1785 for (;;) { 1786 if ((ret = mpeg_decode_mb(s, s->block)) < 0) 1787 return ret; 1788 1789 // Note motion_val is normally NULL unless we want to extract the MVs. 1790 if (s->current_picture.motion_val[0] && !s->encoding) { 1791 const int wrap = s->b8_stride; 1792 int xy = s->mb_x * 2 + s->mb_y * 2 * wrap; 1793 int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride); 1794 int motion_x, motion_y, dir, i; 1795 1796 for (i = 0; i < 2; i++) { 1797 for (dir = 0; dir < 2; dir++) { 1798 if (s->mb_intra || 1799 (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) { 1800 motion_x = motion_y = 0; 1801 } else if (s->mv_type == MV_TYPE_16X16 || 1802 (s->mv_type == MV_TYPE_FIELD && field_pic)) { 1803 motion_x = s->mv[dir][0][0]; 1804 motion_y = s->mv[dir][0][1]; 1805 } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */ 1806 motion_x = s->mv[dir][i][0]; 1807 motion_y = s->mv[dir][i][1]; 1808 } 1809 1810 s->current_picture.motion_val[dir][xy][0] = motion_x; 1811 s->current_picture.motion_val[dir][xy][1] = motion_y; 1812 s->current_picture.motion_val[dir][xy + 1][0] = motion_x; 1813 s->current_picture.motion_val[dir][xy + 1][1] = motion_y; 1814 s->current_picture.ref_index [dir][b8_xy] = 1815 s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i]; 1816 av_assert2(s->field_select[dir][i] == 0 || 1817 s->field_select[dir][i] == 1); 1818 } 1819 xy += wrap; 1820 b8_xy += 2; 1821 } 1822 } 1823 1824 s->dest[0] += 16 >> lowres; 1825 s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift; 1826 s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift; 1827 1828 ff_mpv_reconstruct_mb(s, s->block); 1829 1830 if (++s->mb_x >= s->mb_width) { 1831 const int mb_size = 16 >> s->avctx->lowres; 1832 int left; 1833 1834 ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size); 1835 ff_mpv_report_decode_progress(s); 1836 1837 s->mb_x = 0; 1838 s->mb_y += 1 << field_pic; 1839 1840 if (s->mb_y >= s->mb_height) { 1841 int left = get_bits_left(&s->gb); 1842 int is_d10 = s->chroma_format == 2 && 1843 s->pict_type == AV_PICTURE_TYPE_I && 1844 avctx->profile == 0 && avctx->level == 5 && 1845 s->intra_dc_precision == 2 && 1846 s->q_scale_type == 1 && s->alternate_scan == 0 && 1847 s->progressive_frame == 0 1848 /* vbv_delay == 0xBBB || 0xE10 */; 1849 1850 if (left >= 32 && !is_d10) { 1851 GetBitContext gb = s->gb; 1852 align_get_bits(&gb); 1853 if (show_bits(&gb, 24) == 0x060E2B) { 1854 av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n"); 1855 is_d10 = 1; 1856 } 1857 if (left > 32 && show_bits_long(&gb, 32) == 0x201) { 1858 av_log(avctx, AV_LOG_DEBUG, "skipping m704 alpha (unsupported)\n"); 1859 goto eos; 1860 } 1861 } 1862 1863 if (left < 0 || 1864 (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) || 1865 ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) { 1866 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X at %d %d\n", 1867 left, left>0 ? show_bits(&s->gb, FFMIN(left, 23)) : 0, s->mb_x, s->mb_y); 1868 return AVERROR_INVALIDDATA; 1869 } else 1870 goto eos; 1871 } 1872 // There are some files out there which are missing the last slice 1873 // in cases where the slice is completely outside the visible 1874 // area, we detect this here instead of running into the end expecting 1875 // more data 1876 left = get_bits_left(&s->gb); 1877 if (s->mb_y >= ((s->height + 15) >> 4) && 1878 !s->progressive_sequence && 1879 left <= 25 && 1880 left >= 0 && 1881 s->mb_skip_run == -1 && 1882 (!left || show_bits(&s->gb, left) == 0)) 1883 goto eos; 1884 1885 ff_init_block_index(s); 1886 } 1887 1888 /* skip mb handling */ 1889 if (s->mb_skip_run == -1) { 1890 /* read increment again */ 1891 s->mb_skip_run = 0; 1892 for (;;) { 1893 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table, 1894 MBINCR_VLC_BITS, 2); 1895 if (code < 0) { 1896 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n"); 1897 return AVERROR_INVALIDDATA; 1898 } 1899 if (code >= 33) { 1900 if (code == 33) { 1901 s->mb_skip_run += 33; 1902 } else if (code == 35) { 1903 if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) { 1904 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n"); 1905 return AVERROR_INVALIDDATA; 1906 } 1907 goto eos; /* end of slice */ 1908 } 1909 /* otherwise, stuffing, nothing to do */ 1910 } else { 1911 s->mb_skip_run += code; 1912 break; 1913 } 1914 } 1915 if (s->mb_skip_run) { 1916 int i; 1917 if (s->pict_type == AV_PICTURE_TYPE_I) { 1918 av_log(s->avctx, AV_LOG_ERROR, 1919 "skipped MB in I-frame at %d %d\n", s->mb_x, s->mb_y); 1920 return AVERROR_INVALIDDATA; 1921 } 1922 1923 /* skip mb */ 1924 s->mb_intra = 0; 1925 for (i = 0; i < 12; i++) 1926 s->block_last_index[i] = -1; 1927 if (s->picture_structure == PICT_FRAME) 1928 s->mv_type = MV_TYPE_16X16; 1929 else 1930 s->mv_type = MV_TYPE_FIELD; 1931 if (s->pict_type == AV_PICTURE_TYPE_P) { 1932 /* if P type, zero motion vector is implied */ 1933 s->mv_dir = MV_DIR_FORWARD; 1934 s->mv[0][0][0] = s->mv[0][0][1] = 0; 1935 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0; 1936 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0; 1937 s->field_select[0][0] = (s->picture_structure - 1) & 1; 1938 } else { 1939 /* if B type, reuse previous vectors and directions */ 1940 s->mv[0][0][0] = s->last_mv[0][0][0]; 1941 s->mv[0][0][1] = s->last_mv[0][0][1]; 1942 s->mv[1][0][0] = s->last_mv[1][0][0]; 1943 s->mv[1][0][1] = s->last_mv[1][0][1]; 1944 s->field_select[0][0] = (s->picture_structure - 1) & 1; 1945 s->field_select[1][0] = (s->picture_structure - 1) & 1; 1946 } 1947 } 1948 } 1949 } 1950eos: // end of slice 1951 if (get_bits_left(&s->gb) < 0) { 1952 av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb)); 1953 return AVERROR_INVALIDDATA; 1954 } 1955 *buf += (get_bits_count(&s->gb) - 1) / 8; 1956 ff_dlog(s, "Slice start:%d %d end:%d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y); 1957 return 0; 1958} 1959 1960static int slice_decode_thread(AVCodecContext *c, void *arg) 1961{ 1962 MpegEncContext *s = *(void **) arg; 1963 const uint8_t *buf = s->gb.buffer; 1964 int mb_y = s->start_mb_y; 1965 const int field_pic = s->picture_structure != PICT_FRAME; 1966 1967 s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic; 1968 1969 for (;;) { 1970 uint32_t start_code; 1971 int ret; 1972 1973 ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf); 1974 emms_c(); 1975 ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n", 1976 ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, 1977 s->start_mb_y, s->end_mb_y, s->er.error_count); 1978 if (ret < 0) { 1979 if (c->err_recognition & AV_EF_EXPLODE) 1980 return ret; 1981 if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0) 1982 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, 1983 s->mb_x, s->mb_y, 1984 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR); 1985 } else { 1986 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, 1987 s->mb_x - 1, s->mb_y, 1988 ER_AC_END | ER_DC_END | ER_MV_END); 1989 } 1990 1991 if (s->mb_y == s->end_mb_y) 1992 return 0; 1993 1994 start_code = -1; 1995 buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code); 1996 if (start_code < SLICE_MIN_START_CODE || start_code > SLICE_MAX_START_CODE) 1997 return AVERROR_INVALIDDATA; 1998 mb_y = start_code - SLICE_MIN_START_CODE; 1999 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16) 2000 mb_y += (*buf&0xE0)<<2; 2001 mb_y <<= field_pic; 2002 if (s->picture_structure == PICT_BOTTOM_FIELD) 2003 mb_y++; 2004 if (mb_y >= s->end_mb_y) 2005 return AVERROR_INVALIDDATA; 2006 } 2007} 2008 2009/** 2010 * Handle slice ends. 2011 * @return 1 if it seems to be the last slice 2012 */ 2013static int slice_end(AVCodecContext *avctx, AVFrame *pict) 2014{ 2015 Mpeg1Context *s1 = avctx->priv_data; 2016 MpegEncContext *s = &s1->mpeg_enc_ctx; 2017 2018 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr) 2019 return 0; 2020 2021 if (s->avctx->hwaccel) { 2022 int ret = s->avctx->hwaccel->end_frame(s->avctx); 2023 if (ret < 0) { 2024 av_log(avctx, AV_LOG_ERROR, 2025 "hardware accelerator failed to decode picture\n"); 2026 return ret; 2027 } 2028 } 2029 2030 /* end of slice reached */ 2031 if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) { 2032 /* end of image */ 2033 2034 ff_er_frame_end(&s->er); 2035 2036 ff_mpv_frame_end(s); 2037 2038 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { 2039 int ret = av_frame_ref(pict, s->current_picture_ptr->f); 2040 if (ret < 0) 2041 return ret; 2042 ff_print_debug_info(s, s->current_picture_ptr, pict); 2043 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG2); 2044 } else { 2045 /* latency of 1 frame for I- and P-frames */ 2046 if (s->last_picture_ptr) { 2047 int ret = av_frame_ref(pict, s->last_picture_ptr->f); 2048 if (ret < 0) 2049 return ret; 2050 ff_print_debug_info(s, s->last_picture_ptr, pict); 2051 ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG2); 2052 } 2053 } 2054 2055 return 1; 2056 } else { 2057 return 0; 2058 } 2059} 2060 2061static int mpeg1_decode_sequence(AVCodecContext *avctx, 2062 const uint8_t *buf, int buf_size) 2063{ 2064 Mpeg1Context *s1 = avctx->priv_data; 2065 MpegEncContext *s = &s1->mpeg_enc_ctx; 2066 int width, height; 2067 int i, v, j; 2068 2069 init_get_bits(&s->gb, buf, buf_size * 8); 2070 2071 width = get_bits(&s->gb, 12); 2072 height = get_bits(&s->gb, 12); 2073 if (width == 0 || height == 0) { 2074 av_log(avctx, AV_LOG_WARNING, 2075 "Invalid horizontal or vertical size value.\n"); 2076 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT)) 2077 return AVERROR_INVALIDDATA; 2078 } 2079 s1->aspect_ratio_info = get_bits(&s->gb, 4); 2080 if (s1->aspect_ratio_info == 0) { 2081 av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n"); 2082 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT)) 2083 return AVERROR_INVALIDDATA; 2084 } 2085 s1->frame_rate_index = get_bits(&s->gb, 4); 2086 if (s1->frame_rate_index == 0 || s1->frame_rate_index > 13) { 2087 av_log(avctx, AV_LOG_WARNING, 2088 "frame_rate_index %d is invalid\n", s1->frame_rate_index); 2089 s1->frame_rate_index = 1; 2090 } 2091 s->bit_rate = get_bits(&s->gb, 18) * 400LL; 2092 if (check_marker(s->avctx, &s->gb, "in sequence header") == 0) { 2093 return AVERROR_INVALIDDATA; 2094 } 2095 2096 s1->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16; 2097 skip_bits(&s->gb, 1); 2098 2099 /* get matrix */ 2100 if (get_bits1(&s->gb)) { 2101 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1); 2102 } else { 2103 for (i = 0; i < 64; i++) { 2104 j = s->idsp.idct_permutation[i]; 2105 v = ff_mpeg1_default_intra_matrix[i]; 2106 s->intra_matrix[j] = v; 2107 s->chroma_intra_matrix[j] = v; 2108 } 2109 } 2110 if (get_bits1(&s->gb)) { 2111 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0); 2112 } else { 2113 for (i = 0; i < 64; i++) { 2114 int j = s->idsp.idct_permutation[i]; 2115 v = ff_mpeg1_default_non_intra_matrix[i]; 2116 s->inter_matrix[j] = v; 2117 s->chroma_inter_matrix[j] = v; 2118 } 2119 } 2120 2121 if (show_bits(&s->gb, 23) != 0) { 2122 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n"); 2123 return AVERROR_INVALIDDATA; 2124 } 2125 2126 s->width = width; 2127 s->height = height; 2128 2129 /* We set MPEG-2 parameters so that it emulates MPEG-1. */ 2130 s->progressive_sequence = 1; 2131 s->progressive_frame = 1; 2132 s->picture_structure = PICT_FRAME; 2133 s->first_field = 0; 2134 s->frame_pred_frame_dct = 1; 2135 s->chroma_format = 1; 2136 s->codec_id = 2137 s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO; 2138 s->out_format = FMT_MPEG1; 2139 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) 2140 s->low_delay = 1; 2141 2142 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 2143 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n", 2144 s1->rc_buffer_size, s->bit_rate, s1->aspect_ratio_info); 2145 2146 return 0; 2147} 2148 2149static int vcr2_init_sequence(AVCodecContext *avctx) 2150{ 2151 Mpeg1Context *s1 = avctx->priv_data; 2152 MpegEncContext *s = &s1->mpeg_enc_ctx; 2153 int i, v, ret; 2154 2155 /* start new MPEG-1 context decoding */ 2156 s->out_format = FMT_MPEG1; 2157 if (s1->mpeg_enc_ctx_allocated) { 2158 ff_mpv_common_end(s); 2159 s1->mpeg_enc_ctx_allocated = 0; 2160 } 2161 s->width = avctx->coded_width; 2162 s->height = avctx->coded_height; 2163 avctx->has_b_frames = 0; // true? 2164 s->low_delay = 1; 2165 2166 avctx->pix_fmt = mpeg_get_pixelformat(avctx); 2167 2168 ff_mpv_idct_init(s); 2169 if ((ret = ff_mpv_common_init(s)) < 0) 2170 return ret; 2171 s1->mpeg_enc_ctx_allocated = 1; 2172 2173 for (i = 0; i < 64; i++) { 2174 int j = s->idsp.idct_permutation[i]; 2175 v = ff_mpeg1_default_intra_matrix[i]; 2176 s->intra_matrix[j] = v; 2177 s->chroma_intra_matrix[j] = v; 2178 2179 v = ff_mpeg1_default_non_intra_matrix[i]; 2180 s->inter_matrix[j] = v; 2181 s->chroma_inter_matrix[j] = v; 2182 } 2183 2184 s->progressive_sequence = 1; 2185 s->progressive_frame = 1; 2186 s->picture_structure = PICT_FRAME; 2187 s->first_field = 0; 2188 s->frame_pred_frame_dct = 1; 2189 s->chroma_format = 1; 2190 if (s->codec_tag == AV_RL32("BW10")) { 2191 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO; 2192 } else { 2193 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO; 2194 } 2195 s1->save_width = s->width; 2196 s1->save_height = s->height; 2197 s1->save_progressive_seq = s->progressive_sequence; 2198 return 0; 2199} 2200 2201static int mpeg_decode_a53_cc(AVCodecContext *avctx, 2202 const uint8_t *p, int buf_size) 2203{ 2204 Mpeg1Context *s1 = avctx->priv_data; 2205 2206 if (buf_size >= 6 && 2207 p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' && 2208 p[4] == 3 && (p[5] & 0x40)) { 2209 /* extract A53 Part 4 CC data */ 2210 int cc_count = p[5] & 0x1f; 2211 if (cc_count > 0 && buf_size >= 7 + cc_count * 3) { 2212 int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0; 2213 const uint64_t new_size = (old_size + cc_count 2214 * UINT64_C(3)); 2215 int ret; 2216 2217 if (new_size > 3*A53_MAX_CC_COUNT) 2218 return AVERROR(EINVAL); 2219 2220 ret = av_buffer_realloc(&s1->a53_buf_ref, new_size); 2221 if (ret >= 0) 2222 memcpy(s1->a53_buf_ref->data + old_size, p + 7, cc_count * UINT64_C(3)); 2223 2224 avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS; 2225 } 2226 return 1; 2227 } else if (buf_size >= 2 && 2228 p[0] == 0x03 && (p[1]&0x7f) == 0x01) { 2229 /* extract SCTE-20 CC data */ 2230 GetBitContext gb; 2231 int cc_count = 0; 2232 int i, ret; 2233 2234 init_get_bits8(&gb, p + 2, buf_size - 2); 2235 cc_count = get_bits(&gb, 5); 2236 if (cc_count > 0) { 2237 int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0; 2238 const uint64_t new_size = (old_size + cc_count 2239 * UINT64_C(3)); 2240 if (new_size > 3*A53_MAX_CC_COUNT) 2241 return AVERROR(EINVAL); 2242 2243 ret = av_buffer_realloc(&s1->a53_buf_ref, new_size); 2244 if (ret >= 0) { 2245 uint8_t field, cc1, cc2; 2246 uint8_t *cap = s1->a53_buf_ref->data; 2247 2248 memset(s1->a53_buf_ref->data + old_size, 0, cc_count * 3); 2249 for (i = 0; i < cc_count && get_bits_left(&gb) >= 26; i++) { 2250 skip_bits(&gb, 2); // priority 2251 field = get_bits(&gb, 2); 2252 skip_bits(&gb, 5); // line_offset 2253 cc1 = get_bits(&gb, 8); 2254 cc2 = get_bits(&gb, 8); 2255 skip_bits(&gb, 1); // marker 2256 2257 if (!field) { // forbidden 2258 cap[0] = cap[1] = cap[2] = 0x00; 2259 } else { 2260 field = (field == 2 ? 1 : 0); 2261 if (!s1->mpeg_enc_ctx.top_field_first) field = !field; 2262 cap[0] = 0x04 | field; 2263 cap[1] = ff_reverse[cc1]; 2264 cap[2] = ff_reverse[cc2]; 2265 } 2266 cap += 3; 2267 } 2268 } 2269 avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS; 2270 } 2271 return 1; 2272 } else if (buf_size >= 11 && 2273 p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) { 2274 /* extract DVD CC data 2275 * 2276 * uint32_t user_data_start_code 0x000001B2 (big endian) 2277 * uint16_t user_identifier 0x4343 "CC" 2278 * uint8_t user_data_type_code 0x01 2279 * uint8_t caption_block_size 0xF8 2280 * uint8_t 2281 * bit 7 caption_odd_field_first 1=odd field (CC1/CC2) first 0=even field (CC3/CC4) first 2282 * bit 6 caption_filler 0 2283 * bit 5:1 caption_block_count number of caption blocks (pairs of caption words = frames). Most DVDs use 15 per start of GOP. 2284 * bit 0 caption_extra_field_added 1=one additional caption word 2285 * 2286 * struct caption_field_block { 2287 * uint8_t 2288 * bit 7:1 caption_filler 0x7F (all 1s) 2289 * bit 0 caption_field_odd 1=odd field (this is CC1/CC2) 0=even field (this is CC3/CC4) 2290 * uint8_t caption_first_byte 2291 * uint8_t caption_second_byte 2292 * } caption_block[(caption_block_count * 2) + caption_extra_field_added]; 2293 * 2294 * Some DVDs encode caption data for both fields with caption_field_odd=1. The only way to decode the fields 2295 * correctly is to start on the field indicated by caption_odd_field_first and count between odd/even fields. 2296 * Don't assume that the first caption word is the odd field. There do exist MPEG files in the wild that start 2297 * on the even field. There also exist DVDs in the wild that encode an odd field count and the 2298 * caption_extra_field_added/caption_odd_field_first bits change per packet to allow that. */ 2299 int cc_count = 0; 2300 int i, ret; 2301 // There is a caption count field in the data, but it is often 2302 // incorrect. So count the number of captions present. 2303 for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6) 2304 cc_count++; 2305 // Transform the DVD format into A53 Part 4 format 2306 if (cc_count > 0) { 2307 int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0; 2308 const uint64_t new_size = (old_size + cc_count 2309 * UINT64_C(6)); 2310 if (new_size > 3*A53_MAX_CC_COUNT) 2311 return AVERROR(EINVAL); 2312 2313 ret = av_buffer_realloc(&s1->a53_buf_ref, new_size); 2314 if (ret >= 0) { 2315 uint8_t field1 = !!(p[4] & 0x80); 2316 uint8_t *cap = s1->a53_buf_ref->data; 2317 p += 5; 2318 for (i = 0; i < cc_count; i++) { 2319 cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd; 2320 cap[1] = p[1]; 2321 cap[2] = p[2]; 2322 cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd; 2323 cap[4] = p[4]; 2324 cap[5] = p[5]; 2325 cap += 6; 2326 p += 6; 2327 } 2328 } 2329 avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS; 2330 } 2331 return 1; 2332 } 2333 return 0; 2334} 2335 2336static void mpeg_decode_user_data(AVCodecContext *avctx, 2337 const uint8_t *p, int buf_size) 2338{ 2339 Mpeg1Context *s = avctx->priv_data; 2340 const uint8_t *buf_end = p + buf_size; 2341 Mpeg1Context *s1 = avctx->priv_data; 2342 2343#if 0 2344 int i; 2345 for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){ 2346 av_log(avctx, AV_LOG_ERROR, "%c", p[i]); 2347 } 2348 av_log(avctx, AV_LOG_ERROR, "\n"); 2349#endif 2350 2351 if (buf_size > 29){ 2352 int i; 2353 for(i=0; i<20; i++) 2354 if (!memcmp(p+i, "\0TMPGEXS\0", 9)){ 2355 s->tmpgexs= 1; 2356 } 2357 } 2358 /* we parse the DTG active format information */ 2359 if (buf_end - p >= 5 && 2360 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') { 2361 int flags = p[4]; 2362 p += 5; 2363 if (flags & 0x80) { 2364 /* skip event id */ 2365 p += 2; 2366 } 2367 if (flags & 0x40) { 2368 if (buf_end - p < 1) 2369 return; 2370 s1->has_afd = 1; 2371 s1->afd = p[0] & 0x0f; 2372 } 2373 } else if (buf_end - p >= 6 && 2374 p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' && 2375 p[4] == 0x03) { // S3D_video_format_length 2376 // the 0x7F mask ignores the reserved_bit value 2377 const uint8_t S3D_video_format_type = p[5] & 0x7F; 2378 2379 if (S3D_video_format_type == 0x03 || 2380 S3D_video_format_type == 0x04 || 2381 S3D_video_format_type == 0x08 || 2382 S3D_video_format_type == 0x23) { 2383 2384 s1->has_stereo3d = 1; 2385 2386 switch (S3D_video_format_type) { 2387 case 0x03: 2388 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE; 2389 break; 2390 case 0x04: 2391 s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM; 2392 break; 2393 case 0x08: 2394 s1->stereo3d.type = AV_STEREO3D_2D; 2395 break; 2396 case 0x23: 2397 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX; 2398 break; 2399 } 2400 } 2401 } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) { 2402 return; 2403 } 2404} 2405 2406static void mpeg_decode_gop(AVCodecContext *avctx, 2407 const uint8_t *buf, int buf_size) 2408{ 2409 Mpeg1Context *s1 = avctx->priv_data; 2410 MpegEncContext *s = &s1->mpeg_enc_ctx; 2411 int broken_link; 2412 int64_t tc; 2413 2414 init_get_bits(&s->gb, buf, buf_size * 8); 2415 2416 tc = s1->timecode_frame_start = get_bits(&s->gb, 25); 2417 2418 s1->closed_gop = get_bits1(&s->gb); 2419 /* broken_link indicates that after editing the 2420 * reference frames of the first B-Frames after GOP I-Frame 2421 * are missing (open gop) */ 2422 broken_link = get_bits1(&s->gb); 2423 2424 if (s->avctx->debug & FF_DEBUG_PICT_INFO) { 2425 char tcbuf[AV_TIMECODE_STR_SIZE]; 2426 av_timecode_make_mpeg_tc_string(tcbuf, tc); 2427 av_log(s->avctx, AV_LOG_DEBUG, 2428 "GOP (%s) closed_gop=%d broken_link=%d\n", 2429 tcbuf, s1->closed_gop, broken_link); 2430 } 2431} 2432 2433static int decode_chunks(AVCodecContext *avctx, AVFrame *picture, 2434 int *got_output, const uint8_t *buf, int buf_size) 2435{ 2436 Mpeg1Context *s = avctx->priv_data; 2437 MpegEncContext *s2 = &s->mpeg_enc_ctx; 2438 const uint8_t *buf_ptr = buf; 2439 const uint8_t *buf_end = buf + buf_size; 2440 int ret, input_size; 2441 int last_code = 0, skip_frame = 0; 2442 int picture_start_code_seen = 0; 2443 2444 for (;;) { 2445 /* find next start code */ 2446 uint32_t start_code = -1; 2447 buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code); 2448 if (start_code > 0x1ff) { 2449 if (!skip_frame) { 2450 if (HAVE_THREADS && 2451 (avctx->active_thread_type & FF_THREAD_SLICE) && 2452 !avctx->hwaccel) { 2453 int i; 2454 av_assert0(avctx->thread_count > 1); 2455 2456 avctx->execute(avctx, slice_decode_thread, 2457 &s2->thread_context[0], NULL, 2458 s->slice_count, sizeof(void *)); 2459 for (i = 0; i < s->slice_count; i++) 2460 s2->er.error_count += s2->thread_context[i]->er.error_count; 2461 } 2462 2463 ret = slice_end(avctx, picture); 2464 if (ret < 0) 2465 return ret; 2466 else if (ret) { 2467 // FIXME: merge with the stuff in mpeg_decode_slice 2468 if (s2->last_picture_ptr || s2->low_delay || s2->pict_type == AV_PICTURE_TYPE_B) 2469 *got_output = 1; 2470 } 2471 } 2472 s2->pict_type = 0; 2473 2474 if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count) 2475 return AVERROR_INVALIDDATA; 2476 2477#if FF_API_FLAG_TRUNCATED 2478 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index); 2479#else 2480 return FFMAX(0, buf_ptr - buf); 2481#endif 2482 } 2483 2484 input_size = buf_end - buf_ptr; 2485 2486 if (avctx->debug & FF_DEBUG_STARTCODE) 2487 av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n", 2488 start_code, buf_ptr - buf, input_size); 2489 2490 /* prepare data for next start code */ 2491 switch (start_code) { 2492 case SEQ_START_CODE: 2493 if (last_code == 0) { 2494 mpeg1_decode_sequence(avctx, buf_ptr, input_size); 2495 if (buf != avctx->extradata) 2496 s->sync = 1; 2497 } else { 2498 av_log(avctx, AV_LOG_ERROR, 2499 "ignoring SEQ_START_CODE after %X\n", last_code); 2500 if (avctx->err_recognition & AV_EF_EXPLODE) 2501 return AVERROR_INVALIDDATA; 2502 } 2503 break; 2504 2505 case PICTURE_START_CODE: 2506 if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) { 2507 /* If it's a frame picture, there can't be more than one picture header. 2508 Yet, it does happen and we need to handle it. */ 2509 av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n"); 2510 break; 2511 } 2512 picture_start_code_seen = 1; 2513 2514 if (s2->width <= 0 || s2->height <= 0) { 2515 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n", 2516 s2->width, s2->height); 2517 return AVERROR_INVALIDDATA; 2518 } 2519 2520 if (s->tmpgexs){ 2521 s2->intra_dc_precision= 3; 2522 s2->intra_matrix[0]= 1; 2523 } 2524 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) && 2525 !avctx->hwaccel && s->slice_count) { 2526 int i; 2527 2528 avctx->execute(avctx, slice_decode_thread, 2529 s2->thread_context, NULL, 2530 s->slice_count, sizeof(void *)); 2531 for (i = 0; i < s->slice_count; i++) 2532 s2->er.error_count += s2->thread_context[i]->er.error_count; 2533 s->slice_count = 0; 2534 } 2535 if (last_code == 0 || last_code == SLICE_MIN_START_CODE) { 2536 ret = mpeg_decode_postinit(avctx); 2537 if (ret < 0) { 2538 av_log(avctx, AV_LOG_ERROR, 2539 "mpeg_decode_postinit() failure\n"); 2540 return ret; 2541 } 2542 2543 /* We have a complete image: we try to decompress it. */ 2544 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0) 2545 s2->pict_type = 0; 2546 s->first_slice = 1; 2547 last_code = PICTURE_START_CODE; 2548 } else { 2549 av_log(avctx, AV_LOG_ERROR, 2550 "ignoring pic after %X\n", last_code); 2551 if (avctx->err_recognition & AV_EF_EXPLODE) 2552 return AVERROR_INVALIDDATA; 2553 } 2554 break; 2555 case EXT_START_CODE: 2556 ret = init_get_bits8(&s2->gb, buf_ptr, input_size); 2557 if (ret < 0) 2558 return ret; 2559 2560 switch (get_bits(&s2->gb, 4)) { 2561 case 0x1: 2562 if (last_code == 0) { 2563 mpeg_decode_sequence_extension(s); 2564 } else { 2565 av_log(avctx, AV_LOG_ERROR, 2566 "ignoring seq ext after %X\n", last_code); 2567 if (avctx->err_recognition & AV_EF_EXPLODE) 2568 return AVERROR_INVALIDDATA; 2569 } 2570 break; 2571 case 0x2: 2572 mpeg_decode_sequence_display_extension(s); 2573 break; 2574 case 0x3: 2575 mpeg_decode_quant_matrix_extension(s2); 2576 break; 2577 case 0x7: 2578 mpeg_decode_picture_display_extension(s); 2579 break; 2580 case 0x8: 2581 if (last_code == PICTURE_START_CODE) { 2582 int ret = mpeg_decode_picture_coding_extension(s); 2583 if (ret < 0) 2584 return ret; 2585 } else { 2586 av_log(avctx, AV_LOG_ERROR, 2587 "ignoring pic cod ext after %X\n", last_code); 2588 if (avctx->err_recognition & AV_EF_EXPLODE) 2589 return AVERROR_INVALIDDATA; 2590 } 2591 break; 2592 } 2593 break; 2594 case USER_START_CODE: 2595 mpeg_decode_user_data(avctx, buf_ptr, input_size); 2596 break; 2597 case GOP_START_CODE: 2598 if (last_code == 0) { 2599 s2->first_field = 0; 2600 mpeg_decode_gop(avctx, buf_ptr, input_size); 2601 s->sync = 1; 2602 } else { 2603 av_log(avctx, AV_LOG_ERROR, 2604 "ignoring GOP_START_CODE after %X\n", last_code); 2605 if (avctx->err_recognition & AV_EF_EXPLODE) 2606 return AVERROR_INVALIDDATA; 2607 } 2608 break; 2609 default: 2610 if (start_code >= SLICE_MIN_START_CODE && 2611 start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) { 2612 if (s2->progressive_sequence && !s2->progressive_frame) { 2613 s2->progressive_frame = 1; 2614 av_log(s2->avctx, AV_LOG_ERROR, 2615 "interlaced frame in progressive sequence, ignoring\n"); 2616 } 2617 2618 if (s2->picture_structure == 0 || 2619 (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) { 2620 av_log(s2->avctx, AV_LOG_ERROR, 2621 "picture_structure %d invalid, ignoring\n", 2622 s2->picture_structure); 2623 s2->picture_structure = PICT_FRAME; 2624 } 2625 2626 if (s2->progressive_sequence && !s2->frame_pred_frame_dct) 2627 av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n"); 2628 2629 if (s2->picture_structure == PICT_FRAME) { 2630 s2->first_field = 0; 2631 s2->v_edge_pos = 16 * s2->mb_height; 2632 } else { 2633 s2->first_field ^= 1; 2634 s2->v_edge_pos = 8 * s2->mb_height; 2635 memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height); 2636 } 2637 } 2638 if (start_code >= SLICE_MIN_START_CODE && 2639 start_code <= SLICE_MAX_START_CODE && last_code != 0) { 2640 const int field_pic = s2->picture_structure != PICT_FRAME; 2641 int mb_y = start_code - SLICE_MIN_START_CODE; 2642 last_code = SLICE_MIN_START_CODE; 2643 if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16) 2644 mb_y += (*buf_ptr&0xE0)<<2; 2645 2646 mb_y <<= field_pic; 2647 if (s2->picture_structure == PICT_BOTTOM_FIELD) 2648 mb_y++; 2649 2650 if (buf_end - buf_ptr < 2) { 2651 av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n"); 2652 return AVERROR_INVALIDDATA; 2653 } 2654 2655 if (mb_y >= s2->mb_height) { 2656 av_log(s2->avctx, AV_LOG_ERROR, 2657 "slice below image (%d >= %d)\n", mb_y, s2->mb_height); 2658 return AVERROR_INVALIDDATA; 2659 } 2660 2661 if (!s2->last_picture_ptr) { 2662 /* Skip B-frames if we do not have reference frames and 2663 * GOP is not closed. */ 2664 if (s2->pict_type == AV_PICTURE_TYPE_B) { 2665 if (!s->closed_gop) { 2666 skip_frame = 1; 2667 av_log(s2->avctx, AV_LOG_DEBUG, 2668 "Skipping B slice due to open GOP\n"); 2669 break; 2670 } 2671 } 2672 } 2673 if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL)) 2674 s->sync = 1; 2675 if (!s2->next_picture_ptr) { 2676 /* Skip P-frames if we do not have a reference frame or 2677 * we have an invalid header. */ 2678 if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) { 2679 skip_frame = 1; 2680 av_log(s2->avctx, AV_LOG_DEBUG, 2681 "Skipping P slice due to !sync\n"); 2682 break; 2683 } 2684 } 2685 if ((avctx->skip_frame >= AVDISCARD_NONREF && 2686 s2->pict_type == AV_PICTURE_TYPE_B) || 2687 (avctx->skip_frame >= AVDISCARD_NONKEY && 2688 s2->pict_type != AV_PICTURE_TYPE_I) || 2689 avctx->skip_frame >= AVDISCARD_ALL) { 2690 skip_frame = 1; 2691 break; 2692 } 2693 2694 if (!s->mpeg_enc_ctx_allocated) 2695 break; 2696 2697 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) { 2698 if (mb_y < avctx->skip_top || 2699 mb_y >= s2->mb_height - avctx->skip_bottom) 2700 break; 2701 } 2702 2703 if (!s2->pict_type) { 2704 av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n"); 2705 if (avctx->err_recognition & AV_EF_EXPLODE) 2706 return AVERROR_INVALIDDATA; 2707 break; 2708 } 2709 2710 if (s->first_slice) { 2711 skip_frame = 0; 2712 s->first_slice = 0; 2713 if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0) 2714 return ret; 2715 } 2716 if (!s2->current_picture_ptr) { 2717 av_log(avctx, AV_LOG_ERROR, 2718 "current_picture not initialized\n"); 2719 return AVERROR_INVALIDDATA; 2720 } 2721 2722 if (HAVE_THREADS && 2723 (avctx->active_thread_type & FF_THREAD_SLICE) && 2724 !avctx->hwaccel) { 2725 int threshold = (s2->mb_height * s->slice_count + 2726 s2->slice_context_count / 2) / 2727 s2->slice_context_count; 2728 av_assert0(avctx->thread_count > 1); 2729 if (threshold <= mb_y) { 2730 MpegEncContext *thread_context = s2->thread_context[s->slice_count]; 2731 2732 thread_context->start_mb_y = mb_y; 2733 thread_context->end_mb_y = s2->mb_height; 2734 if (s->slice_count) { 2735 s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y; 2736 ret = ff_update_duplicate_context(thread_context, s2); 2737 if (ret < 0) 2738 return ret; 2739 } 2740 init_get_bits(&thread_context->gb, buf_ptr, input_size * 8); 2741 s->slice_count++; 2742 } 2743 buf_ptr += 2; // FIXME add minimum number of bytes per slice 2744 } else { 2745 ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size); 2746 emms_c(); 2747 2748 if (ret < 0) { 2749 if (avctx->err_recognition & AV_EF_EXPLODE) 2750 return ret; 2751 if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0) 2752 ff_er_add_slice(&s2->er, s2->resync_mb_x, 2753 s2->resync_mb_y, s2->mb_x, s2->mb_y, 2754 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR); 2755 } else { 2756 ff_er_add_slice(&s2->er, s2->resync_mb_x, 2757 s2->resync_mb_y, s2->mb_x - 1, s2->mb_y, 2758 ER_AC_END | ER_DC_END | ER_MV_END); 2759 } 2760 } 2761 } 2762 break; 2763 } 2764 } 2765} 2766 2767static int mpeg_decode_frame(AVCodecContext *avctx, AVFrame *picture, 2768 int *got_output, AVPacket *avpkt) 2769{ 2770 const uint8_t *buf = avpkt->data; 2771 int ret; 2772 int buf_size = avpkt->size; 2773 Mpeg1Context *s = avctx->priv_data; 2774 MpegEncContext *s2 = &s->mpeg_enc_ctx; 2775 2776 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) { 2777 /* special case for last picture */ 2778 if (s2->low_delay == 0 && s2->next_picture_ptr) { 2779 int ret = av_frame_ref(picture, s2->next_picture_ptr->f); 2780 if (ret < 0) 2781 return ret; 2782 2783 s2->next_picture_ptr = NULL; 2784 2785 *got_output = 1; 2786 } 2787 return buf_size; 2788 } 2789 2790#if FF_API_FLAG_TRUNCATED 2791 if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) { 2792 int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf, 2793 buf_size, NULL); 2794 2795 if (ff_combine_frame(&s2->parse_context, next, 2796 (const uint8_t **) &buf, &buf_size) < 0) 2797 return buf_size; 2798 } 2799#endif 2800 2801 s2->codec_tag = ff_toupper4(avctx->codec_tag); 2802 if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2") 2803 || s2->codec_tag == AV_RL32("BW10") 2804 )) 2805 vcr2_init_sequence(avctx); 2806 2807 s->slice_count = 0; 2808 2809 if (avctx->extradata && !s->extradata_decoded) { 2810 ret = decode_chunks(avctx, picture, got_output, 2811 avctx->extradata, avctx->extradata_size); 2812 if (*got_output) { 2813 av_log(avctx, AV_LOG_ERROR, "picture in extradata\n"); 2814 av_frame_unref(picture); 2815 *got_output = 0; 2816 } 2817 s->extradata_decoded = 1; 2818 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) { 2819 s2->current_picture_ptr = NULL; 2820 return ret; 2821 } 2822 } 2823 2824 ret = decode_chunks(avctx, picture, got_output, buf, buf_size); 2825 if (ret<0 || *got_output) { 2826 s2->current_picture_ptr = NULL; 2827 2828 if (s->timecode_frame_start != -1 && *got_output) { 2829 char tcbuf[AV_TIMECODE_STR_SIZE]; 2830 AVFrameSideData *tcside = av_frame_new_side_data(picture, 2831 AV_FRAME_DATA_GOP_TIMECODE, 2832 sizeof(int64_t)); 2833 if (!tcside) 2834 return AVERROR(ENOMEM); 2835 memcpy(tcside->data, &s->timecode_frame_start, sizeof(int64_t)); 2836 2837 av_timecode_make_mpeg_tc_string(tcbuf, s->timecode_frame_start); 2838 av_dict_set(&picture->metadata, "timecode", tcbuf, 0); 2839 2840 s->timecode_frame_start = -1; 2841 } 2842 } 2843 2844 return ret; 2845} 2846 2847static void flush(AVCodecContext *avctx) 2848{ 2849 Mpeg1Context *s = avctx->priv_data; 2850 2851 s->sync = 0; 2852 s->closed_gop = 0; 2853 2854 ff_mpeg_flush(avctx); 2855} 2856 2857static av_cold int mpeg_decode_end(AVCodecContext *avctx) 2858{ 2859 Mpeg1Context *s = avctx->priv_data; 2860 2861 if (s->mpeg_enc_ctx_allocated) 2862 ff_mpv_common_end(&s->mpeg_enc_ctx); 2863 av_buffer_unref(&s->a53_buf_ref); 2864 return 0; 2865} 2866 2867const FFCodec ff_mpeg1video_decoder = { 2868 .p.name = "mpeg1video", 2869 .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"), 2870 .p.type = AVMEDIA_TYPE_VIDEO, 2871 .p.id = AV_CODEC_ID_MPEG1VIDEO, 2872 .priv_data_size = sizeof(Mpeg1Context), 2873 .init = mpeg_decode_init, 2874 .close = mpeg_decode_end, 2875 FF_CODEC_DECODE_CB(mpeg_decode_frame), 2876 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | 2877#if FF_API_FLAG_TRUNCATED 2878 AV_CODEC_CAP_TRUNCATED | 2879#endif 2880 AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS, 2881 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | 2882 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, 2883 .flush = flush, 2884 .p.max_lowres = 3, 2885 .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context), 2886 .hw_configs = (const AVCodecHWConfigInternal *const []) { 2887#if CONFIG_MPEG1_NVDEC_HWACCEL 2888 HWACCEL_NVDEC(mpeg1), 2889#endif 2890#if CONFIG_MPEG1_VDPAU_HWACCEL 2891 HWACCEL_VDPAU(mpeg1), 2892#endif 2893#if CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL 2894 HWACCEL_VIDEOTOOLBOX(mpeg1), 2895#endif 2896 NULL 2897 }, 2898}; 2899 2900const FFCodec ff_mpeg2video_decoder = { 2901 .p.name = "mpeg2video", 2902 .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"), 2903 .p.type = AVMEDIA_TYPE_VIDEO, 2904 .p.id = AV_CODEC_ID_MPEG2VIDEO, 2905 .priv_data_size = sizeof(Mpeg1Context), 2906 .init = mpeg_decode_init, 2907 .close = mpeg_decode_end, 2908 FF_CODEC_DECODE_CB(mpeg_decode_frame), 2909 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | 2910#if FF_API_FLAG_TRUNCATED 2911 AV_CODEC_CAP_TRUNCATED | 2912#endif 2913 AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS, 2914 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | 2915 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, 2916 .flush = flush, 2917 .p.max_lowres = 3, 2918 .p.profiles = NULL_IF_CONFIG_SMALL(ff_mpeg2_video_profiles), 2919 .hw_configs = (const AVCodecHWConfigInternal *const []) { 2920#if CONFIG_MPEG2_DXVA2_HWACCEL 2921 HWACCEL_DXVA2(mpeg2), 2922#endif 2923#if CONFIG_MPEG2_D3D11VA_HWACCEL 2924 HWACCEL_D3D11VA(mpeg2), 2925#endif 2926#if CONFIG_MPEG2_D3D11VA2_HWACCEL 2927 HWACCEL_D3D11VA2(mpeg2), 2928#endif 2929#if CONFIG_MPEG2_NVDEC_HWACCEL 2930 HWACCEL_NVDEC(mpeg2), 2931#endif 2932#if CONFIG_MPEG2_VAAPI_HWACCEL 2933 HWACCEL_VAAPI(mpeg2), 2934#endif 2935#if CONFIG_MPEG2_VDPAU_HWACCEL 2936 HWACCEL_VDPAU(mpeg2), 2937#endif 2938#if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL 2939 HWACCEL_VIDEOTOOLBOX(mpeg2), 2940#endif 2941 NULL 2942 }, 2943}; 2944 2945//legacy decoder 2946const FFCodec ff_mpegvideo_decoder = { 2947 .p.name = "mpegvideo", 2948 .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"), 2949 .p.type = AVMEDIA_TYPE_VIDEO, 2950 .p.id = AV_CODEC_ID_MPEG2VIDEO, 2951 .priv_data_size = sizeof(Mpeg1Context), 2952 .init = mpeg_decode_init, 2953 .close = mpeg_decode_end, 2954 FF_CODEC_DECODE_CB(mpeg_decode_frame), 2955 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | 2956#if FF_API_FLAG_TRUNCATED 2957 AV_CODEC_CAP_TRUNCATED | 2958#endif 2959 AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS, 2960 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | 2961 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, 2962 .flush = flush, 2963 .p.max_lowres = 3, 2964}; 2965 2966typedef struct IPUContext { 2967 MpegEncContext m; 2968 2969 int flags; 2970 DECLARE_ALIGNED(32, int16_t, block)[6][64]; 2971} IPUContext; 2972 2973static int ipu_decode_frame(AVCodecContext *avctx, AVFrame *frame, 2974 int *got_frame, AVPacket *avpkt) 2975{ 2976 IPUContext *s = avctx->priv_data; 2977 MpegEncContext *m = &s->m; 2978 GetBitContext *gb = &m->gb; 2979 int ret; 2980 2981 // Check for minimal intra MB size (considering mb header, luma & chroma dc VLC, ac EOB VLC) 2982 if (avpkt->size*8LL < (avctx->width+15)/16 * ((avctx->height+15)/16) * (2LL + 3*4 + 2*2 + 2*6)) 2983 return AVERROR_INVALIDDATA; 2984 2985 ret = ff_get_buffer(avctx, frame, 0); 2986 if (ret < 0) 2987 return ret; 2988 2989 ret = init_get_bits8(gb, avpkt->data, avpkt->size); 2990 if (ret < 0) 2991 return ret; 2992 2993 s->flags = get_bits(gb, 8); 2994 m->intra_dc_precision = s->flags & 3; 2995 m->q_scale_type = !!(s->flags & 0x40); 2996 m->intra_vlc_format = !!(s->flags & 0x20); 2997 m->alternate_scan = !!(s->flags & 0x10); 2998 2999 if (s->flags & 0x10) { 3000 ff_init_scantable(m->idsp.idct_permutation, &m->inter_scantable, ff_alternate_vertical_scan); 3001 ff_init_scantable(m->idsp.idct_permutation, &m->intra_scantable, ff_alternate_vertical_scan); 3002 } else { 3003 ff_init_scantable(m->idsp.idct_permutation, &m->inter_scantable, ff_zigzag_direct); 3004 ff_init_scantable(m->idsp.idct_permutation, &m->intra_scantable, ff_zigzag_direct); 3005 } 3006 3007 m->last_dc[0] = m->last_dc[1] = m->last_dc[2] = 1 << (7 + (s->flags & 3)); 3008 m->qscale = 1; 3009 3010 for (int y = 0; y < avctx->height; y += 16) { 3011 int intraquant; 3012 3013 for (int x = 0; x < avctx->width; x += 16) { 3014 if (x || y) { 3015 if (!get_bits1(gb)) 3016 return AVERROR_INVALIDDATA; 3017 } 3018 if (get_bits1(gb)) { 3019 intraquant = 0; 3020 } else { 3021 if (!get_bits1(gb)) 3022 return AVERROR_INVALIDDATA; 3023 intraquant = 1; 3024 } 3025 3026 if (s->flags & 4) 3027 skip_bits1(gb); 3028 3029 if (intraquant) 3030 m->qscale = mpeg_get_qscale(m); 3031 3032 memset(s->block, 0, sizeof(s->block)); 3033 3034 for (int n = 0; n < 6; n++) { 3035 if (s->flags & 0x80) { 3036 ret = ff_mpeg1_decode_block_intra(&m->gb, 3037 m->intra_matrix, 3038 m->intra_scantable.permutated, 3039 m->last_dc, s->block[n], 3040 n, m->qscale); 3041 if (ret >= 0) 3042 m->block_last_index[n] = ret; 3043 } else { 3044 ret = mpeg2_decode_block_intra(m, s->block[n], n); 3045 } 3046 3047 if (ret < 0) 3048 return ret; 3049 } 3050 3051 m->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x, 3052 frame->linesize[0], s->block[0]); 3053 m->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8, 3054 frame->linesize[0], s->block[1]); 3055 m->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x, 3056 frame->linesize[0], s->block[2]); 3057 m->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8, 3058 frame->linesize[0], s->block[3]); 3059 m->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1), 3060 frame->linesize[1], s->block[4]); 3061 m->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1), 3062 frame->linesize[2], s->block[5]); 3063 } 3064 } 3065 3066 align_get_bits(gb); 3067 if (get_bits_left(gb) != 32) 3068 return AVERROR_INVALIDDATA; 3069 3070 frame->pict_type = AV_PICTURE_TYPE_I; 3071 frame->key_frame = 1; 3072 *got_frame = 1; 3073 3074 return avpkt->size; 3075} 3076 3077static av_cold int ipu_decode_init(AVCodecContext *avctx) 3078{ 3079 IPUContext *s = avctx->priv_data; 3080 MpegEncContext *m = &s->m; 3081 3082 avctx->pix_fmt = AV_PIX_FMT_YUV420P; 3083 3084 ff_mpv_decode_init(m, avctx); 3085 ff_mpv_idct_init(m); 3086 ff_mpeg12_common_init(m); 3087 ff_mpeg12_init_vlcs(); 3088 3089 for (int i = 0; i < 64; i++) { 3090 int j = m->idsp.idct_permutation[i]; 3091 int v = ff_mpeg1_default_intra_matrix[i]; 3092 m->intra_matrix[j] = v; 3093 m->chroma_intra_matrix[j] = v; 3094 } 3095 3096 for (int i = 0; i < 64; i++) { 3097 int j = m->idsp.idct_permutation[i]; 3098 int v = ff_mpeg1_default_non_intra_matrix[i]; 3099 m->inter_matrix[j] = v; 3100 m->chroma_inter_matrix[j] = v; 3101 } 3102 3103 return 0; 3104} 3105 3106static av_cold int ipu_decode_end(AVCodecContext *avctx) 3107{ 3108 IPUContext *s = avctx->priv_data; 3109 3110 ff_mpv_common_end(&s->m); 3111 3112 return 0; 3113} 3114 3115const FFCodec ff_ipu_decoder = { 3116 .p.name = "ipu", 3117 .p.long_name = NULL_IF_CONFIG_SMALL("IPU Video"), 3118 .p.type = AVMEDIA_TYPE_VIDEO, 3119 .p.id = AV_CODEC_ID_IPU, 3120 .priv_data_size = sizeof(IPUContext), 3121 .init = ipu_decode_init, 3122 FF_CODEC_DECODE_CB(ipu_decode_frame), 3123 .close = ipu_decode_end, 3124 .p.capabilities = AV_CODEC_CAP_DR1, 3125 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, 3126}; 3127