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