1/* 2 * ITU H263 bitstream decoder 3 * Copyright (c) 2000,2001 Fabrice Bellard 4 * H263+ support. 5 * Copyright (c) 2001 Juan J. Sierralta P 6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> 7 * 8 * This file is part of FFmpeg. 9 * 10 * FFmpeg is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU Lesser General Public 12 * License as published by the Free Software Foundation; either 13 * version 2.1 of the License, or (at your option) any later version. 14 * 15 * FFmpeg is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * Lesser General Public License for more details. 19 * 20 * You should have received a copy of the GNU Lesser General Public 21 * License along with FFmpeg; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 23 */ 24 25/** 26 * @file 27 * h263 decoder. 28 */ 29 30#define UNCHECKED_BITSTREAM_READER 1 31#include <limits.h> 32 33#include "libavutil/attributes.h" 34#include "libavutil/internal.h" 35#include "libavutil/mathematics.h" 36#include "avcodec.h" 37#include "mpegvideo.h" 38#include "h263.h" 39#include "mathops.h" 40#include "mpegutils.h" 41#include "unary.h" 42#include "flv.h" 43#include "mpeg4video.h" 44 45// The defines below define the number of bits that are read at once for 46// reading vlc values. Changing these may improve speed and data cache needs 47// be aware though that decreasing them may need the number of stages that is 48// passed to get_vlc* to be increased. 49#define MV_VLC_BITS 9 50#define H263_MBTYPE_B_VLC_BITS 6 51#define CBPC_B_VLC_BITS 3 52 53static const int h263_mb_type_b_map[15]= { 54 MB_TYPE_DIRECT2 | MB_TYPE_L0L1, 55 MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP, 56 MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT, 57 MB_TYPE_L0 | MB_TYPE_16x16, 58 MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_16x16, 59 MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16, 60 MB_TYPE_L1 | MB_TYPE_16x16, 61 MB_TYPE_L1 | MB_TYPE_CBP | MB_TYPE_16x16, 62 MB_TYPE_L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16, 63 MB_TYPE_L0L1 | MB_TYPE_16x16, 64 MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_16x16, 65 MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16, 66 0, //stuffing 67 MB_TYPE_INTRA4x4 | MB_TYPE_CBP, 68 MB_TYPE_INTRA4x4 | MB_TYPE_CBP | MB_TYPE_QUANT, 69}; 70 71void ff_h263_show_pict_info(MpegEncContext *s){ 72 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ 73 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n", 74 s->qscale, av_get_picture_type_char(s->pict_type), 75 s->gb.size_in_bits, 1-s->no_rounding, 76 s->obmc ? " AP" : "", 77 s->umvplus ? " UMV" : "", 78 s->h263_long_vectors ? " LONG" : "", 79 s->h263_plus ? " +" : "", 80 s->h263_aic ? " AIC" : "", 81 s->alt_inter_vlc ? " AIV" : "", 82 s->modified_quant ? " MQ" : "", 83 s->loop_filter ? " LOOP" : "", 84 s->h263_slice_structured ? " SS" : "", 85 s->avctx->time_base.den, s->avctx->time_base.num 86 ); 87 } 88} 89 90/***********************************************/ 91/* decoding */ 92 93VLC ff_h263_intra_MCBPC_vlc; 94VLC ff_h263_inter_MCBPC_vlc; 95VLC ff_h263_cbpy_vlc; 96static VLC mv_vlc; 97static VLC h263_mbtype_b_vlc; 98static VLC cbpc_b_vlc; 99 100/* init vlcs */ 101 102/* XXX: find a better solution to handle static init */ 103av_cold void ff_h263_decode_init_vlc(void) 104{ 105 static volatile int done = 0; 106 107 if (!done) { 108 INIT_VLC_STATIC(&ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, 109 ff_h263_intra_MCBPC_bits, 1, 1, 110 ff_h263_intra_MCBPC_code, 1, 1, 72); 111 INIT_VLC_STATIC(&ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, 112 ff_h263_inter_MCBPC_bits, 1, 1, 113 ff_h263_inter_MCBPC_code, 1, 1, 198); 114 INIT_VLC_STATIC(&ff_h263_cbpy_vlc, CBPY_VLC_BITS, 16, 115 &ff_h263_cbpy_tab[0][1], 2, 1, 116 &ff_h263_cbpy_tab[0][0], 2, 1, 64); 117 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33, 118 &ff_mvtab[0][1], 2, 1, 119 &ff_mvtab[0][0], 2, 1, 538); 120 ff_init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]); 121 ff_init_rl(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]); 122 INIT_VLC_RL(ff_h263_rl_inter, 554); 123 INIT_VLC_RL(ff_rl_intra_aic, 554); 124 INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, 125 &ff_h263_mbtype_b_tab[0][1], 2, 1, 126 &ff_h263_mbtype_b_tab[0][0], 2, 1, 80); 127 INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, 128 &ff_cbpc_b_tab[0][1], 2, 1, 129 &ff_cbpc_b_tab[0][0], 2, 1, 8); 130 done = 1; 131 } 132} 133 134int ff_h263_decode_mba(MpegEncContext *s) 135{ 136 int i, mb_pos; 137 138 for(i=0; i<6; i++){ 139 if(s->mb_num-1 <= ff_mba_max[i]) break; 140 } 141 mb_pos= get_bits(&s->gb, ff_mba_length[i]); 142 s->mb_x= mb_pos % s->mb_width; 143 s->mb_y= mb_pos / s->mb_width; 144 145 return mb_pos; 146} 147 148/** 149 * Decode the group of blocks header or slice header. 150 * @return <0 if an error occurred 151 */ 152static int h263_decode_gob_header(MpegEncContext *s) 153{ 154 unsigned int val, gob_number; 155 int left; 156 157 /* Check for GOB Start Code */ 158 val = show_bits(&s->gb, 16); 159 if(val) 160 return -1; 161 162 /* We have a GBSC probably with GSTUFF */ 163 skip_bits(&s->gb, 16); /* Drop the zeros */ 164 left= get_bits_left(&s->gb); 165 //MN: we must check the bits left or we might end in a infinite loop (or segfault) 166 for(;left>13; left--){ 167 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ 168 } 169 if(left<=13) 170 return -1; 171 172 if(s->h263_slice_structured){ 173 if(get_bits1(&s->gb)==0) 174 return -1; 175 176 ff_h263_decode_mba(s); 177 178 if(s->mb_num > 1583) 179 if(get_bits1(&s->gb)==0) 180 return -1; 181 182 s->qscale = get_bits(&s->gb, 5); /* SQUANT */ 183 if(get_bits1(&s->gb)==0) 184 return -1; 185 skip_bits(&s->gb, 2); /* GFID */ 186 }else{ 187 gob_number = get_bits(&s->gb, 5); /* GN */ 188 s->mb_x= 0; 189 s->mb_y= s->gob_index* gob_number; 190 skip_bits(&s->gb, 2); /* GFID */ 191 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ 192 } 193 194 if(s->mb_y >= s->mb_height) 195 return -1; 196 197 if(s->qscale==0) 198 return -1; 199 200 return 0; 201} 202 203/** 204 * Decode the group of blocks / video packet header. 205 * @return bit position of the resync_marker, or <0 if none was found 206 */ 207int ff_h263_resync(MpegEncContext *s){ 208 int left, pos, ret; 209 210 if(s->codec_id==AV_CODEC_ID_MPEG4){ 211 skip_bits1(&s->gb); 212 align_get_bits(&s->gb); 213 } 214 215 if(show_bits(&s->gb, 16)==0){ 216 pos= get_bits_count(&s->gb); 217 if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4) 218 ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data); 219 else 220 ret= h263_decode_gob_header(s); 221 if(ret>=0) 222 return pos; 223 } 224 //OK, it's not where it is supposed to be ... 225 s->gb= s->last_resync_gb; 226 align_get_bits(&s->gb); 227 left= get_bits_left(&s->gb); 228 229 for(;left>16+1+5+5; left-=8){ 230 if(show_bits(&s->gb, 16)==0){ 231 GetBitContext bak= s->gb; 232 233 pos= get_bits_count(&s->gb); 234 if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4) 235 ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data); 236 else 237 ret= h263_decode_gob_header(s); 238 if(ret>=0) 239 return pos; 240 241 s->gb= bak; 242 } 243 skip_bits(&s->gb, 8); 244 } 245 246 return -1; 247} 248 249int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code) 250{ 251 int code, val, sign, shift; 252 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); 253 254 if (code == 0) 255 return pred; 256 if (code < 0) 257 return 0xffff; 258 259 sign = get_bits1(&s->gb); 260 shift = f_code - 1; 261 val = code; 262 if (shift) { 263 val = (val - 1) << shift; 264 val |= get_bits(&s->gb, shift); 265 val++; 266 } 267 if (sign) 268 val = -val; 269 val += pred; 270 271 /* modulo decoding */ 272 if (!s->h263_long_vectors) { 273 val = sign_extend(val, 5 + f_code); 274 } else { 275 /* horrible h263 long vector mode */ 276 if (pred < -31 && val < -63) 277 val += 64; 278 if (pred > 32 && val > 63) 279 val -= 64; 280 281 } 282 return val; 283} 284 285 286/* Decode RVLC of H.263+ UMV */ 287static int h263p_decode_umotion(MpegEncContext * s, int pred) 288{ 289 int code = 0, sign; 290 291 if (get_bits1(&s->gb)) /* Motion difference = 0 */ 292 return pred; 293 294 code = 2 + get_bits1(&s->gb); 295 296 while (get_bits1(&s->gb)) 297 { 298 code <<= 1; 299 code += get_bits1(&s->gb); 300 } 301 sign = code & 1; 302 code >>= 1; 303 304 code = (sign) ? (pred - code) : (pred + code); 305 av_dlog(s->avctx,"H.263+ UMV Motion = %d\n", code); 306 return code; 307 308} 309 310/** 311 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :) 312 */ 313static void preview_obmc(MpegEncContext *s){ 314 GetBitContext gb= s->gb; 315 316 int cbpc, i, pred_x, pred_y, mx, my; 317 int16_t *mot_val; 318 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride; 319 const int stride= s->b8_stride*2; 320 321 for(i=0; i<4; i++) 322 s->block_index[i]+= 2; 323 for(i=4; i<6; i++) 324 s->block_index[i]+= 1; 325 s->mb_x++; 326 327 av_assert2(s->pict_type == AV_PICTURE_TYPE_P); 328 329 do{ 330 if (get_bits1(&s->gb)) { 331 /* skip mb */ 332 mot_val = s->current_picture.motion_val[0][s->block_index[0]]; 333 mot_val[0 ]= mot_val[2 ]= 334 mot_val[0+stride]= mot_val[2+stride]= 0; 335 mot_val[1 ]= mot_val[3 ]= 336 mot_val[1+stride]= mot_val[3+stride]= 0; 337 338 s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 339 goto end; 340 } 341 cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); 342 }while(cbpc == 20); 343 344 if(cbpc & 4){ 345 s->current_picture.mb_type[xy] = MB_TYPE_INTRA; 346 }else{ 347 get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); 348 if (cbpc & 8) { 349 if(s->modified_quant){ 350 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); 351 else skip_bits(&s->gb, 5); 352 }else 353 skip_bits(&s->gb, 2); 354 } 355 356 if ((cbpc & 16) == 0) { 357 s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0; 358 /* 16x16 motion prediction */ 359 mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 360 if (s->umvplus) 361 mx = h263p_decode_umotion(s, pred_x); 362 else 363 mx = ff_h263_decode_motion(s, pred_x, 1); 364 365 if (s->umvplus) 366 my = h263p_decode_umotion(s, pred_y); 367 else 368 my = ff_h263_decode_motion(s, pred_y, 1); 369 370 mot_val[0 ]= mot_val[2 ]= 371 mot_val[0+stride]= mot_val[2+stride]= mx; 372 mot_val[1 ]= mot_val[3 ]= 373 mot_val[1+stride]= mot_val[3+stride]= my; 374 } else { 375 s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0; 376 for(i=0;i<4;i++) { 377 mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y); 378 if (s->umvplus) 379 mx = h263p_decode_umotion(s, pred_x); 380 else 381 mx = ff_h263_decode_motion(s, pred_x, 1); 382 383 if (s->umvplus) 384 my = h263p_decode_umotion(s, pred_y); 385 else 386 my = ff_h263_decode_motion(s, pred_y, 1); 387 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) 388 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ 389 mot_val[0] = mx; 390 mot_val[1] = my; 391 } 392 } 393 } 394end: 395 396 for(i=0; i<4; i++) 397 s->block_index[i]-= 2; 398 for(i=4; i<6; i++) 399 s->block_index[i]-= 1; 400 s->mb_x--; 401 402 s->gb= gb; 403} 404 405static void h263_decode_dquant(MpegEncContext *s){ 406 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; 407 408 if(s->modified_quant){ 409 if(get_bits1(&s->gb)) 410 s->qscale= ff_modified_quant_tab[get_bits1(&s->gb)][ s->qscale ]; 411 else 412 s->qscale= get_bits(&s->gb, 5); 413 }else 414 s->qscale += quant_tab[get_bits(&s->gb, 2)]; 415 ff_set_qscale(s, s->qscale); 416} 417 418static int h263_decode_block(MpegEncContext * s, int16_t * block, 419 int n, int coded) 420{ 421 int code, level, i, j, last, run; 422 RLTable *rl = &ff_h263_rl_inter; 423 const uint8_t *scan_table; 424 GetBitContext gb= s->gb; 425 426 scan_table = s->intra_scantable.permutated; 427 if (s->h263_aic && s->mb_intra) { 428 rl = &ff_rl_intra_aic; 429 i = 0; 430 if (s->ac_pred) { 431 if (s->h263_aic_dir) 432 scan_table = s->intra_v_scantable.permutated; /* left */ 433 else 434 scan_table = s->intra_h_scantable.permutated; /* top */ 435 } 436 } else if (s->mb_intra) { 437 /* DC coef */ 438 if(s->codec_id == AV_CODEC_ID_RV10){ 439#if CONFIG_RV10_DECODER 440 if (s->rv10_version == 3 && s->pict_type == AV_PICTURE_TYPE_I) { 441 int component, diff; 442 component = (n <= 3 ? 0 : n - 4 + 1); 443 level = s->last_dc[component]; 444 if (s->rv10_first_dc_coded[component]) { 445 diff = ff_rv_decode_dc(s, n); 446 if (diff == 0xffff) 447 return -1; 448 level += diff; 449 level = level & 0xff; /* handle wrap round */ 450 s->last_dc[component] = level; 451 } else { 452 s->rv10_first_dc_coded[component] = 1; 453 } 454 } else { 455 level = get_bits(&s->gb, 8); 456 if (level == 255) 457 level = 128; 458 } 459#endif 460 }else{ 461 level = get_bits(&s->gb, 8); 462 if((level&0x7F) == 0){ 463 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); 464 if(s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) 465 return -1; 466 } 467 if (level == 255) 468 level = 128; 469 } 470 block[0] = level; 471 i = 1; 472 } else { 473 i = 0; 474 } 475 if (!coded) { 476 if (s->mb_intra && s->h263_aic) 477 goto not_coded; 478 s->block_last_index[n] = i - 1; 479 return 0; 480 } 481retry: 482 for(;;) { 483 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2); 484 if (code < 0){ 485 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); 486 return -1; 487 } 488 if (code == rl->n) { 489 /* escape */ 490 if (CONFIG_FLV_DECODER && s->h263_flv > 1) { 491 ff_flv2_decode_ac_esc(&s->gb, &level, &run, &last); 492 } else { 493 last = get_bits1(&s->gb); 494 run = get_bits(&s->gb, 6); 495 level = (int8_t)get_bits(&s->gb, 8); 496 if(level == -128){ 497 if (s->codec_id == AV_CODEC_ID_RV10) { 498 /* XXX: should patch encoder too */ 499 level = get_sbits(&s->gb, 12); 500 }else{ 501 level = get_bits(&s->gb, 5); 502 level |= get_sbits(&s->gb, 6)<<5; 503 } 504 } 505 } 506 } else { 507 run = rl->table_run[code]; 508 level = rl->table_level[code]; 509 last = code >= rl->last; 510 if (get_bits1(&s->gb)) 511 level = -level; 512 } 513 i += run; 514 if (i >= 64){ 515 if(s->alt_inter_vlc && rl == &ff_h263_rl_inter && !s->mb_intra){ 516 //Looks like a hack but no, it's the way it is supposed to work ... 517 rl = &ff_rl_intra_aic; 518 i = 0; 519 s->gb= gb; 520 s->bdsp.clear_block(block); 521 goto retry; 522 } 523 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra); 524 return -1; 525 } 526 j = scan_table[i]; 527 block[j] = level; 528 if (last) 529 break; 530 i++; 531 } 532not_coded: 533 if (s->mb_intra && s->h263_aic) { 534 ff_h263_pred_acdc(s, block, n); 535 i = 63; 536 } 537 s->block_last_index[n] = i; 538 return 0; 539} 540 541static int h263_skip_b_part(MpegEncContext *s, int cbp) 542{ 543 LOCAL_ALIGNED_16(int16_t, dblock, [64]); 544 int i, mbi; 545 int bli[6]; 546 547 /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly 548 * but real value should be restored in order to be used later (in OBMC condition) 549 */ 550 mbi = s->mb_intra; 551 memcpy(bli, s->block_last_index, sizeof(bli)); 552 s->mb_intra = 0; 553 for (i = 0; i < 6; i++) { 554 if (h263_decode_block(s, dblock, i, cbp&32) < 0) 555 return -1; 556 cbp+=cbp; 557 } 558 s->mb_intra = mbi; 559 memcpy(s->block_last_index, bli, sizeof(bli)); 560 return 0; 561} 562 563static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb) 564{ 565 int c, mv = 1; 566 567 if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame 568 c = get_bits1(gb); 569 if (pb_frame == 2 && c) 570 mv = !get_bits1(gb); 571 } else { // h.263 Annex M improved PB-frame 572 mv = get_unary(gb, 0, 4) + 1; 573 c = mv & 1; 574 mv = !!(mv & 2); 575 } 576 if(c) 577 *cbpb = get_bits(gb, 6); 578 return mv; 579} 580 581int ff_h263_decode_mb(MpegEncContext *s, 582 int16_t block[6][64]) 583{ 584 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; 585 int16_t *mot_val; 586 const int xy= s->mb_x + s->mb_y * s->mb_stride; 587 int cbpb = 0, pb_mv_count = 0; 588 589 av_assert2(!s->h263_pred); 590 591 if (s->pict_type == AV_PICTURE_TYPE_P) { 592 do{ 593 if (get_bits1(&s->gb)) { 594 /* skip mb */ 595 s->mb_intra = 0; 596 for(i=0;i<6;i++) 597 s->block_last_index[i] = -1; 598 s->mv_dir = MV_DIR_FORWARD; 599 s->mv_type = MV_TYPE_16X16; 600 s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 601 s->mv[0][0][0] = 0; 602 s->mv[0][0][1] = 0; 603 s->mb_skipped = !(s->obmc | s->loop_filter); 604 goto end; 605 } 606 cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); 607 if (cbpc < 0){ 608 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); 609 return -1; 610 } 611 }while(cbpc == 20); 612 613 s->bdsp.clear_blocks(s->block[0]); 614 615 dquant = cbpc & 8; 616 s->mb_intra = ((cbpc & 4) != 0); 617 if (s->mb_intra) goto intra; 618 619 if(s->pb_frame && get_bits1(&s->gb)) 620 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); 621 cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); 622 623 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) 624 cbpy ^= 0xF; 625 626 cbp = (cbpc & 3) | (cbpy << 2); 627 if (dquant) { 628 h263_decode_dquant(s); 629 } 630 631 s->mv_dir = MV_DIR_FORWARD; 632 if ((cbpc & 16) == 0) { 633 s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0; 634 /* 16x16 motion prediction */ 635 s->mv_type = MV_TYPE_16X16; 636 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 637 if (s->umvplus) 638 mx = h263p_decode_umotion(s, pred_x); 639 else 640 mx = ff_h263_decode_motion(s, pred_x, 1); 641 642 if (mx >= 0xffff) 643 return -1; 644 645 if (s->umvplus) 646 my = h263p_decode_umotion(s, pred_y); 647 else 648 my = ff_h263_decode_motion(s, pred_y, 1); 649 650 if (my >= 0xffff) 651 return -1; 652 s->mv[0][0][0] = mx; 653 s->mv[0][0][1] = my; 654 655 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) 656 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ 657 } else { 658 s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0; 659 s->mv_type = MV_TYPE_8X8; 660 for(i=0;i<4;i++) { 661 mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y); 662 if (s->umvplus) 663 mx = h263p_decode_umotion(s, pred_x); 664 else 665 mx = ff_h263_decode_motion(s, pred_x, 1); 666 if (mx >= 0xffff) 667 return -1; 668 669 if (s->umvplus) 670 my = h263p_decode_umotion(s, pred_y); 671 else 672 my = ff_h263_decode_motion(s, pred_y, 1); 673 if (my >= 0xffff) 674 return -1; 675 s->mv[0][i][0] = mx; 676 s->mv[0][i][1] = my; 677 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) 678 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ 679 mot_val[0] = mx; 680 mot_val[1] = my; 681 } 682 } 683 } else if(s->pict_type==AV_PICTURE_TYPE_B) { 684 int mb_type; 685 const int stride= s->b8_stride; 686 int16_t *mot_val0 = s->current_picture.motion_val[0][2 * (s->mb_x + s->mb_y * stride)]; 687 int16_t *mot_val1 = s->current_picture.motion_val[1][2 * (s->mb_x + s->mb_y * stride)]; 688// const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride; 689 690 //FIXME ugly 691 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= 692 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= 693 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= 694 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; 695 696 do{ 697 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2); 698 if (mb_type < 0){ 699 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); 700 return -1; 701 } 702 703 mb_type= h263_mb_type_b_map[ mb_type ]; 704 }while(!mb_type); 705 706 s->mb_intra = IS_INTRA(mb_type); 707 if(HAS_CBP(mb_type)){ 708 s->bdsp.clear_blocks(s->block[0]); 709 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1); 710 if(s->mb_intra){ 711 dquant = IS_QUANT(mb_type); 712 goto intra; 713 } 714 715 cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); 716 717 if (cbpy < 0){ 718 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); 719 return -1; 720 } 721 722 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) 723 cbpy ^= 0xF; 724 725 cbp = (cbpc & 3) | (cbpy << 2); 726 }else 727 cbp=0; 728 729 av_assert2(!s->mb_intra); 730 731 if(IS_QUANT(mb_type)){ 732 h263_decode_dquant(s); 733 } 734 735 if(IS_DIRECT(mb_type)){ 736 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; 737 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); 738 }else{ 739 s->mv_dir = 0; 740 s->mv_type= MV_TYPE_16X16; 741//FIXME UMV 742 743 if(USES_LIST(mb_type, 0)){ 744 int16_t *mot_val= ff_h263_pred_motion(s, 0, 0, &mx, &my); 745 s->mv_dir = MV_DIR_FORWARD; 746 747 mx = ff_h263_decode_motion(s, mx, 1); 748 my = ff_h263_decode_motion(s, my, 1); 749 750 s->mv[0][0][0] = mx; 751 s->mv[0][0][1] = my; 752 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; 753 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; 754 } 755 756 if(USES_LIST(mb_type, 1)){ 757 int16_t *mot_val= ff_h263_pred_motion(s, 0, 1, &mx, &my); 758 s->mv_dir |= MV_DIR_BACKWARD; 759 760 mx = ff_h263_decode_motion(s, mx, 1); 761 my = ff_h263_decode_motion(s, my, 1); 762 763 s->mv[1][0][0] = mx; 764 s->mv[1][0][1] = my; 765 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; 766 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; 767 } 768 } 769 770 s->current_picture.mb_type[xy] = mb_type; 771 } else { /* I-Frame */ 772 do{ 773 cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); 774 if (cbpc < 0){ 775 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); 776 return -1; 777 } 778 }while(cbpc == 8); 779 780 s->bdsp.clear_blocks(s->block[0]); 781 782 dquant = cbpc & 4; 783 s->mb_intra = 1; 784intra: 785 s->current_picture.mb_type[xy] = MB_TYPE_INTRA; 786 if (s->h263_aic) { 787 s->ac_pred = get_bits1(&s->gb); 788 if(s->ac_pred){ 789 s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED; 790 791 s->h263_aic_dir = get_bits1(&s->gb); 792 } 793 }else 794 s->ac_pred = 0; 795 796 if(s->pb_frame && get_bits1(&s->gb)) 797 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); 798 cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); 799 if(cbpy<0){ 800 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); 801 return -1; 802 } 803 cbp = (cbpc & 3) | (cbpy << 2); 804 if (dquant) { 805 h263_decode_dquant(s); 806 } 807 808 pb_mv_count += !!s->pb_frame; 809 } 810 811 while(pb_mv_count--){ 812 ff_h263_decode_motion(s, 0, 1); 813 ff_h263_decode_motion(s, 0, 1); 814 } 815 816 /* decode each block */ 817 for (i = 0; i < 6; i++) { 818 if (h263_decode_block(s, block[i], i, cbp&32) < 0) 819 return -1; 820 cbp+=cbp; 821 } 822 823 if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0) 824 return -1; 825 if(s->obmc && !s->mb_intra){ 826 if(s->pict_type == AV_PICTURE_TYPE_P && s->mb_x+1<s->mb_width && s->mb_num_left != 1) 827 preview_obmc(s); 828 } 829end: 830 831 /* per-MB end of slice check */ 832 { 833 int v= show_bits(&s->gb, 16); 834 835 if (get_bits_left(&s->gb) < 16) { 836 v >>= 16 - get_bits_left(&s->gb); 837 } 838 839 if(v==0) 840 return SLICE_END; 841 } 842 843 return SLICE_OK; 844} 845 846/* most is hardcoded. should extend to handle all h263 streams */ 847int ff_h263_decode_picture_header(MpegEncContext *s) 848{ 849 int format, width, height, i; 850 uint32_t startcode; 851 852 align_get_bits(&s->gb); 853 854 if (show_bits(&s->gb, 2) == 2 && s->avctx->frame_number == 0) { 855 av_log(s->avctx, AV_LOG_WARNING, "Header looks like RTP instead of H.263\n"); 856 } 857 858 startcode= get_bits(&s->gb, 22-8); 859 860 for(i= get_bits_left(&s->gb); i>24; i-=8) { 861 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; 862 863 if(startcode == 0x20) 864 break; 865 } 866 867 if (startcode != 0x20) { 868 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); 869 return -1; 870 } 871 /* temporal reference */ 872 i = get_bits(&s->gb, 8); /* picture timestamp */ 873 if( (s->picture_number&~0xFF)+i < s->picture_number) 874 i+= 256; 875 s->picture_number= (s->picture_number&~0xFF) + i; 876 877 /* PTYPE starts here */ 878 if (get_bits1(&s->gb) != 1) { 879 /* marker */ 880 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); 881 return -1; 882 } 883 if (get_bits1(&s->gb) != 0) { 884 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); 885 return -1; /* h263 id */ 886 } 887 skip_bits1(&s->gb); /* split screen off */ 888 skip_bits1(&s->gb); /* camera off */ 889 skip_bits1(&s->gb); /* freeze picture release off */ 890 891 format = get_bits(&s->gb, 3); 892 /* 893 0 forbidden 894 1 sub-QCIF 895 10 QCIF 896 7 extended PTYPE (PLUSPTYPE) 897 */ 898 899 if (format != 7 && format != 6) { 900 s->h263_plus = 0; 901 /* H.263v1 */ 902 width = ff_h263_format[format][0]; 903 height = ff_h263_format[format][1]; 904 if (!width) 905 return -1; 906 907 s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb); 908 909 s->h263_long_vectors = get_bits1(&s->gb); 910 911 if (get_bits1(&s->gb) != 0) { 912 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n"); 913 return -1; /* SAC: off */ 914 } 915 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ 916 s->unrestricted_mv = s->h263_long_vectors || s->obmc; 917 918 s->pb_frame = get_bits1(&s->gb); 919 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); 920 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ 921 922 s->width = width; 923 s->height = height; 924 s->avctx->sample_aspect_ratio= (AVRational){12,11}; 925 s->avctx->time_base= (AVRational){1001, 30000}; 926 } else { 927 int ufep; 928 929 /* H.263v2 */ 930 s->h263_plus = 1; 931 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ 932 933 /* ufep other than 0 and 1 are reserved */ 934 if (ufep == 1) { 935 /* OPPTYPE */ 936 format = get_bits(&s->gb, 3); 937 av_dlog(s->avctx, "ufep=1, format: %d\n", format); 938 s->custom_pcf= get_bits1(&s->gb); 939 s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */ 940 if (get_bits1(&s->gb) != 0) { 941 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); 942 } 943 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ 944 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */ 945 s->loop_filter= get_bits1(&s->gb); 946 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter; 947 if(s->avctx->lowres) 948 s->loop_filter = 0; 949 950 s->h263_slice_structured= get_bits1(&s->gb); 951 if (get_bits1(&s->gb) != 0) { 952 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n"); 953 } 954 if (get_bits1(&s->gb) != 0) { 955 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n"); 956 } 957 s->alt_inter_vlc= get_bits1(&s->gb); 958 s->modified_quant= get_bits1(&s->gb); 959 if(s->modified_quant) 960 s->chroma_qscale_table= ff_h263_chroma_qscale_table; 961 962 skip_bits(&s->gb, 1); /* Prevent start code emulation */ 963 964 skip_bits(&s->gb, 3); /* Reserved */ 965 } else if (ufep != 0) { 966 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); 967 return -1; 968 } 969 970 /* MPPTYPE */ 971 s->pict_type = get_bits(&s->gb, 3); 972 switch(s->pict_type){ 973 case 0: s->pict_type= AV_PICTURE_TYPE_I;break; 974 case 1: s->pict_type= AV_PICTURE_TYPE_P;break; 975 case 2: s->pict_type= AV_PICTURE_TYPE_P;s->pb_frame = 3;break; 976 case 3: s->pict_type= AV_PICTURE_TYPE_B;break; 977 case 7: s->pict_type= AV_PICTURE_TYPE_I;break; //ZYGO 978 default: 979 return -1; 980 } 981 skip_bits(&s->gb, 2); 982 s->no_rounding = get_bits1(&s->gb); 983 skip_bits(&s->gb, 4); 984 985 /* Get the picture dimensions */ 986 if (ufep) { 987 if (format == 6) { 988 /* Custom Picture Format (CPFMT) */ 989 s->aspect_ratio_info = get_bits(&s->gb, 4); 990 av_dlog(s->avctx, "aspect: %d\n", s->aspect_ratio_info); 991 /* aspect ratios: 992 0 - forbidden 993 1 - 1:1 994 2 - 12:11 (CIF 4:3) 995 3 - 10:11 (525-type 4:3) 996 4 - 16:11 (CIF 16:9) 997 5 - 40:33 (525-type 16:9) 998 6-14 - reserved 999 */ 1000 width = (get_bits(&s->gb, 9) + 1) * 4; 1001 skip_bits1(&s->gb); 1002 height = get_bits(&s->gb, 9) * 4; 1003 av_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height); 1004 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { 1005 /* aspected dimensions */ 1006 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); 1007 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); 1008 }else{ 1009 s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info]; 1010 } 1011 } else { 1012 width = ff_h263_format[format][0]; 1013 height = ff_h263_format[format][1]; 1014 s->avctx->sample_aspect_ratio= (AVRational){12,11}; 1015 } 1016 s->avctx->sample_aspect_ratio.den <<= s->ehc_mode; 1017 if ((width == 0) || (height == 0)) 1018 return -1; 1019 s->width = width; 1020 s->height = height; 1021 1022 if(s->custom_pcf){ 1023 int gcd; 1024 s->avctx->time_base.den= 1800000; 1025 s->avctx->time_base.num= 1000 + get_bits1(&s->gb); 1026 s->avctx->time_base.num*= get_bits(&s->gb, 7); 1027 if(s->avctx->time_base.num == 0){ 1028 av_log(s, AV_LOG_ERROR, "zero framerate\n"); 1029 return -1; 1030 } 1031 gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num); 1032 s->avctx->time_base.den /= gcd; 1033 s->avctx->time_base.num /= gcd; 1034 }else{ 1035 s->avctx->time_base= (AVRational){1001, 30000}; 1036 } 1037 } 1038 1039 if(s->custom_pcf){ 1040 skip_bits(&s->gb, 2); //extended Temporal reference 1041 } 1042 1043 if (ufep) { 1044 if (s->umvplus) { 1045 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ 1046 skip_bits1(&s->gb); 1047 } 1048 if(s->h263_slice_structured){ 1049 if (get_bits1(&s->gb) != 0) { 1050 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); 1051 } 1052 if (get_bits1(&s->gb) != 0) { 1053 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n"); 1054 } 1055 } 1056 } 1057 1058 s->qscale = get_bits(&s->gb, 5); 1059 } 1060 1061 if (s->width == 0 || s->height == 0) { 1062 av_log(s->avctx, AV_LOG_ERROR, "dimensions 0\n"); 1063 return -1; 1064 } 1065 s->mb_width = (s->width + 15) / 16; 1066 s->mb_height = (s->height + 15) / 16; 1067 s->mb_num = s->mb_width * s->mb_height; 1068 1069 if (s->pb_frame) { 1070 skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */ 1071 if (s->custom_pcf) 1072 skip_bits(&s->gb, 2); //extended Temporal reference 1073 skip_bits(&s->gb, 2); /* Quantization information for B-pictures */ 1074 } 1075 1076 if (s->pict_type!=AV_PICTURE_TYPE_B) { 1077 s->time = s->picture_number; 1078 s->pp_time = s->time - s->last_non_b_time; 1079 s->last_non_b_time = s->time; 1080 }else{ 1081 s->time = s->picture_number; 1082 s->pb_time = s->pp_time - (s->last_non_b_time - s->time); 1083 if (s->pp_time <=s->pb_time || 1084 s->pp_time <= s->pp_time - s->pb_time || 1085 s->pp_time <= 0){ 1086 s->pp_time = 2; 1087 s->pb_time = 1; 1088 } 1089 ff_mpeg4_init_direct_mv(s); 1090 } 1091 1092 /* PEI */ 1093 if (skip_1stop_8data_bits(&s->gb) < 0) 1094 return AVERROR_INVALIDDATA; 1095 1096 if(s->h263_slice_structured){ 1097 if (get_bits1(&s->gb) != 1) { 1098 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n"); 1099 return -1; 1100 } 1101 1102 ff_h263_decode_mba(s); 1103 1104 if (get_bits1(&s->gb) != 1) { 1105 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n"); 1106 return -1; 1107 } 1108 } 1109 s->f_code = 1; 1110 1111 if(s->h263_aic){ 1112 s->y_dc_scale_table= 1113 s->c_dc_scale_table= ff_aic_dc_scale_table; 1114 }else{ 1115 s->y_dc_scale_table= 1116 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; 1117 } 1118 1119 ff_h263_show_pict_info(s); 1120 if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO") && get_bits_left(&s->gb) >= 85 + 13*3*16 + 50){ 1121 int i,j; 1122 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); 1123 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 1124 for(i=0; i<13; i++){ 1125 for(j=0; j<3; j++){ 1126 int v= get_bits(&s->gb, 8); 1127 v |= get_sbits(&s->gb, 8)<<8; 1128 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v); 1129 } 1130 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 1131 } 1132 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); 1133 } 1134 1135 return 0; 1136} 1137