1/* 2 * MPEG-1/2 decoder 3 * Copyright (c) 2000,2001 Fabrice Bellard 4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> 5 * 6 * This file is part of FFmpeg. 7 * 8 * FFmpeg is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU Lesser General Public 10 * License as published by the Free Software Foundation; either 11 * version 2.1 of the License, or (at your option) any later version. 12 * 13 * FFmpeg is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * Lesser General Public License for more details. 17 * 18 * You should have received a copy of the GNU Lesser General Public 19 * License along with FFmpeg; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 21 */ 22 23/** 24 * @file 25 * MPEG-1/2 decoder 26 */ 27 28//#define DEBUG 29#include "internal.h" 30#include "avcodec.h" 31#include "dsputil.h" 32#include "mpegvideo.h" 33 34#include "mpeg12.h" 35#include "mpeg12data.h" 36#include "mpeg12decdata.h" 37#include "bytestream.h" 38#include "vdpau_internal.h" 39#include "xvmc_internal.h" 40 41//#undef NDEBUG 42//#include <assert.h> 43 44 45#define MV_VLC_BITS 9 46#define MBINCR_VLC_BITS 9 47#define MB_PAT_VLC_BITS 9 48#define MB_PTYPE_VLC_BITS 6 49#define MB_BTYPE_VLC_BITS 6 50 51static inline int mpeg1_decode_block_intra(MpegEncContext *s, 52 DCTELEM *block, 53 int n); 54static inline int mpeg1_decode_block_inter(MpegEncContext *s, 55 DCTELEM *block, 56 int n); 57static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n); 58static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 59 DCTELEM *block, 60 int n); 61static inline int mpeg2_decode_block_intra(MpegEncContext *s, 62 DCTELEM *block, 63 int n); 64static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, DCTELEM *block, int n); 65static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, DCTELEM *block, int n); 66static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred); 67static void exchange_uv(MpegEncContext *s); 68 69static const enum PixelFormat pixfmt_xvmc_mpg2_420[] = { 70 PIX_FMT_XVMC_MPEG2_IDCT, 71 PIX_FMT_XVMC_MPEG2_MC, 72 PIX_FMT_NONE}; 73 74uint8_t ff_mpeg12_static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3]; 75 76 77#define INIT_2D_VLC_RL(rl, static_size)\ 78{\ 79 static RL_VLC_ELEM rl_vlc_table[static_size];\ 80 INIT_VLC_STATIC(&rl.vlc, TEX_VLC_BITS, rl.n + 2,\ 81 &rl.table_vlc[0][1], 4, 2,\ 82 &rl.table_vlc[0][0], 4, 2, static_size);\ 83\ 84 rl.rl_vlc[0]= rl_vlc_table;\ 85 init_2d_vlc_rl(&rl);\ 86} 87 88static void init_2d_vlc_rl(RLTable *rl) 89{ 90 int i; 91 92 for(i=0; i<rl->vlc.table_size; i++){ 93 int code= rl->vlc.table[i][0]; 94 int len = rl->vlc.table[i][1]; 95 int level, run; 96 97 if(len==0){ // illegal code 98 run= 65; 99 level= MAX_LEVEL; 100 }else if(len<0){ //more bits needed 101 run= 0; 102 level= code; 103 }else{ 104 if(code==rl->n){ //esc 105 run= 65; 106 level= 0; 107 }else if(code==rl->n+1){ //eob 108 run= 0; 109 level= 127; 110 }else{ 111 run= rl->table_run [code] + 1; 112 level= rl->table_level[code]; 113 } 114 } 115 rl->rl_vlc[0][i].len= len; 116 rl->rl_vlc[0][i].level= level; 117 rl->rl_vlc[0][i].run= run; 118 } 119} 120 121void ff_mpeg12_common_init(MpegEncContext *s) 122{ 123 124 s->y_dc_scale_table= 125 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision]; 126 127} 128 129void ff_mpeg1_clean_buffers(MpegEncContext *s){ 130 s->last_dc[0] = 1 << (7 + s->intra_dc_precision); 131 s->last_dc[1] = s->last_dc[0]; 132 s->last_dc[2] = s->last_dc[0]; 133 memset(s->last_mv, 0, sizeof(s->last_mv)); 134} 135 136 137/******************************************/ 138/* decoding */ 139 140static VLC mv_vlc; 141static VLC mbincr_vlc; 142static VLC mb_ptype_vlc; 143static VLC mb_btype_vlc; 144static VLC mb_pat_vlc; 145 146av_cold void ff_mpeg12_init_vlcs(void) 147{ 148 static int done = 0; 149 150 if (!done) { 151 done = 1; 152 153 INIT_VLC_STATIC(&dc_lum_vlc, DC_VLC_BITS, 12, 154 ff_mpeg12_vlc_dc_lum_bits, 1, 1, 155 ff_mpeg12_vlc_dc_lum_code, 2, 2, 512); 156 INIT_VLC_STATIC(&dc_chroma_vlc, DC_VLC_BITS, 12, 157 ff_mpeg12_vlc_dc_chroma_bits, 1, 1, 158 ff_mpeg12_vlc_dc_chroma_code, 2, 2, 514); 159 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 17, 160 &ff_mpeg12_mbMotionVectorTable[0][1], 2, 1, 161 &ff_mpeg12_mbMotionVectorTable[0][0], 2, 1, 518); 162 INIT_VLC_STATIC(&mbincr_vlc, MBINCR_VLC_BITS, 36, 163 &ff_mpeg12_mbAddrIncrTable[0][1], 2, 1, 164 &ff_mpeg12_mbAddrIncrTable[0][0], 2, 1, 538); 165 INIT_VLC_STATIC(&mb_pat_vlc, MB_PAT_VLC_BITS, 64, 166 &ff_mpeg12_mbPatTable[0][1], 2, 1, 167 &ff_mpeg12_mbPatTable[0][0], 2, 1, 512); 168 169 INIT_VLC_STATIC(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7, 170 &table_mb_ptype[0][1], 2, 1, 171 &table_mb_ptype[0][0], 2, 1, 64); 172 INIT_VLC_STATIC(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11, 173 &table_mb_btype[0][1], 2, 1, 174 &table_mb_btype[0][0], 2, 1, 64); 175 init_rl(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]); 176 init_rl(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]); 177 178 INIT_2D_VLC_RL(ff_rl_mpeg1, 680); 179 INIT_2D_VLC_RL(ff_rl_mpeg2, 674); 180 } 181} 182 183static inline int get_dmv(MpegEncContext *s) 184{ 185 if(get_bits1(&s->gb)) 186 return 1 - (get_bits1(&s->gb) << 1); 187 else 188 return 0; 189} 190 191static inline int get_qscale(MpegEncContext *s) 192{ 193 int qscale = get_bits(&s->gb, 5); 194 if (s->q_scale_type) { 195 return non_linear_qscale[qscale]; 196 } else { 197 return qscale << 1; 198 } 199} 200 201/* motion type (for MPEG-2) */ 202#define MT_FIELD 1 203#define MT_FRAME 2 204#define MT_16X8 2 205#define MT_DMV 3 206 207static int mpeg_decode_mb(MpegEncContext *s, 208 DCTELEM block[12][64]) 209{ 210 int i, j, k, cbp, val, mb_type, motion_type; 211 const int mb_block_count = 4 + (1<< s->chroma_format); 212 213 dprintf(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y); 214 215 assert(s->mb_skipped==0); 216 217 if (s->mb_skip_run-- != 0) { 218 if (s->pict_type == FF_P_TYPE) { 219 s->mb_skipped = 1; 220 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16; 221 } else { 222 int mb_type; 223 224 if(s->mb_x) 225 mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]; 226 else 227 mb_type= s->current_picture.mb_type[ s->mb_width + (s->mb_y-1)*s->mb_stride - 1]; // FIXME not sure if this is allowed in MPEG at all 228 if(IS_INTRA(mb_type)) 229 return -1; 230 231 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= 232 mb_type | MB_TYPE_SKIP; 233// assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8)); 234 235 if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0) 236 s->mb_skipped = 1; 237 } 238 239 return 0; 240 } 241 242 switch(s->pict_type) { 243 default: 244 case FF_I_TYPE: 245 if (get_bits1(&s->gb) == 0) { 246 if (get_bits1(&s->gb) == 0){ 247 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y); 248 return -1; 249 } 250 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA; 251 } else { 252 mb_type = MB_TYPE_INTRA; 253 } 254 break; 255 case FF_P_TYPE: 256 mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1); 257 if (mb_type < 0){ 258 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y); 259 return -1; 260 } 261 mb_type = ptype2mb_type[ mb_type ]; 262 break; 263 case FF_B_TYPE: 264 mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1); 265 if (mb_type < 0){ 266 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y); 267 return -1; 268 } 269 mb_type = btype2mb_type[ mb_type ]; 270 break; 271 } 272 dprintf(s->avctx, "mb_type=%x\n", mb_type); 273// motion_type = 0; /* avoid warning */ 274 if (IS_INTRA(mb_type)) { 275 s->dsp.clear_blocks(s->block[0]); 276 277 if(!s->chroma_y_shift){ 278 s->dsp.clear_blocks(s->block[6]); 279 } 280 281 /* compute DCT type */ 282 if (s->picture_structure == PICT_FRAME && //FIXME add an interlaced_dct coded var? 283 !s->frame_pred_frame_dct) { 284 s->interlaced_dct = get_bits1(&s->gb); 285 } 286 287 if (IS_QUANT(mb_type)) 288 s->qscale = get_qscale(s); 289 290 if (s->concealment_motion_vectors) { 291 /* just parse them */ 292 if (s->picture_structure != PICT_FRAME) 293 skip_bits1(&s->gb); /* field select */ 294 295 s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] = 296 mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]); 297 s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] = 298 mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]); 299 300 skip_bits1(&s->gb); /* marker */ 301 }else 302 memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */ 303 s->mb_intra = 1; 304 //if 1, we memcpy blocks in xvmcvideo 305 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1){ 306 ff_xvmc_pack_pblocks(s,-1);//inter are always full blocks 307 if(s->swap_uv){ 308 exchange_uv(s); 309 } 310 } 311 312 if (s->codec_id == CODEC_ID_MPEG2VIDEO) { 313 if(s->flags2 & CODEC_FLAG2_FAST){ 314 for(i=0;i<6;i++) { 315 mpeg2_fast_decode_block_intra(s, *s->pblocks[i], i); 316 } 317 }else{ 318 for(i=0;i<mb_block_count;i++) { 319 if (mpeg2_decode_block_intra(s, *s->pblocks[i], i) < 0) 320 return -1; 321 } 322 } 323 } else { 324 for(i=0;i<6;i++) { 325 if (mpeg1_decode_block_intra(s, *s->pblocks[i], i) < 0) 326 return -1; 327 } 328 } 329 } else { 330 if (mb_type & MB_TYPE_ZERO_MV){ 331 assert(mb_type & MB_TYPE_CBP); 332 333 s->mv_dir = MV_DIR_FORWARD; 334 if(s->picture_structure == PICT_FRAME){ 335 if(!s->frame_pred_frame_dct) 336 s->interlaced_dct = get_bits1(&s->gb); 337 s->mv_type = MV_TYPE_16X16; 338 }else{ 339 s->mv_type = MV_TYPE_FIELD; 340 mb_type |= MB_TYPE_INTERLACED; 341 s->field_select[0][0]= s->picture_structure - 1; 342 } 343 344 if (IS_QUANT(mb_type)) 345 s->qscale = get_qscale(s); 346 347 s->last_mv[0][0][0] = 0; 348 s->last_mv[0][0][1] = 0; 349 s->last_mv[0][1][0] = 0; 350 s->last_mv[0][1][1] = 0; 351 s->mv[0][0][0] = 0; 352 s->mv[0][0][1] = 0; 353 }else{ 354 assert(mb_type & MB_TYPE_L0L1); 355//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED 356 /* get additional motion vector type */ 357 if (s->frame_pred_frame_dct) 358 motion_type = MT_FRAME; 359 else{ 360 motion_type = get_bits(&s->gb, 2); 361 if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type)) 362 s->interlaced_dct = get_bits1(&s->gb); 363 } 364 365 if (IS_QUANT(mb_type)) 366 s->qscale = get_qscale(s); 367 368 /* motion vectors */ 369 s->mv_dir= (mb_type>>13)&3; 370 dprintf(s->avctx, "motion_type=%d\n", motion_type); 371 switch(motion_type) { 372 case MT_FRAME: /* or MT_16X8 */ 373 if (s->picture_structure == PICT_FRAME) { 374 mb_type |= MB_TYPE_16x16; 375 s->mv_type = MV_TYPE_16X16; 376 for(i=0;i<2;i++) { 377 if (USES_LIST(mb_type, i)) { 378 /* MT_FRAME */ 379 s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] = 380 mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]); 381 s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] = 382 mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]); 383 /* full_pel: only for MPEG-1 */ 384 if (s->full_pel[i]){ 385 s->mv[i][0][0] <<= 1; 386 s->mv[i][0][1] <<= 1; 387 } 388 } 389 } 390 } else { 391 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; 392 s->mv_type = MV_TYPE_16X8; 393 for(i=0;i<2;i++) { 394 if (USES_LIST(mb_type, i)) { 395 /* MT_16X8 */ 396 for(j=0;j<2;j++) { 397 s->field_select[i][j] = get_bits1(&s->gb); 398 for(k=0;k<2;k++) { 399 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], 400 s->last_mv[i][j][k]); 401 s->last_mv[i][j][k] = val; 402 s->mv[i][j][k] = val; 403 } 404 } 405 } 406 } 407 } 408 break; 409 case MT_FIELD: 410 s->mv_type = MV_TYPE_FIELD; 411 if (s->picture_structure == PICT_FRAME) { 412 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; 413 for(i=0;i<2;i++) { 414 if (USES_LIST(mb_type, i)) { 415 for(j=0;j<2;j++) { 416 s->field_select[i][j] = get_bits1(&s->gb); 417 val = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 418 s->last_mv[i][j][0]); 419 s->last_mv[i][j][0] = val; 420 s->mv[i][j][0] = val; 421 dprintf(s->avctx, "fmx=%d\n", val); 422 val = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 423 s->last_mv[i][j][1] >> 1); 424 s->last_mv[i][j][1] = val << 1; 425 s->mv[i][j][1] = val; 426 dprintf(s->avctx, "fmy=%d\n", val); 427 } 428 } 429 } 430 } else { 431 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED; 432 for(i=0;i<2;i++) { 433 if (USES_LIST(mb_type, i)) { 434 s->field_select[i][0] = get_bits1(&s->gb); 435 for(k=0;k<2;k++) { 436 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], 437 s->last_mv[i][0][k]); 438 s->last_mv[i][0][k] = val; 439 s->last_mv[i][1][k] = val; 440 s->mv[i][0][k] = val; 441 } 442 } 443 } 444 } 445 break; 446 case MT_DMV: 447 s->mv_type = MV_TYPE_DMV; 448 for(i=0;i<2;i++) { 449 if (USES_LIST(mb_type, i)) { 450 int dmx, dmy, mx, my, m; 451 const int my_shift= s->picture_structure == PICT_FRAME; 452 453 mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 454 s->last_mv[i][0][0]); 455 s->last_mv[i][0][0] = mx; 456 s->last_mv[i][1][0] = mx; 457 dmx = get_dmv(s); 458 my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 459 s->last_mv[i][0][1] >> my_shift); 460 dmy = get_dmv(s); 461 462 463 s->last_mv[i][0][1] = my<<my_shift; 464 s->last_mv[i][1][1] = my<<my_shift; 465 466 s->mv[i][0][0] = mx; 467 s->mv[i][0][1] = my; 468 s->mv[i][1][0] = mx;//not used 469 s->mv[i][1][1] = my;//not used 470 471 if (s->picture_structure == PICT_FRAME) { 472 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED; 473 474 //m = 1 + 2 * s->top_field_first; 475 m = s->top_field_first ? 1 : 3; 476 477 /* top -> top pred */ 478 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx; 479 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1; 480 m = 4 - m; 481 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx; 482 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1; 483 } else { 484 mb_type |= MB_TYPE_16x16; 485 486 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx; 487 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy; 488 if(s->picture_structure == PICT_TOP_FIELD) 489 s->mv[i][2][1]--; 490 else 491 s->mv[i][2][1]++; 492 } 493 } 494 } 495 break; 496 default: 497 av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y); 498 return -1; 499 } 500 } 501 502 s->mb_intra = 0; 503 if (HAS_CBP(mb_type)) { 504 s->dsp.clear_blocks(s->block[0]); 505 506 cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1); 507 if(mb_block_count > 6){ 508 cbp<<= mb_block_count-6; 509 cbp |= get_bits(&s->gb, mb_block_count-6); 510 s->dsp.clear_blocks(s->block[6]); 511 } 512 if (cbp <= 0){ 513 av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y); 514 return -1; 515 } 516 517 //if 1, we memcpy blocks in xvmcvideo 518 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1){ 519 ff_xvmc_pack_pblocks(s,cbp); 520 if(s->swap_uv){ 521 exchange_uv(s); 522 } 523 } 524 525 if (s->codec_id == CODEC_ID_MPEG2VIDEO) { 526 if(s->flags2 & CODEC_FLAG2_FAST){ 527 for(i=0;i<6;i++) { 528 if(cbp & 32) { 529 mpeg2_fast_decode_block_non_intra(s, *s->pblocks[i], i); 530 } else { 531 s->block_last_index[i] = -1; 532 } 533 cbp+=cbp; 534 } 535 }else{ 536 cbp<<= 12-mb_block_count; 537 538 for(i=0;i<mb_block_count;i++) { 539 if ( cbp & (1<<11) ) { 540 if (mpeg2_decode_block_non_intra(s, *s->pblocks[i], i) < 0) 541 return -1; 542 } else { 543 s->block_last_index[i] = -1; 544 } 545 cbp+=cbp; 546 } 547 } 548 } else { 549 if(s->flags2 & CODEC_FLAG2_FAST){ 550 for(i=0;i<6;i++) { 551 if (cbp & 32) { 552 mpeg1_fast_decode_block_inter(s, *s->pblocks[i], i); 553 } else { 554 s->block_last_index[i] = -1; 555 } 556 cbp+=cbp; 557 } 558 }else{ 559 for(i=0;i<6;i++) { 560 if (cbp & 32) { 561 if (mpeg1_decode_block_inter(s, *s->pblocks[i], i) < 0) 562 return -1; 563 } else { 564 s->block_last_index[i] = -1; 565 } 566 cbp+=cbp; 567 } 568 } 569 } 570 }else{ 571 for(i=0;i<12;i++) 572 s->block_last_index[i] = -1; 573 } 574 } 575 576 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type; 577 578 return 0; 579} 580 581/* as H.263, but only 17 codes */ 582static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred) 583{ 584 int code, sign, val, l, shift; 585 586 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); 587 if (code == 0) { 588 return pred; 589 } 590 if (code < 0) { 591 return 0xffff; 592 } 593 594 sign = get_bits1(&s->gb); 595 shift = fcode - 1; 596 val = code; 597 if (shift) { 598 val = (val - 1) << shift; 599 val |= get_bits(&s->gb, shift); 600 val++; 601 } 602 if (sign) 603 val = -val; 604 val += pred; 605 606 /* modulo decoding */ 607 l= INT_BIT - 5 - shift; 608 val = (val<<l)>>l; 609 return val; 610} 611 612static inline int mpeg1_decode_block_intra(MpegEncContext *s, 613 DCTELEM *block, 614 int n) 615{ 616 int level, dc, diff, i, j, run; 617 int component; 618 RLTable *rl = &ff_rl_mpeg1; 619 uint8_t * const scantable= s->intra_scantable.permutated; 620 const uint16_t *quant_matrix= s->intra_matrix; 621 const int qscale= s->qscale; 622 623 /* DC coefficient */ 624 component = (n <= 3 ? 0 : n - 4 + 1); 625 diff = decode_dc(&s->gb, component); 626 if (diff >= 0xffff) 627 return -1; 628 dc = s->last_dc[component]; 629 dc += diff; 630 s->last_dc[component] = dc; 631 block[0] = dc*quant_matrix[0]; 632 dprintf(s->avctx, "dc=%d diff=%d\n", dc, diff); 633 i = 0; 634 { 635 OPEN_READER(re, &s->gb); 636 /* now quantify & encode AC coefficients */ 637 for(;;) { 638 UPDATE_CACHE(re, &s->gb); 639 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); 640 641 if(level == 127){ 642 break; 643 } else if(level != 0) { 644 i += run; 645 j = scantable[i]; 646 level= (level*qscale*quant_matrix[j])>>4; 647 level= (level-1)|1; 648 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 649 LAST_SKIP_BITS(re, &s->gb, 1); 650 } else { 651 /* escape */ 652 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); 653 UPDATE_CACHE(re, &s->gb); 654 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8); 655 if (level == -128) { 656 level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8); 657 } else if (level == 0) { 658 level = SHOW_UBITS(re, &s->gb, 8) ; LAST_SKIP_BITS(re, &s->gb, 8); 659 } 660 i += run; 661 j = scantable[i]; 662 if(level<0){ 663 level= -level; 664 level= (level*qscale*quant_matrix[j])>>4; 665 level= (level-1)|1; 666 level= -level; 667 }else{ 668 level= (level*qscale*quant_matrix[j])>>4; 669 level= (level-1)|1; 670 } 671 } 672 if (i > 63){ 673 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); 674 return -1; 675 } 676 677 block[j] = level; 678 } 679 CLOSE_READER(re, &s->gb); 680 } 681 s->block_last_index[n] = i; 682 return 0; 683} 684 685int ff_mpeg1_decode_block_intra(MpegEncContext *s, 686 DCTELEM *block, 687 int n) 688{ 689 return mpeg1_decode_block_intra(s, block, n); 690} 691 692static inline int mpeg1_decode_block_inter(MpegEncContext *s, 693 DCTELEM *block, 694 int n) 695{ 696 int level, i, j, run; 697 RLTable *rl = &ff_rl_mpeg1; 698 uint8_t * const scantable= s->intra_scantable.permutated; 699 const uint16_t *quant_matrix= s->inter_matrix; 700 const int qscale= s->qscale; 701 702 { 703 OPEN_READER(re, &s->gb); 704 i = -1; 705 // special case for first coefficient, no need to add second VLC table 706 UPDATE_CACHE(re, &s->gb); 707 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) { 708 level= (3*qscale*quant_matrix[0])>>5; 709 level= (level-1)|1; 710 if(GET_CACHE(re, &s->gb)&0x40000000) 711 level= -level; 712 block[0] = level; 713 i++; 714 SKIP_BITS(re, &s->gb, 2); 715 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) 716 goto end; 717 } 718#if MIN_CACHE_BITS < 19 719 UPDATE_CACHE(re, &s->gb); 720#endif 721 /* now quantify & encode AC coefficients */ 722 for(;;) { 723 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); 724 725 if(level != 0) { 726 i += run; 727 j = scantable[i]; 728 level= ((level*2+1)*qscale*quant_matrix[j])>>5; 729 level= (level-1)|1; 730 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 731 SKIP_BITS(re, &s->gb, 1); 732 } else { 733 /* escape */ 734 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); 735 UPDATE_CACHE(re, &s->gb); 736 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8); 737 if (level == -128) { 738 level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8); 739 } else if (level == 0) { 740 level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8); 741 } 742 i += run; 743 j = scantable[i]; 744 if(level<0){ 745 level= -level; 746 level= ((level*2+1)*qscale*quant_matrix[j])>>5; 747 level= (level-1)|1; 748 level= -level; 749 }else{ 750 level= ((level*2+1)*qscale*quant_matrix[j])>>5; 751 level= (level-1)|1; 752 } 753 } 754 if (i > 63){ 755 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); 756 return -1; 757 } 758 759 block[j] = level; 760#if MIN_CACHE_BITS < 19 761 UPDATE_CACHE(re, &s->gb); 762#endif 763 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) 764 break; 765#if MIN_CACHE_BITS >= 19 766 UPDATE_CACHE(re, &s->gb); 767#endif 768 } 769end: 770 LAST_SKIP_BITS(re, &s->gb, 2); 771 CLOSE_READER(re, &s->gb); 772 } 773 s->block_last_index[n] = i; 774 return 0; 775} 776 777static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n) 778{ 779 int level, i, j, run; 780 RLTable *rl = &ff_rl_mpeg1; 781 uint8_t * const scantable= s->intra_scantable.permutated; 782 const int qscale= s->qscale; 783 784 { 785 OPEN_READER(re, &s->gb); 786 i = -1; 787 // special case for first coefficient, no need to add second VLC table 788 UPDATE_CACHE(re, &s->gb); 789 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) { 790 level= (3*qscale)>>1; 791 level= (level-1)|1; 792 if(GET_CACHE(re, &s->gb)&0x40000000) 793 level= -level; 794 block[0] = level; 795 i++; 796 SKIP_BITS(re, &s->gb, 2); 797 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) 798 goto end; 799 } 800#if MIN_CACHE_BITS < 19 801 UPDATE_CACHE(re, &s->gb); 802#endif 803 804 /* now quantify & encode AC coefficients */ 805 for(;;) { 806 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); 807 808 if(level != 0) { 809 i += run; 810 j = scantable[i]; 811 level= ((level*2+1)*qscale)>>1; 812 level= (level-1)|1; 813 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 814 SKIP_BITS(re, &s->gb, 1); 815 } else { 816 /* escape */ 817 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); 818 UPDATE_CACHE(re, &s->gb); 819 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8); 820 if (level == -128) { 821 level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8); 822 } else if (level == 0) { 823 level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8); 824 } 825 i += run; 826 j = scantable[i]; 827 if(level<0){ 828 level= -level; 829 level= ((level*2+1)*qscale)>>1; 830 level= (level-1)|1; 831 level= -level; 832 }else{ 833 level= ((level*2+1)*qscale)>>1; 834 level= (level-1)|1; 835 } 836 } 837 838 block[j] = level; 839#if MIN_CACHE_BITS < 19 840 UPDATE_CACHE(re, &s->gb); 841#endif 842 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) 843 break; 844#if MIN_CACHE_BITS >= 19 845 UPDATE_CACHE(re, &s->gb); 846#endif 847 } 848end: 849 LAST_SKIP_BITS(re, &s->gb, 2); 850 CLOSE_READER(re, &s->gb); 851 } 852 s->block_last_index[n] = i; 853 return 0; 854} 855 856 857static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 858 DCTELEM *block, 859 int n) 860{ 861 int level, i, j, run; 862 RLTable *rl = &ff_rl_mpeg1; 863 uint8_t * const scantable= s->intra_scantable.permutated; 864 const uint16_t *quant_matrix; 865 const int qscale= s->qscale; 866 int mismatch; 867 868 mismatch = 1; 869 870 { 871 OPEN_READER(re, &s->gb); 872 i = -1; 873 if (n < 4) 874 quant_matrix = s->inter_matrix; 875 else 876 quant_matrix = s->chroma_inter_matrix; 877 878 // special case for first coefficient, no need to add second VLC table 879 UPDATE_CACHE(re, &s->gb); 880 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) { 881 level= (3*qscale*quant_matrix[0])>>5; 882 if(GET_CACHE(re, &s->gb)&0x40000000) 883 level= -level; 884 block[0] = level; 885 mismatch ^= level; 886 i++; 887 SKIP_BITS(re, &s->gb, 2); 888 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) 889 goto end; 890 } 891#if MIN_CACHE_BITS < 19 892 UPDATE_CACHE(re, &s->gb); 893#endif 894 895 /* now quantify & encode AC coefficients */ 896 for(;;) { 897 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); 898 899 if(level != 0) { 900 i += run; 901 j = scantable[i]; 902 level= ((level*2+1)*qscale*quant_matrix[j])>>5; 903 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 904 SKIP_BITS(re, &s->gb, 1); 905 } else { 906 /* escape */ 907 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); 908 UPDATE_CACHE(re, &s->gb); 909 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12); 910 911 i += run; 912 j = scantable[i]; 913 if(level<0){ 914 level= ((-level*2+1)*qscale*quant_matrix[j])>>5; 915 level= -level; 916 }else{ 917 level= ((level*2+1)*qscale*quant_matrix[j])>>5; 918 } 919 } 920 if (i > 63){ 921 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); 922 return -1; 923 } 924 925 mismatch ^= level; 926 block[j] = level; 927#if MIN_CACHE_BITS < 19 928 UPDATE_CACHE(re, &s->gb); 929#endif 930 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) 931 break; 932#if MIN_CACHE_BITS >= 19 933 UPDATE_CACHE(re, &s->gb); 934#endif 935 } 936end: 937 LAST_SKIP_BITS(re, &s->gb, 2); 938 CLOSE_READER(re, &s->gb); 939 } 940 block[63] ^= (mismatch & 1); 941 942 s->block_last_index[n] = i; 943 return 0; 944} 945 946static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, 947 DCTELEM *block, 948 int n) 949{ 950 int level, i, j, run; 951 RLTable *rl = &ff_rl_mpeg1; 952 uint8_t * const scantable= s->intra_scantable.permutated; 953 const int qscale= s->qscale; 954 OPEN_READER(re, &s->gb); 955 i = -1; 956 957 // special case for first coefficient, no need to add second VLC table 958 UPDATE_CACHE(re, &s->gb); 959 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) { 960 level= (3*qscale)>>1; 961 if(GET_CACHE(re, &s->gb)&0x40000000) 962 level= -level; 963 block[0] = level; 964 i++; 965 SKIP_BITS(re, &s->gb, 2); 966 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) 967 goto end; 968 } 969#if MIN_CACHE_BITS < 19 970 UPDATE_CACHE(re, &s->gb); 971#endif 972 973 /* now quantify & encode AC coefficients */ 974 for(;;) { 975 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); 976 977 if(level != 0) { 978 i += run; 979 j = scantable[i]; 980 level= ((level*2+1)*qscale)>>1; 981 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 982 SKIP_BITS(re, &s->gb, 1); 983 } else { 984 /* escape */ 985 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); 986 UPDATE_CACHE(re, &s->gb); 987 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12); 988 989 i += run; 990 j = scantable[i]; 991 if(level<0){ 992 level= ((-level*2+1)*qscale)>>1; 993 level= -level; 994 }else{ 995 level= ((level*2+1)*qscale)>>1; 996 } 997 } 998 999 block[j] = level; 1000#if MIN_CACHE_BITS < 19 1001 UPDATE_CACHE(re, &s->gb); 1002#endif 1003 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) 1004 break; 1005#if MIN_CACHE_BITS >=19 1006 UPDATE_CACHE(re, &s->gb); 1007#endif 1008 } 1009end: 1010 LAST_SKIP_BITS(re, &s->gb, 2); 1011 CLOSE_READER(re, &s->gb); 1012 s->block_last_index[n] = i; 1013 return 0; 1014} 1015 1016 1017static inline int mpeg2_decode_block_intra(MpegEncContext *s, 1018 DCTELEM *block, 1019 int n) 1020{ 1021 int level, dc, diff, i, j, run; 1022 int component; 1023 RLTable *rl; 1024 uint8_t * const scantable= s->intra_scantable.permutated; 1025 const uint16_t *quant_matrix; 1026 const int qscale= s->qscale; 1027 int mismatch; 1028 1029 /* DC coefficient */ 1030 if (n < 4){ 1031 quant_matrix = s->intra_matrix; 1032 component = 0; 1033 }else{ 1034 quant_matrix = s->chroma_intra_matrix; 1035 component = (n&1) + 1; 1036 } 1037 diff = decode_dc(&s->gb, component); 1038 if (diff >= 0xffff) 1039 return -1; 1040 dc = s->last_dc[component]; 1041 dc += diff; 1042 s->last_dc[component] = dc; 1043 block[0] = dc << (3 - s->intra_dc_precision); 1044 dprintf(s->avctx, "dc=%d\n", block[0]); 1045 mismatch = block[0] ^ 1; 1046 i = 0; 1047 if (s->intra_vlc_format) 1048 rl = &ff_rl_mpeg2; 1049 else 1050 rl = &ff_rl_mpeg1; 1051 1052 { 1053 OPEN_READER(re, &s->gb); 1054 /* now quantify & encode AC coefficients */ 1055 for(;;) { 1056 UPDATE_CACHE(re, &s->gb); 1057 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); 1058 1059 if(level == 127){ 1060 break; 1061 } else if(level != 0) { 1062 i += run; 1063 j = scantable[i]; 1064 level= (level*qscale*quant_matrix[j])>>4; 1065 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 1066 LAST_SKIP_BITS(re, &s->gb, 1); 1067 } else { 1068 /* escape */ 1069 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); 1070 UPDATE_CACHE(re, &s->gb); 1071 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12); 1072 i += run; 1073 j = scantable[i]; 1074 if(level<0){ 1075 level= (-level*qscale*quant_matrix[j])>>4; 1076 level= -level; 1077 }else{ 1078 level= (level*qscale*quant_matrix[j])>>4; 1079 } 1080 } 1081 if (i > 63){ 1082 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); 1083 return -1; 1084 } 1085 1086 mismatch^= level; 1087 block[j] = level; 1088 } 1089 CLOSE_READER(re, &s->gb); 1090 } 1091 block[63]^= mismatch&1; 1092 1093 s->block_last_index[n] = i; 1094 return 0; 1095} 1096 1097static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, 1098 DCTELEM *block, 1099 int n) 1100{ 1101 int level, dc, diff, j, run; 1102 int component; 1103 RLTable *rl; 1104 uint8_t * scantable= s->intra_scantable.permutated; 1105 const uint16_t *quant_matrix; 1106 const int qscale= s->qscale; 1107 1108 /* DC coefficient */ 1109 if (n < 4){ 1110 quant_matrix = s->intra_matrix; 1111 component = 0; 1112 }else{ 1113 quant_matrix = s->chroma_intra_matrix; 1114 component = (n&1) + 1; 1115 } 1116 diff = decode_dc(&s->gb, component); 1117 if (diff >= 0xffff) 1118 return -1; 1119 dc = s->last_dc[component]; 1120 dc += diff; 1121 s->last_dc[component] = dc; 1122 block[0] = dc << (3 - s->intra_dc_precision); 1123 if (s->intra_vlc_format) 1124 rl = &ff_rl_mpeg2; 1125 else 1126 rl = &ff_rl_mpeg1; 1127 1128 { 1129 OPEN_READER(re, &s->gb); 1130 /* now quantify & encode AC coefficients */ 1131 for(;;) { 1132 UPDATE_CACHE(re, &s->gb); 1133 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); 1134 1135 if(level == 127){ 1136 break; 1137 } else if(level != 0) { 1138 scantable += run; 1139 j = *scantable; 1140 level= (level*qscale*quant_matrix[j])>>4; 1141 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 1142 LAST_SKIP_BITS(re, &s->gb, 1); 1143 } else { 1144 /* escape */ 1145 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); 1146 UPDATE_CACHE(re, &s->gb); 1147 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12); 1148 scantable += run; 1149 j = *scantable; 1150 if(level<0){ 1151 level= (-level*qscale*quant_matrix[j])>>4; 1152 level= -level; 1153 }else{ 1154 level= (level*qscale*quant_matrix[j])>>4; 1155 } 1156 } 1157 1158 block[j] = level; 1159 } 1160 CLOSE_READER(re, &s->gb); 1161 } 1162 1163 s->block_last_index[n] = scantable - s->intra_scantable.permutated; 1164 return 0; 1165} 1166 1167typedef struct Mpeg1Context { 1168 MpegEncContext mpeg_enc_ctx; 1169 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */ 1170 int repeat_field; /* true if we must repeat the field */ 1171 AVPanScan pan_scan; /** some temporary storage for the panscan */ 1172 int slice_count; 1173 int swap_uv;//indicate VCR2 1174 int save_aspect_info; 1175 int save_width, save_height, save_progressive_seq; 1176 AVRational frame_rate_ext; ///< MPEG-2 specific framerate modificator 1177 int sync; ///< Did we reach a sync point like a GOP/SEQ/KEYFrame? 1178} Mpeg1Context; 1179 1180static av_cold int mpeg_decode_init(AVCodecContext *avctx) 1181{ 1182 Mpeg1Context *s = avctx->priv_data; 1183 MpegEncContext *s2 = &s->mpeg_enc_ctx; 1184 int i; 1185 1186 /* we need some permutation to store matrices, 1187 * until MPV_common_init() sets the real permutation. */ 1188 for(i=0;i<64;i++) 1189 s2->dsp.idct_permutation[i]=i; 1190 1191 MPV_decode_defaults(s2); 1192 1193 s->mpeg_enc_ctx.avctx= avctx; 1194 s->mpeg_enc_ctx.flags= avctx->flags; 1195 s->mpeg_enc_ctx.flags2= avctx->flags2; 1196 ff_mpeg12_common_init(&s->mpeg_enc_ctx); 1197 ff_mpeg12_init_vlcs(); 1198 1199 s->mpeg_enc_ctx_allocated = 0; 1200 s->mpeg_enc_ctx.picture_number = 0; 1201 s->repeat_field = 0; 1202 s->mpeg_enc_ctx.codec_id= avctx->codec->id; 1203 avctx->color_range= AVCOL_RANGE_MPEG; 1204 if (avctx->codec->id == CODEC_ID_MPEG1VIDEO) 1205 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER; 1206 else 1207 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; 1208 return 0; 1209} 1210 1211static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm, 1212 const uint8_t *new_perm){ 1213 uint16_t temp_matrix[64]; 1214 int i; 1215 1216 memcpy(temp_matrix,matrix,64*sizeof(uint16_t)); 1217 1218 for(i=0;i<64;i++){ 1219 matrix[new_perm[i]] = temp_matrix[old_perm[i]]; 1220 } 1221} 1222 1223static enum PixelFormat mpeg_get_pixelformat(AVCodecContext *avctx){ 1224 Mpeg1Context *s1 = avctx->priv_data; 1225 MpegEncContext *s = &s1->mpeg_enc_ctx; 1226 1227 if(avctx->xvmc_acceleration) 1228 return avctx->get_format(avctx,pixfmt_xvmc_mpg2_420); 1229 else if(avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){ 1230 if(avctx->codec_id == CODEC_ID_MPEG1VIDEO) 1231 return PIX_FMT_VDPAU_MPEG1; 1232 else 1233 return PIX_FMT_VDPAU_MPEG2; 1234 }else{ 1235 if(s->chroma_format < 2) 1236 return avctx->get_format(avctx,ff_hwaccel_pixfmt_list_420); 1237 else if(s->chroma_format == 2) 1238 return PIX_FMT_YUV422P; 1239 else 1240 return PIX_FMT_YUV444P; 1241 } 1242} 1243 1244/* Call this function when we know all parameters. 1245 * It may be called in different places for MPEG-1 and MPEG-2. */ 1246static int mpeg_decode_postinit(AVCodecContext *avctx){ 1247 Mpeg1Context *s1 = avctx->priv_data; 1248 MpegEncContext *s = &s1->mpeg_enc_ctx; 1249 uint8_t old_permutation[64]; 1250 1251 if ( 1252 (s1->mpeg_enc_ctx_allocated == 0)|| 1253 avctx->coded_width != s->width || 1254 avctx->coded_height != s->height|| 1255 s1->save_width != s->width || 1256 s1->save_height != s->height || 1257 s1->save_aspect_info != s->aspect_ratio_info|| 1258 s1->save_progressive_seq != s->progressive_sequence || 1259 0) 1260 { 1261 1262 if (s1->mpeg_enc_ctx_allocated) { 1263 ParseContext pc= s->parse_context; 1264 s->parse_context.buffer=0; 1265 MPV_common_end(s); 1266 s->parse_context= pc; 1267 } 1268 1269 if( (s->width == 0 )||(s->height == 0)) 1270 return -2; 1271 1272 avcodec_set_dimensions(avctx, s->width, s->height); 1273 avctx->bit_rate = s->bit_rate; 1274 s1->save_aspect_info = s->aspect_ratio_info; 1275 s1->save_width = s->width; 1276 s1->save_height = s->height; 1277 s1->save_progressive_seq = s->progressive_sequence; 1278 1279 /* low_delay may be forced, in this case we will have B-frames 1280 * that behave like P-frames. */ 1281 avctx->has_b_frames = !(s->low_delay); 1282 1283 assert((avctx->sub_id==1) == (avctx->codec_id==CODEC_ID_MPEG1VIDEO)); 1284 if(avctx->codec_id==CODEC_ID_MPEG1VIDEO){ 1285 //MPEG-1 fps 1286 avctx->time_base.den= ff_frame_rate_tab[s->frame_rate_index].num; 1287 avctx->time_base.num= ff_frame_rate_tab[s->frame_rate_index].den; 1288 //MPEG-1 aspect 1289 avctx->sample_aspect_ratio= av_d2q( 1290 1.0/ff_mpeg1_aspect[s->aspect_ratio_info], 255); 1291 avctx->ticks_per_frame=1; 1292 }else{//MPEG-2 1293 //MPEG-2 fps 1294 av_reduce( 1295 &s->avctx->time_base.den, 1296 &s->avctx->time_base.num, 1297 ff_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num*2, 1298 ff_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den, 1299 1<<30); 1300 avctx->ticks_per_frame=2; 1301 //MPEG-2 aspect 1302 if(s->aspect_ratio_info > 1){ 1303 //we ignore the spec here as reality does not match the spec, see for example 1304 // res_change_ffmpeg_aspect.ts and sequence-display-aspect.mpg 1305 if( (s1->pan_scan.width == 0 )||(s1->pan_scan.height == 0) || 1){ 1306 s->avctx->sample_aspect_ratio= 1307 av_div_q( 1308 ff_mpeg2_aspect[s->aspect_ratio_info], 1309 (AVRational){s->width, s->height} 1310 ); 1311 }else{ 1312 s->avctx->sample_aspect_ratio= 1313 av_div_q( 1314 ff_mpeg2_aspect[s->aspect_ratio_info], 1315 (AVRational){s1->pan_scan.width, s1->pan_scan.height} 1316 ); 1317 } 1318 }else{ 1319 s->avctx->sample_aspect_ratio= 1320 ff_mpeg2_aspect[s->aspect_ratio_info]; 1321 } 1322 }//MPEG-2 1323 1324 avctx->pix_fmt = mpeg_get_pixelformat(avctx); 1325 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt); 1326 //until then pix_fmt may be changed right after codec init 1327 if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT || 1328 avctx->hwaccel || 1329 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU ) 1330 if( avctx->idct_algo == FF_IDCT_AUTO ) 1331 avctx->idct_algo = FF_IDCT_SIMPLE; 1332 1333 /* Quantization matrices may need reordering 1334 * if DCT permutation is changed. */ 1335 memcpy(old_permutation,s->dsp.idct_permutation,64*sizeof(uint8_t)); 1336 1337 if (MPV_common_init(s) < 0) 1338 return -2; 1339 1340 quant_matrix_rebuild(s->intra_matrix, old_permutation,s->dsp.idct_permutation); 1341 quant_matrix_rebuild(s->inter_matrix, old_permutation,s->dsp.idct_permutation); 1342 quant_matrix_rebuild(s->chroma_intra_matrix,old_permutation,s->dsp.idct_permutation); 1343 quant_matrix_rebuild(s->chroma_inter_matrix,old_permutation,s->dsp.idct_permutation); 1344 1345 s1->mpeg_enc_ctx_allocated = 1; 1346 } 1347 return 0; 1348} 1349 1350static int mpeg1_decode_picture(AVCodecContext *avctx, 1351 const uint8_t *buf, int buf_size) 1352{ 1353 Mpeg1Context *s1 = avctx->priv_data; 1354 MpegEncContext *s = &s1->mpeg_enc_ctx; 1355 int ref, f_code, vbv_delay; 1356 1357 init_get_bits(&s->gb, buf, buf_size*8); 1358 1359 ref = get_bits(&s->gb, 10); /* temporal ref */ 1360 s->pict_type = get_bits(&s->gb, 3); 1361 if(s->pict_type == 0 || s->pict_type > 3) 1362 return -1; 1363 1364 vbv_delay= get_bits(&s->gb, 16); 1365 if (s->pict_type == FF_P_TYPE || s->pict_type == FF_B_TYPE) { 1366 s->full_pel[0] = get_bits1(&s->gb); 1367 f_code = get_bits(&s->gb, 3); 1368 if (f_code == 0 && avctx->error_recognition >= FF_ER_COMPLIANT) 1369 return -1; 1370 s->mpeg_f_code[0][0] = f_code; 1371 s->mpeg_f_code[0][1] = f_code; 1372 } 1373 if (s->pict_type == FF_B_TYPE) { 1374 s->full_pel[1] = get_bits1(&s->gb); 1375 f_code = get_bits(&s->gb, 3); 1376 if (f_code == 0 && avctx->error_recognition >= FF_ER_COMPLIANT) 1377 return -1; 1378 s->mpeg_f_code[1][0] = f_code; 1379 s->mpeg_f_code[1][1] = f_code; 1380 } 1381 s->current_picture.pict_type= s->pict_type; 1382 s->current_picture.key_frame= s->pict_type == FF_I_TYPE; 1383 1384 if(avctx->debug & FF_DEBUG_PICT_INFO) 1385 av_log(avctx, AV_LOG_DEBUG, "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type); 1386 1387 s->y_dc_scale = 8; 1388 s->c_dc_scale = 8; 1389 return 0; 1390} 1391 1392static void mpeg_decode_sequence_extension(Mpeg1Context *s1) 1393{ 1394 MpegEncContext *s= &s1->mpeg_enc_ctx; 1395 int horiz_size_ext, vert_size_ext; 1396 int bit_rate_ext; 1397 1398 skip_bits(&s->gb, 1); /* profile and level esc*/ 1399 s->avctx->profile= get_bits(&s->gb, 3); 1400 s->avctx->level= get_bits(&s->gb, 4); 1401 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */ 1402 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */ 1403 horiz_size_ext = get_bits(&s->gb, 2); 1404 vert_size_ext = get_bits(&s->gb, 2); 1405 s->width |= (horiz_size_ext << 12); 1406 s->height |= (vert_size_ext << 12); 1407 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */ 1408 s->bit_rate += (bit_rate_ext << 18) * 400; 1409 skip_bits1(&s->gb); /* marker */ 1410 s->avctx->rc_buffer_size += get_bits(&s->gb, 8)*1024*16<<10; 1411 1412 s->low_delay = get_bits1(&s->gb); 1413 if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1; 1414 1415 s1->frame_rate_ext.num = get_bits(&s->gb, 2)+1; 1416 s1->frame_rate_ext.den = get_bits(&s->gb, 5)+1; 1417 1418 dprintf(s->avctx, "sequence extension\n"); 1419 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO; 1420 s->avctx->sub_id = 2; /* indicates MPEG-2 found */ 1421 1422 if(s->avctx->debug & FF_DEBUG_PICT_INFO) 1423 av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d vbv buffer: %d, bitrate:%d\n", 1424 s->avctx->profile, s->avctx->level, s->avctx->rc_buffer_size, s->bit_rate); 1425 1426} 1427 1428static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1) 1429{ 1430 MpegEncContext *s= &s1->mpeg_enc_ctx; 1431 int color_description, w, h; 1432 1433 skip_bits(&s->gb, 3); /* video format */ 1434 color_description= get_bits1(&s->gb); 1435 if(color_description){ 1436 s->avctx->color_primaries= get_bits(&s->gb, 8); 1437 s->avctx->color_trc = get_bits(&s->gb, 8); 1438 s->avctx->colorspace = get_bits(&s->gb, 8); 1439 } 1440 w= get_bits(&s->gb, 14); 1441 skip_bits(&s->gb, 1); //marker 1442 h= get_bits(&s->gb, 14); 1443 skip_bits(&s->gb, 1); //marker 1444 1445 s1->pan_scan.width= 16*w; 1446 s1->pan_scan.height=16*h; 1447 1448 if(s->avctx->debug & FF_DEBUG_PICT_INFO) 1449 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h); 1450} 1451 1452static void mpeg_decode_picture_display_extension(Mpeg1Context *s1) 1453{ 1454 MpegEncContext *s= &s1->mpeg_enc_ctx; 1455 int i,nofco; 1456 1457 nofco = 1; 1458 if(s->progressive_sequence){ 1459 if(s->repeat_first_field){ 1460 nofco++; 1461 if(s->top_field_first) 1462 nofco++; 1463 } 1464 }else{ 1465 if(s->picture_structure == PICT_FRAME){ 1466 nofco++; 1467 if(s->repeat_first_field) 1468 nofco++; 1469 } 1470 } 1471 for(i=0; i<nofco; i++){ 1472 s1->pan_scan.position[i][0]= get_sbits(&s->gb, 16); 1473 skip_bits(&s->gb, 1); //marker 1474 s1->pan_scan.position[i][1]= get_sbits(&s->gb, 16); 1475 skip_bits(&s->gb, 1); //marker 1476 } 1477 1478 if(s->avctx->debug & FF_DEBUG_PICT_INFO) 1479 av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n", 1480 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1], 1481 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1], 1482 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1] 1483 ); 1484} 1485 1486static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], uint16_t matrix1[64], int intra){ 1487 int i; 1488 1489 for(i=0; i<64; i++) { 1490 int j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; 1491 int v = get_bits(&s->gb, 8); 1492 if(v==0){ 1493 av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n"); 1494 return -1; 1495 } 1496 if(intra && i==0 && v!=8){ 1497 av_log(s->avctx, AV_LOG_ERROR, "intra matrix invalid, ignoring\n"); 1498 v= 8; // needed by pink.mpg / issue1046 1499 } 1500 matrix0[j] = v; 1501 if(matrix1) 1502 matrix1[j] = v; 1503 } 1504 return 0; 1505} 1506 1507static void mpeg_decode_quant_matrix_extension(MpegEncContext *s) 1508{ 1509 dprintf(s->avctx, "matrix extension\n"); 1510 1511 if(get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1); 1512 if(get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0); 1513 if(get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, NULL , 1); 1514 if(get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, NULL , 0); 1515} 1516 1517static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1) 1518{ 1519 MpegEncContext *s= &s1->mpeg_enc_ctx; 1520 1521 s->full_pel[0] = s->full_pel[1] = 0; 1522 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4); 1523 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4); 1524 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4); 1525 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4); 1526 if(!s->pict_type && s1->mpeg_enc_ctx_allocated){ 1527 av_log(s->avctx, AV_LOG_ERROR, "Missing picture start code, guessing missing values\n"); 1528 if(s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1]==15){ 1529 if(s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15) 1530 s->pict_type= FF_I_TYPE; 1531 else 1532 s->pict_type= FF_P_TYPE; 1533 }else 1534 s->pict_type= FF_B_TYPE; 1535 s->current_picture.pict_type= s->pict_type; 1536 s->current_picture.key_frame= s->pict_type == FF_I_TYPE; 1537 } 1538 s->intra_dc_precision = get_bits(&s->gb, 2); 1539 s->picture_structure = get_bits(&s->gb, 2); 1540 s->top_field_first = get_bits1(&s->gb); 1541 s->frame_pred_frame_dct = get_bits1(&s->gb); 1542 s->concealment_motion_vectors = get_bits1(&s->gb); 1543 s->q_scale_type = get_bits1(&s->gb); 1544 s->intra_vlc_format = get_bits1(&s->gb); 1545 s->alternate_scan = get_bits1(&s->gb); 1546 s->repeat_first_field = get_bits1(&s->gb); 1547 s->chroma_420_type = get_bits1(&s->gb); 1548 s->progressive_frame = get_bits1(&s->gb); 1549 1550 if(s->progressive_sequence && !s->progressive_frame){ 1551 s->progressive_frame= 1; 1552 av_log(s->avctx, AV_LOG_ERROR, "interlaced frame in progressive sequence, ignoring\n"); 1553 } 1554 1555 if(s->picture_structure==0 || (s->progressive_frame && s->picture_structure!=PICT_FRAME)){ 1556 av_log(s->avctx, AV_LOG_ERROR, "picture_structure %d invalid, ignoring\n", s->picture_structure); 1557 s->picture_structure= PICT_FRAME; 1558 } 1559 1560 if(s->progressive_sequence && !s->frame_pred_frame_dct){ 1561 av_log(s->avctx, AV_LOG_ERROR, "invalid frame_pred_frame_dct\n"); 1562 s->frame_pred_frame_dct= 1; 1563 } 1564 1565 if(s->picture_structure == PICT_FRAME){ 1566 s->first_field=0; 1567 s->v_edge_pos= 16*s->mb_height; 1568 }else{ 1569 s->first_field ^= 1; 1570 s->v_edge_pos= 8*s->mb_height; 1571 memset(s->mbskip_table, 0, s->mb_stride*s->mb_height); 1572 } 1573 1574 if(s->alternate_scan){ 1575 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); 1576 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); 1577 }else{ 1578 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); 1579 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); 1580 } 1581 1582 /* composite display not parsed */ 1583 dprintf(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision); 1584 dprintf(s->avctx, "picture_structure=%d\n", s->picture_structure); 1585 dprintf(s->avctx, "top field first=%d\n", s->top_field_first); 1586 dprintf(s->avctx, "repeat first field=%d\n", s->repeat_first_field); 1587 dprintf(s->avctx, "conceal=%d\n", s->concealment_motion_vectors); 1588 dprintf(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format); 1589 dprintf(s->avctx, "alternate_scan=%d\n", s->alternate_scan); 1590 dprintf(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct); 1591 dprintf(s->avctx, "progressive_frame=%d\n", s->progressive_frame); 1592} 1593 1594static void exchange_uv(MpegEncContext *s){ 1595 DCTELEM (*tmp)[64]; 1596 1597 tmp = s->pblocks[4]; 1598 s->pblocks[4] = s->pblocks[5]; 1599 s->pblocks[5] = tmp; 1600} 1601 1602static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size){ 1603 AVCodecContext *avctx= s->avctx; 1604 Mpeg1Context *s1 = (Mpeg1Context*)s; 1605 1606 /* start frame decoding */ 1607 if(s->first_field || s->picture_structure==PICT_FRAME){ 1608 if(MPV_frame_start(s, avctx) < 0) 1609 return -1; 1610 1611 ff_er_frame_start(s); 1612 1613 /* first check if we must repeat the frame */ 1614 s->current_picture_ptr->repeat_pict = 0; 1615 if (s->repeat_first_field) { 1616 if (s->progressive_sequence) { 1617 if (s->top_field_first) 1618 s->current_picture_ptr->repeat_pict = 4; 1619 else 1620 s->current_picture_ptr->repeat_pict = 2; 1621 } else if (s->progressive_frame) { 1622 s->current_picture_ptr->repeat_pict = 1; 1623 } 1624 } 1625 1626 *s->current_picture_ptr->pan_scan= s1->pan_scan; 1627 }else{ //second field 1628 int i; 1629 1630 if(!s->current_picture_ptr){ 1631 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n"); 1632 return -1; 1633 } 1634 1635 for(i=0; i<4; i++){ 1636 s->current_picture.data[i] = s->current_picture_ptr->data[i]; 1637 if(s->picture_structure == PICT_BOTTOM_FIELD){ 1638 s->current_picture.data[i] += s->current_picture_ptr->linesize[i]; 1639 } 1640 } 1641 } 1642 1643 if (avctx->hwaccel) { 1644 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0) 1645 return -1; 1646 } 1647 1648// MPV_frame_start will call this function too, 1649// but we need to call it on every field 1650 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) 1651 if(ff_xvmc_field_start(s,avctx) < 0) 1652 return -1; 1653 1654 return 0; 1655} 1656 1657#define DECODE_SLICE_ERROR -1 1658#define DECODE_SLICE_OK 0 1659 1660/** 1661 * decodes a slice. MpegEncContext.mb_y must be set to the MB row from the startcode 1662 * @return DECODE_SLICE_ERROR if the slice is damaged<br> 1663 * DECODE_SLICE_OK if this slice is ok<br> 1664 */ 1665static int mpeg_decode_slice(Mpeg1Context *s1, int mb_y, 1666 const uint8_t **buf, int buf_size) 1667{ 1668 MpegEncContext *s = &s1->mpeg_enc_ctx; 1669 AVCodecContext *avctx= s->avctx; 1670 const int field_pic= s->picture_structure != PICT_FRAME; 1671 const int lowres= s->avctx->lowres; 1672 1673 s->resync_mb_x= 1674 s->resync_mb_y= -1; 1675 1676 assert(mb_y < s->mb_height); 1677 1678 init_get_bits(&s->gb, *buf, buf_size*8); 1679 1680 ff_mpeg1_clean_buffers(s); 1681 s->interlaced_dct = 0; 1682 1683 s->qscale = get_qscale(s); 1684 1685 if(s->qscale == 0){ 1686 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n"); 1687 return -1; 1688 } 1689 1690 /* extra slice info */ 1691 while (get_bits1(&s->gb) != 0) { 1692 skip_bits(&s->gb, 8); 1693 } 1694 1695 s->mb_x=0; 1696 1697 if(mb_y==0 && s->codec_tag == AV_RL32("SLIF")){ 1698 skip_bits1(&s->gb); 1699 }else{ 1700 for(;;) { 1701 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2); 1702 if (code < 0){ 1703 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n"); 1704 return -1; 1705 } 1706 if (code >= 33) { 1707 if (code == 33) { 1708 s->mb_x += 33; 1709 } 1710 /* otherwise, stuffing, nothing to do */ 1711 } else { 1712 s->mb_x += code; 1713 break; 1714 } 1715 } 1716 } 1717 1718 if(s->mb_x >= (unsigned)s->mb_width){ 1719 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n"); 1720 return -1; 1721 } 1722 1723 if (avctx->hwaccel) { 1724 const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */ 1725 int start_code = -1; 1726 buf_end = ff_find_start_code(buf_start + 2, *buf + buf_size, &start_code); 1727 if (buf_end < *buf + buf_size) 1728 buf_end -= 4; 1729 s->mb_y = mb_y; 1730 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0) 1731 return DECODE_SLICE_ERROR; 1732 *buf = buf_end; 1733 return DECODE_SLICE_OK; 1734 } 1735 1736 s->resync_mb_x= s->mb_x; 1737 s->resync_mb_y= s->mb_y= mb_y; 1738 s->mb_skip_run= 0; 1739 ff_init_block_index(s); 1740 1741 if (s->mb_y==0 && s->mb_x==0 && (s->first_field || s->picture_structure==PICT_FRAME)) { 1742 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ 1743 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%2d%2d%2d%2d %s %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n", 1744 s->qscale, s->mpeg_f_code[0][0],s->mpeg_f_code[0][1],s->mpeg_f_code[1][0],s->mpeg_f_code[1][1], 1745 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")), 1746 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"", 1747 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors, 1748 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :""); 1749 } 1750 } 1751 1752 for(;;) { 1753 //If 1, we memcpy blocks in xvmcvideo. 1754 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1) 1755 ff_xvmc_init_block(s);//set s->block 1756 1757 if(mpeg_decode_mb(s, s->block) < 0) 1758 return -1; 1759 1760 if(s->current_picture.motion_val[0] && !s->encoding){ //note motion_val is normally NULL unless we want to extract the MVs 1761 const int wrap = s->b8_stride; 1762 int xy = s->mb_x*2 + s->mb_y*2*wrap; 1763 int b8_xy= 4*(s->mb_x + s->mb_y*s->mb_stride); 1764 int motion_x, motion_y, dir, i; 1765 1766 for(i=0; i<2; i++){ 1767 for(dir=0; dir<2; dir++){ 1768 if (s->mb_intra || (dir==1 && s->pict_type != FF_B_TYPE)) { 1769 motion_x = motion_y = 0; 1770 }else if (s->mv_type == MV_TYPE_16X16 || (s->mv_type == MV_TYPE_FIELD && field_pic)){ 1771 motion_x = s->mv[dir][0][0]; 1772 motion_y = s->mv[dir][0][1]; 1773 } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ { 1774 motion_x = s->mv[dir][i][0]; 1775 motion_y = s->mv[dir][i][1]; 1776 } 1777 1778 s->current_picture.motion_val[dir][xy ][0] = motion_x; 1779 s->current_picture.motion_val[dir][xy ][1] = motion_y; 1780 s->current_picture.motion_val[dir][xy + 1][0] = motion_x; 1781 s->current_picture.motion_val[dir][xy + 1][1] = motion_y; 1782 s->current_picture.ref_index [dir][b8_xy ]= 1783 s->current_picture.ref_index [dir][b8_xy + 1]= s->field_select[dir][i]; 1784 assert(s->field_select[dir][i]==0 || s->field_select[dir][i]==1); 1785 } 1786 xy += wrap; 1787 b8_xy +=2; 1788 } 1789 } 1790 1791 s->dest[0] += 16 >> lowres; 1792 s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift; 1793 s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift; 1794 1795 MPV_decode_mb(s, s->block); 1796 1797 if (++s->mb_x >= s->mb_width) { 1798 const int mb_size= 16>>s->avctx->lowres; 1799 1800 ff_draw_horiz_band(s, mb_size*(s->mb_y>>field_pic), mb_size); 1801 1802 s->mb_x = 0; 1803 s->mb_y += 1<<field_pic; 1804 1805 if(s->mb_y >= s->mb_height){ 1806 int left= get_bits_left(&s->gb); 1807 int is_d10= s->chroma_format==2 && s->pict_type==FF_I_TYPE && avctx->profile==0 && avctx->level==5 1808 && s->intra_dc_precision == 2 && s->q_scale_type == 1 && s->alternate_scan == 0 1809 && s->progressive_frame == 0 /* vbv_delay == 0xBBB || 0xE10*/; 1810 1811 if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) 1812 || (avctx->error_recognition >= FF_ER_AGGRESSIVE && left>8)){ 1813 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n", left, show_bits(&s->gb, FFMIN(left, 23))); 1814 return -1; 1815 }else 1816 goto eos; 1817 } 1818 1819 ff_init_block_index(s); 1820 } 1821 1822 /* skip mb handling */ 1823 if (s->mb_skip_run == -1) { 1824 /* read increment again */ 1825 s->mb_skip_run = 0; 1826 for(;;) { 1827 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2); 1828 if (code < 0){ 1829 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n"); 1830 return -1; 1831 } 1832 if (code >= 33) { 1833 if (code == 33) { 1834 s->mb_skip_run += 33; 1835 }else if(code == 35){ 1836 if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){ 1837 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n"); 1838 return -1; 1839 } 1840 goto eos; /* end of slice */ 1841 } 1842 /* otherwise, stuffing, nothing to do */ 1843 } else { 1844 s->mb_skip_run += code; 1845 break; 1846 } 1847 } 1848 if(s->mb_skip_run){ 1849 int i; 1850 if(s->pict_type == FF_I_TYPE){ 1851 av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y); 1852 return -1; 1853 } 1854 1855 /* skip mb */ 1856 s->mb_intra = 0; 1857 for(i=0;i<12;i++) 1858 s->block_last_index[i] = -1; 1859 if(s->picture_structure == PICT_FRAME) 1860 s->mv_type = MV_TYPE_16X16; 1861 else 1862 s->mv_type = MV_TYPE_FIELD; 1863 if (s->pict_type == FF_P_TYPE) { 1864 /* if P type, zero motion vector is implied */ 1865 s->mv_dir = MV_DIR_FORWARD; 1866 s->mv[0][0][0] = s->mv[0][0][1] = 0; 1867 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0; 1868 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0; 1869 s->field_select[0][0]= (s->picture_structure - 1) & 1; 1870 } else { 1871 /* if B type, reuse previous vectors and directions */ 1872 s->mv[0][0][0] = s->last_mv[0][0][0]; 1873 s->mv[0][0][1] = s->last_mv[0][0][1]; 1874 s->mv[1][0][0] = s->last_mv[1][0][0]; 1875 s->mv[1][0][1] = s->last_mv[1][0][1]; 1876 } 1877 } 1878 } 1879 } 1880eos: // end of slice 1881 *buf += (get_bits_count(&s->gb)-1)/8; 1882//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y); 1883 return 0; 1884} 1885 1886static int slice_decode_thread(AVCodecContext *c, void *arg){ 1887 MpegEncContext *s= *(void**)arg; 1888 const uint8_t *buf= s->gb.buffer; 1889 int mb_y= s->start_mb_y; 1890 const int field_pic= s->picture_structure != PICT_FRAME; 1891 1892 s->error_count= (3*(s->end_mb_y - s->start_mb_y)*s->mb_width) >> field_pic; 1893 1894 for(;;){ 1895 uint32_t start_code; 1896 int ret; 1897 1898 ret= mpeg_decode_slice((Mpeg1Context*)s, mb_y, &buf, s->gb.buffer_end - buf); 1899 emms_c(); 1900//av_log(c, AV_LOG_DEBUG, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n", 1901//ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, s->start_mb_y, s->end_mb_y, s->error_count); 1902 if(ret < 0){ 1903 if(s->resync_mb_x>=0 && s->resync_mb_y>=0) 1904 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, AC_ERROR|DC_ERROR|MV_ERROR); 1905 }else{ 1906 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END); 1907 } 1908 1909 if(s->mb_y == s->end_mb_y) 1910 return 0; 1911 1912 start_code= -1; 1913 buf = ff_find_start_code(buf, s->gb.buffer_end, &start_code); 1914 mb_y= start_code - SLICE_MIN_START_CODE; 1915 if(mb_y < 0 || mb_y >= s->end_mb_y) 1916 return -1; 1917 } 1918 1919 return 0; //not reached 1920} 1921 1922/** 1923 * Handles slice ends. 1924 * @return 1 if it seems to be the last slice 1925 */ 1926static int slice_end(AVCodecContext *avctx, AVFrame *pict) 1927{ 1928 Mpeg1Context *s1 = avctx->priv_data; 1929 MpegEncContext *s = &s1->mpeg_enc_ctx; 1930 1931 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr) 1932 return 0; 1933 1934 if (s->avctx->hwaccel) { 1935 if (s->avctx->hwaccel->end_frame(s->avctx) < 0) 1936 av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n"); 1937 } 1938 1939 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) 1940 ff_xvmc_field_end(s); 1941 1942 /* end of slice reached */ 1943 if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) { 1944 /* end of image */ 1945 1946 s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2; 1947 1948 ff_er_frame_end(s); 1949 1950 MPV_frame_end(s); 1951 1952 if (s->pict_type == FF_B_TYPE || s->low_delay) { 1953 *pict= *(AVFrame*)s->current_picture_ptr; 1954 ff_print_debug_info(s, pict); 1955 } else { 1956 s->picture_number++; 1957 /* latency of 1 frame for I- and P-frames */ 1958 /* XXX: use another variable than picture_number */ 1959 if (s->last_picture_ptr != NULL) { 1960 *pict= *(AVFrame*)s->last_picture_ptr; 1961 ff_print_debug_info(s, pict); 1962 } 1963 } 1964 1965 return 1; 1966 } else { 1967 return 0; 1968 } 1969} 1970 1971static int mpeg1_decode_sequence(AVCodecContext *avctx, 1972 const uint8_t *buf, int buf_size) 1973{ 1974 Mpeg1Context *s1 = avctx->priv_data; 1975 MpegEncContext *s = &s1->mpeg_enc_ctx; 1976 int width,height; 1977 int i, v, j; 1978 1979 init_get_bits(&s->gb, buf, buf_size*8); 1980 1981 width = get_bits(&s->gb, 12); 1982 height = get_bits(&s->gb, 12); 1983 if (width <= 0 || height <= 0) 1984 return -1; 1985 s->aspect_ratio_info= get_bits(&s->gb, 4); 1986 if (s->aspect_ratio_info == 0) { 1987 av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n"); 1988 if (avctx->error_recognition >= FF_ER_COMPLIANT) 1989 return -1; 1990 } 1991 s->frame_rate_index = get_bits(&s->gb, 4); 1992 if (s->frame_rate_index == 0 || s->frame_rate_index > 13) 1993 return -1; 1994 s->bit_rate = get_bits(&s->gb, 18) * 400; 1995 if (get_bits1(&s->gb) == 0) /* marker */ 1996 return -1; 1997 s->width = width; 1998 s->height = height; 1999 2000 s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16; 2001 skip_bits(&s->gb, 1); 2002 2003 /* get matrix */ 2004 if (get_bits1(&s->gb)) { 2005 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1); 2006 } else { 2007 for(i=0;i<64;i++) { 2008 j = s->dsp.idct_permutation[i]; 2009 v = ff_mpeg1_default_intra_matrix[i]; 2010 s->intra_matrix[j] = v; 2011 s->chroma_intra_matrix[j] = v; 2012 } 2013 } 2014 if (get_bits1(&s->gb)) { 2015 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0); 2016 } else { 2017 for(i=0;i<64;i++) { 2018 int j= s->dsp.idct_permutation[i]; 2019 v = ff_mpeg1_default_non_intra_matrix[i]; 2020 s->inter_matrix[j] = v; 2021 s->chroma_inter_matrix[j] = v; 2022 } 2023 } 2024 2025 if(show_bits(&s->gb, 23) != 0){ 2026 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n"); 2027 return -1; 2028 } 2029 2030 /* we set MPEG-2 parameters so that it emulates MPEG-1 */ 2031 s->progressive_sequence = 1; 2032 s->progressive_frame = 1; 2033 s->picture_structure = PICT_FRAME; 2034 s->frame_pred_frame_dct = 1; 2035 s->chroma_format = 1; 2036 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO; 2037 avctx->sub_id = 1; /* indicates MPEG-1 */ 2038 s->out_format = FMT_MPEG1; 2039 s->swap_uv = 0;//AFAIK VCR2 does not have SEQ_HEADER 2040 if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1; 2041 2042 if(s->avctx->debug & FF_DEBUG_PICT_INFO) 2043 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n", 2044 s->avctx->rc_buffer_size, s->bit_rate); 2045 2046 return 0; 2047} 2048 2049static int vcr2_init_sequence(AVCodecContext *avctx) 2050{ 2051 Mpeg1Context *s1 = avctx->priv_data; 2052 MpegEncContext *s = &s1->mpeg_enc_ctx; 2053 int i, v; 2054 2055 /* start new MPEG-1 context decoding */ 2056 s->out_format = FMT_MPEG1; 2057 if (s1->mpeg_enc_ctx_allocated) { 2058 MPV_common_end(s); 2059 } 2060 s->width = avctx->coded_width; 2061 s->height = avctx->coded_height; 2062 avctx->has_b_frames= 0; //true? 2063 s->low_delay= 1; 2064 2065 avctx->pix_fmt = mpeg_get_pixelformat(avctx); 2066 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt); 2067 2068 if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT || avctx->hwaccel || 2069 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU ) 2070 if( avctx->idct_algo == FF_IDCT_AUTO ) 2071 avctx->idct_algo = FF_IDCT_SIMPLE; 2072 2073 if (MPV_common_init(s) < 0) 2074 return -1; 2075 exchange_uv(s);//common init reset pblocks, so we swap them here 2076 s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB 2077 s1->mpeg_enc_ctx_allocated = 1; 2078 2079 for(i=0;i<64;i++) { 2080 int j= s->dsp.idct_permutation[i]; 2081 v = ff_mpeg1_default_intra_matrix[i]; 2082 s->intra_matrix[j] = v; 2083 s->chroma_intra_matrix[j] = v; 2084 2085 v = ff_mpeg1_default_non_intra_matrix[i]; 2086 s->inter_matrix[j] = v; 2087 s->chroma_inter_matrix[j] = v; 2088 } 2089 2090 s->progressive_sequence = 1; 2091 s->progressive_frame = 1; 2092 s->picture_structure = PICT_FRAME; 2093 s->frame_pred_frame_dct = 1; 2094 s->chroma_format = 1; 2095 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO; 2096 avctx->sub_id = 2; /* indicates MPEG-2 */ 2097 s1->save_width = s->width; 2098 s1->save_height = s->height; 2099 s1->save_progressive_seq = s->progressive_sequence; 2100 return 0; 2101} 2102 2103 2104static void mpeg_decode_user_data(AVCodecContext *avctx, 2105 const uint8_t *p, int buf_size) 2106{ 2107 const uint8_t *buf_end = p+buf_size; 2108 2109 /* we parse the DTG active format information */ 2110 if (buf_end - p >= 5 && 2111 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') { 2112 int flags = p[4]; 2113 p += 5; 2114 if (flags & 0x80) { 2115 /* skip event id */ 2116 p += 2; 2117 } 2118 if (flags & 0x40) { 2119 if (buf_end - p < 1) 2120 return; 2121 avctx->dtg_active_format = p[0] & 0x0f; 2122 } 2123 } 2124} 2125 2126static void mpeg_decode_gop(AVCodecContext *avctx, 2127 const uint8_t *buf, int buf_size){ 2128 Mpeg1Context *s1 = avctx->priv_data; 2129 MpegEncContext *s = &s1->mpeg_enc_ctx; 2130 2131 int drop_frame_flag; 2132 int time_code_hours, time_code_minutes; 2133 int time_code_seconds, time_code_pictures; 2134 int broken_link; 2135 2136 init_get_bits(&s->gb, buf, buf_size*8); 2137 2138 drop_frame_flag = get_bits1(&s->gb); 2139 2140 time_code_hours=get_bits(&s->gb,5); 2141 time_code_minutes = get_bits(&s->gb,6); 2142 skip_bits1(&s->gb);//marker bit 2143 time_code_seconds = get_bits(&s->gb,6); 2144 time_code_pictures = get_bits(&s->gb,6); 2145 2146 s->closed_gop = get_bits1(&s->gb); 2147 /*broken_link indicate that after editing the 2148 reference frames of the first B-Frames after GOP I-Frame 2149 are missing (open gop)*/ 2150 broken_link = get_bits1(&s->gb); 2151 2152 if(s->avctx->debug & FF_DEBUG_PICT_INFO) 2153 av_log(s->avctx, AV_LOG_DEBUG, "GOP (%2d:%02d:%02d.[%02d]) closed_gop=%d broken_link=%d\n", 2154 time_code_hours, time_code_minutes, time_code_seconds, 2155 time_code_pictures, s->closed_gop, broken_link); 2156} 2157/** 2158 * Finds the end of the current frame in the bitstream. 2159 * @return the position of the first byte of the next frame, or -1 2160 */ 2161int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size, AVCodecParserContext *s) 2162{ 2163 int i; 2164 uint32_t state= pc->state; 2165 2166 /* EOF considered as end of frame */ 2167 if (buf_size == 0) 2168 return 0; 2169 2170/* 2171 0 frame start -> 1/4 2172 1 first_SEQEXT -> 0/2 2173 2 first field start -> 3/0 2174 3 second_SEQEXT -> 2/0 2175 4 searching end 2176*/ 2177 2178 for(i=0; i<buf_size; i++){ 2179 assert(pc->frame_start_found>=0 && pc->frame_start_found<=4); 2180 if(pc->frame_start_found&1){ 2181 if(state == EXT_START_CODE && (buf[i]&0xF0) != 0x80) 2182 pc->frame_start_found--; 2183 else if(state == EXT_START_CODE+2){ 2184 if((buf[i]&3) == 3) pc->frame_start_found= 0; 2185 else pc->frame_start_found= (pc->frame_start_found+1)&3; 2186 } 2187 state++; 2188 }else{ 2189 i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1; 2190 if(pc->frame_start_found==0 && state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){ 2191 i++; 2192 pc->frame_start_found=4; 2193 } 2194 if(state == SEQ_END_CODE){ 2195 pc->state=-1; 2196 return i+1; 2197 } 2198 if(pc->frame_start_found==2 && state == SEQ_START_CODE) 2199 pc->frame_start_found= 0; 2200 if(pc->frame_start_found<4 && state == EXT_START_CODE) 2201 pc->frame_start_found++; 2202 if(pc->frame_start_found == 4 && (state&0xFFFFFF00) == 0x100){ 2203 if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){ 2204 pc->frame_start_found=0; 2205 pc->state=-1; 2206 return i-3; 2207 } 2208 } 2209 if(pc->frame_start_found == 0 && s && state == PICTURE_START_CODE){ 2210 ff_fetch_timestamp(s, i-3, 1); 2211 } 2212 } 2213 } 2214 pc->state= state; 2215 return END_NOT_FOUND; 2216} 2217 2218static int decode_chunks(AVCodecContext *avctx, 2219 AVFrame *picture, int *data_size, 2220 const uint8_t *buf, int buf_size); 2221 2222/* handle buffering and image synchronisation */ 2223static int mpeg_decode_frame(AVCodecContext *avctx, 2224 void *data, int *data_size, 2225 AVPacket *avpkt) 2226{ 2227 const uint8_t *buf = avpkt->data; 2228 int buf_size = avpkt->size; 2229 Mpeg1Context *s = avctx->priv_data; 2230 AVFrame *picture = data; 2231 MpegEncContext *s2 = &s->mpeg_enc_ctx; 2232 dprintf(avctx, "fill_buffer\n"); 2233 2234 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) { 2235 /* special case for last picture */ 2236 if (s2->low_delay==0 && s2->next_picture_ptr) { 2237 *picture= *(AVFrame*)s2->next_picture_ptr; 2238 s2->next_picture_ptr= NULL; 2239 2240 *data_size = sizeof(AVFrame); 2241 } 2242 return buf_size; 2243 } 2244 2245 if(s2->flags&CODEC_FLAG_TRUNCATED){ 2246 int next= ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size, NULL); 2247 2248 if( ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 ) 2249 return buf_size; 2250 } 2251 2252#if 0 2253 if (s->repeat_field % 2 == 1) { 2254 s->repeat_field++; 2255 //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number, 2256 // s2->picture_number, s->repeat_field); 2257 if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) { 2258 *data_size = sizeof(AVPicture); 2259 goto the_end; 2260 } 2261 } 2262#endif 2263 2264 if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == AV_RL32("VCR2")) 2265 vcr2_init_sequence(avctx); 2266 2267 s->slice_count= 0; 2268 2269 if(avctx->extradata && !avctx->frame_number) 2270 decode_chunks(avctx, picture, data_size, avctx->extradata, avctx->extradata_size); 2271 2272 return decode_chunks(avctx, picture, data_size, buf, buf_size); 2273} 2274 2275static int decode_chunks(AVCodecContext *avctx, 2276 AVFrame *picture, int *data_size, 2277 const uint8_t *buf, int buf_size) 2278{ 2279 Mpeg1Context *s = avctx->priv_data; 2280 MpegEncContext *s2 = &s->mpeg_enc_ctx; 2281 const uint8_t *buf_ptr = buf; 2282 const uint8_t *buf_end = buf + buf_size; 2283 int ret, input_size; 2284 int last_code= 0; 2285 2286 for(;;) { 2287 /* find next start code */ 2288 uint32_t start_code = -1; 2289 buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code); 2290 if (start_code > 0x1ff){ 2291 if(s2->pict_type != FF_B_TYPE || avctx->skip_frame <= AVDISCARD_DEFAULT){ 2292 if(avctx->thread_count > 1){ 2293 int i; 2294 2295 avctx->execute(avctx, slice_decode_thread, &s2->thread_context[0], NULL, s->slice_count, sizeof(void*)); 2296 for(i=0; i<s->slice_count; i++) 2297 s2->error_count += s2->thread_context[i]->error_count; 2298 } 2299 2300 if (CONFIG_MPEG_VDPAU_DECODER && avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) 2301 ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count); 2302 2303 if (slice_end(avctx, picture)) { 2304 if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice 2305 *data_size = sizeof(AVPicture); 2306 } 2307 } 2308 s2->pict_type= 0; 2309 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index); 2310 } 2311 2312 input_size = buf_end - buf_ptr; 2313 2314 if(avctx->debug & FF_DEBUG_STARTCODE){ 2315 av_log(avctx, AV_LOG_DEBUG, "%3X at %td left %d\n", start_code, buf_ptr-buf, input_size); 2316 } 2317 2318 /* prepare data for next start code */ 2319 switch(start_code) { 2320 case SEQ_START_CODE: 2321 if(last_code == 0){ 2322 mpeg1_decode_sequence(avctx, buf_ptr, 2323 input_size); 2324 s->sync=1; 2325 }else{ 2326 av_log(avctx, AV_LOG_ERROR, "ignoring SEQ_START_CODE after %X\n", last_code); 2327 } 2328 break; 2329 2330 case PICTURE_START_CODE: 2331 if(last_code == 0 || last_code == SLICE_MIN_START_CODE){ 2332 if(mpeg_decode_postinit(avctx) < 0){ 2333 av_log(avctx, AV_LOG_ERROR, "mpeg_decode_postinit() failure\n"); 2334 return -1; 2335 } 2336 2337 /* we have a complete image: we try to decompress it */ 2338 if(mpeg1_decode_picture(avctx, 2339 buf_ptr, input_size) < 0) 2340 s2->pict_type=0; 2341 s2->first_slice = 1; 2342 last_code= PICTURE_START_CODE; 2343 }else{ 2344 av_log(avctx, AV_LOG_ERROR, "ignoring pic after %X\n", last_code); 2345 } 2346 break; 2347 case EXT_START_CODE: 2348 init_get_bits(&s2->gb, buf_ptr, input_size*8); 2349 2350 switch(get_bits(&s2->gb, 4)) { 2351 case 0x1: 2352 if(last_code == 0){ 2353 mpeg_decode_sequence_extension(s); 2354 }else{ 2355 av_log(avctx, AV_LOG_ERROR, "ignoring seq ext after %X\n", last_code); 2356 } 2357 break; 2358 case 0x2: 2359 mpeg_decode_sequence_display_extension(s); 2360 break; 2361 case 0x3: 2362 mpeg_decode_quant_matrix_extension(s2); 2363 break; 2364 case 0x7: 2365 mpeg_decode_picture_display_extension(s); 2366 break; 2367 case 0x8: 2368 if(last_code == PICTURE_START_CODE){ 2369 mpeg_decode_picture_coding_extension(s); 2370 }else{ 2371 av_log(avctx, AV_LOG_ERROR, "ignoring pic cod ext after %X\n", last_code); 2372 } 2373 break; 2374 } 2375 break; 2376 case USER_START_CODE: 2377 mpeg_decode_user_data(avctx, 2378 buf_ptr, input_size); 2379 break; 2380 case GOP_START_CODE: 2381 if(last_code == 0){ 2382 s2->first_field=0; 2383 mpeg_decode_gop(avctx, 2384 buf_ptr, input_size); 2385 s->sync=1; 2386 }else{ 2387 av_log(avctx, AV_LOG_ERROR, "ignoring GOP_START_CODE after %X\n", last_code); 2388 } 2389 break; 2390 default: 2391 if (start_code >= SLICE_MIN_START_CODE && 2392 start_code <= SLICE_MAX_START_CODE && last_code!=0) { 2393 const int field_pic= s2->picture_structure != PICT_FRAME; 2394 int mb_y= (start_code - SLICE_MIN_START_CODE) << field_pic; 2395 last_code= SLICE_MIN_START_CODE; 2396 2397 if(s2->picture_structure == PICT_BOTTOM_FIELD) 2398 mb_y++; 2399 2400 if (mb_y >= s2->mb_height){ 2401 av_log(s2->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s2->mb_height); 2402 return -1; 2403 } 2404 2405 if(s2->last_picture_ptr==NULL){ 2406 /* Skip B-frames if we do not have reference frames and gop is not closed */ 2407 if(s2->pict_type==FF_B_TYPE){ 2408 if(!s2->closed_gop) 2409 break; 2410 } 2411 } 2412 if(s2->pict_type==FF_I_TYPE) 2413 s->sync=1; 2414 if(s2->next_picture_ptr==NULL){ 2415 /* Skip P-frames if we do not have a reference frame or we have an invalid header. */ 2416 if(s2->pict_type==FF_P_TYPE && !s->sync) break; 2417 } 2418 /* Skip B-frames if we are in a hurry. */ 2419 if(avctx->hurry_up && s2->pict_type==FF_B_TYPE) break; 2420 if( (avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type==FF_B_TYPE) 2421 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type!=FF_I_TYPE) 2422 || avctx->skip_frame >= AVDISCARD_ALL) 2423 break; 2424 /* Skip everything if we are in a hurry>=5. */ 2425 if(avctx->hurry_up>=5) break; 2426 2427 if (!s->mpeg_enc_ctx_allocated) break; 2428 2429 if(s2->codec_id == CODEC_ID_MPEG2VIDEO){ 2430 if(mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom) 2431 break; 2432 } 2433 2434 if(!s2->pict_type){ 2435 av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n"); 2436 break; 2437 } 2438 2439 if(s2->first_slice){ 2440 s2->first_slice=0; 2441 if(mpeg_field_start(s2, buf, buf_size) < 0) 2442 return -1; 2443 } 2444 if(!s2->current_picture_ptr){ 2445 av_log(avctx, AV_LOG_ERROR, "current_picture not initialized\n"); 2446 return -1; 2447 } 2448 2449 if (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) { 2450 s->slice_count++; 2451 break; 2452 } 2453 2454 if(avctx->thread_count > 1){ 2455 int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count; 2456 if(threshold <= mb_y){ 2457 MpegEncContext *thread_context= s2->thread_context[s->slice_count]; 2458 2459 thread_context->start_mb_y= mb_y; 2460 thread_context->end_mb_y = s2->mb_height; 2461 if(s->slice_count){ 2462 s2->thread_context[s->slice_count-1]->end_mb_y= mb_y; 2463 ff_update_duplicate_context(thread_context, s2); 2464 } 2465 init_get_bits(&thread_context->gb, buf_ptr, input_size*8); 2466 s->slice_count++; 2467 } 2468 buf_ptr += 2; //FIXME add minimum number of bytes per slice 2469 }else{ 2470 ret = mpeg_decode_slice(s, mb_y, &buf_ptr, input_size); 2471 emms_c(); 2472 2473 if(ret < 0){ 2474 if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0) 2475 ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, AC_ERROR|DC_ERROR|MV_ERROR); 2476 }else{ 2477 ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, AC_END|DC_END|MV_END); 2478 } 2479 } 2480 } 2481 break; 2482 } 2483 } 2484} 2485 2486static void flush(AVCodecContext *avctx){ 2487 Mpeg1Context *s = avctx->priv_data; 2488 2489 s->sync=0; 2490 2491 ff_mpeg_flush(avctx); 2492} 2493 2494static int mpeg_decode_end(AVCodecContext *avctx) 2495{ 2496 Mpeg1Context *s = avctx->priv_data; 2497 2498 if (s->mpeg_enc_ctx_allocated) 2499 MPV_common_end(&s->mpeg_enc_ctx); 2500 return 0; 2501} 2502 2503AVCodec mpeg1video_decoder = { 2504 "mpeg1video", 2505 AVMEDIA_TYPE_VIDEO, 2506 CODEC_ID_MPEG1VIDEO, 2507 sizeof(Mpeg1Context), 2508 mpeg_decode_init, 2509 NULL, 2510 mpeg_decode_end, 2511 mpeg_decode_frame, 2512 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, 2513 .flush= flush, 2514 .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"), 2515}; 2516 2517AVCodec mpeg2video_decoder = { 2518 "mpeg2video", 2519 AVMEDIA_TYPE_VIDEO, 2520 CODEC_ID_MPEG2VIDEO, 2521 sizeof(Mpeg1Context), 2522 mpeg_decode_init, 2523 NULL, 2524 mpeg_decode_end, 2525 mpeg_decode_frame, 2526 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, 2527 .flush= flush, 2528 .long_name= NULL_IF_CONFIG_SMALL("MPEG-2 video"), 2529}; 2530 2531//legacy decoder 2532AVCodec mpegvideo_decoder = { 2533 "mpegvideo", 2534 AVMEDIA_TYPE_VIDEO, 2535 CODEC_ID_MPEG2VIDEO, 2536 sizeof(Mpeg1Context), 2537 mpeg_decode_init, 2538 NULL, 2539 mpeg_decode_end, 2540 mpeg_decode_frame, 2541 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, 2542 .flush= flush, 2543 .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"), 2544}; 2545 2546#if CONFIG_MPEG_XVMC_DECODER 2547static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx){ 2548 if( avctx->thread_count > 1) 2549 return -1; 2550 if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) ) 2551 return -1; 2552 if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){ 2553 dprintf(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n"); 2554 } 2555 mpeg_decode_init(avctx); 2556 2557 avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT; 2558 avctx->xvmc_acceleration = 2;//2 - the blocks are packed! 2559 2560 return 0; 2561} 2562 2563AVCodec mpeg_xvmc_decoder = { 2564 "mpegvideo_xvmc", 2565 AVMEDIA_TYPE_VIDEO, 2566 CODEC_ID_MPEG2VIDEO_XVMC, 2567 sizeof(Mpeg1Context), 2568 mpeg_mc_decode_init, 2569 NULL, 2570 mpeg_decode_end, 2571 mpeg_decode_frame, 2572 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL | CODEC_CAP_DELAY, 2573 .flush= flush, 2574 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"), 2575}; 2576 2577#endif 2578 2579#if CONFIG_MPEG_VDPAU_DECODER 2580AVCodec mpeg_vdpau_decoder = { 2581 "mpegvideo_vdpau", 2582 AVMEDIA_TYPE_VIDEO, 2583 CODEC_ID_MPEG2VIDEO, 2584 sizeof(Mpeg1Context), 2585 mpeg_decode_init, 2586 NULL, 2587 mpeg_decode_end, 2588 mpeg_decode_frame, 2589 CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY, 2590 .flush= flush, 2591 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"), 2592}; 2593#endif 2594 2595#if CONFIG_MPEG1_VDPAU_DECODER 2596AVCodec mpeg1_vdpau_decoder = { 2597 "mpeg1video_vdpau", 2598 AVMEDIA_TYPE_VIDEO, 2599 CODEC_ID_MPEG1VIDEO, 2600 sizeof(Mpeg1Context), 2601 mpeg_decode_init, 2602 NULL, 2603 mpeg_decode_end, 2604 mpeg_decode_frame, 2605 CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY, 2606 .flush= flush, 2607 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"), 2608}; 2609#endif 2610 2611