1/* 2 * H261 decoder 3 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> 4 * Copyright (c) 2004 Maarten Daniels 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 * H.261 decoder. 26 */ 27 28#include "dsputil.h" 29#include "avcodec.h" 30#include "mpegvideo.h" 31#include "h263.h" 32#include "h261.h" 33#include "h261data.h" 34 35#define H261_MBA_VLC_BITS 9 36#define H261_MTYPE_VLC_BITS 6 37#define H261_MV_VLC_BITS 7 38#define H261_CBP_VLC_BITS 9 39#define TCOEFF_VLC_BITS 9 40#define MBA_STUFFING 33 41#define MBA_STARTCODE 34 42 43extern uint8_t ff_h261_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3]; 44 45static VLC h261_mba_vlc; 46static VLC h261_mtype_vlc; 47static VLC h261_mv_vlc; 48static VLC h261_cbp_vlc; 49 50static int h261_decode_block(H261Context * h, DCTELEM * block, int n, int coded); 51 52static av_cold void h261_decode_init_vlc(H261Context *h){ 53 static int done = 0; 54 55 if(!done){ 56 done = 1; 57 INIT_VLC_STATIC(&h261_mba_vlc, H261_MBA_VLC_BITS, 35, 58 h261_mba_bits, 1, 1, 59 h261_mba_code, 1, 1, 662); 60 INIT_VLC_STATIC(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10, 61 h261_mtype_bits, 1, 1, 62 h261_mtype_code, 1, 1, 80); 63 INIT_VLC_STATIC(&h261_mv_vlc, H261_MV_VLC_BITS, 17, 64 &h261_mv_tab[0][1], 2, 1, 65 &h261_mv_tab[0][0], 2, 1, 144); 66 INIT_VLC_STATIC(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63, 67 &h261_cbp_tab[0][1], 2, 1, 68 &h261_cbp_tab[0][0], 2, 1, 512); 69 init_rl(&h261_rl_tcoeff, ff_h261_rl_table_store); 70 INIT_VLC_RL(h261_rl_tcoeff, 552); 71 } 72} 73 74static av_cold int h261_decode_init(AVCodecContext *avctx){ 75 H261Context *h= avctx->priv_data; 76 MpegEncContext * const s = &h->s; 77 78 // set defaults 79 MPV_decode_defaults(s); 80 s->avctx = avctx; 81 82 s->width = s->avctx->coded_width; 83 s->height = s->avctx->coded_height; 84 s->codec_id = s->avctx->codec->id; 85 86 s->out_format = FMT_H261; 87 s->low_delay= 1; 88 avctx->pix_fmt= PIX_FMT_YUV420P; 89 90 s->codec_id= avctx->codec->id; 91 92 h261_decode_init_vlc(h); 93 94 h->gob_start_code_skipped = 0; 95 96 return 0; 97} 98 99/** 100 * decodes the group of blocks header or slice header. 101 * @return <0 if an error occurred 102 */ 103static int h261_decode_gob_header(H261Context *h){ 104 unsigned int val; 105 MpegEncContext * const s = &h->s; 106 107 if ( !h->gob_start_code_skipped ){ 108 /* Check for GOB Start Code */ 109 val = show_bits(&s->gb, 15); 110 if(val) 111 return -1; 112 113 /* We have a GBSC */ 114 skip_bits(&s->gb, 16); 115 } 116 117 h->gob_start_code_skipped = 0; 118 119 h->gob_number = get_bits(&s->gb, 4); /* GN */ 120 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ 121 122 /* Check if gob_number is valid */ 123 if (s->mb_height==18){ //cif 124 if ((h->gob_number<=0) || (h->gob_number>12)) 125 return -1; 126 } 127 else{ //qcif 128 if ((h->gob_number!=1) && (h->gob_number!=3) && (h->gob_number!=5)) 129 return -1; 130 } 131 132 /* GEI */ 133 while (get_bits1(&s->gb) != 0) { 134 skip_bits(&s->gb, 8); 135 } 136 137 if(s->qscale==0) { 138 av_log(s->avctx, AV_LOG_ERROR, "qscale has forbidden 0 value\n"); 139 if (s->avctx->error_recognition >= FF_ER_COMPLIANT) 140 return -1; 141 } 142 143 // For the first transmitted macroblock in a GOB, MBA is the absolute address. For 144 // subsequent macroblocks, MBA is the difference between the absolute addresses of 145 // the macroblock and the last transmitted macroblock. 146 h->current_mba = 0; 147 h->mba_diff = 0; 148 149 return 0; 150} 151 152/** 153 * decodes the group of blocks / video packet header. 154 * @return <0 if no resync found 155 */ 156static int ff_h261_resync(H261Context *h){ 157 MpegEncContext * const s = &h->s; 158 int left, ret; 159 160 if ( h->gob_start_code_skipped ){ 161 ret= h261_decode_gob_header(h); 162 if(ret>=0) 163 return 0; 164 } 165 else{ 166 if(show_bits(&s->gb, 15)==0){ 167 ret= h261_decode_gob_header(h); 168 if(ret>=0) 169 return 0; 170 } 171 //OK, it is not where it is supposed to be ... 172 s->gb= s->last_resync_gb; 173 align_get_bits(&s->gb); 174 left= get_bits_left(&s->gb); 175 176 for(;left>15+1+4+5; left-=8){ 177 if(show_bits(&s->gb, 15)==0){ 178 GetBitContext bak= s->gb; 179 180 ret= h261_decode_gob_header(h); 181 if(ret>=0) 182 return 0; 183 184 s->gb= bak; 185 } 186 skip_bits(&s->gb, 8); 187 } 188 } 189 190 return -1; 191} 192 193/** 194 * decodes skipped macroblocks 195 * @return 0 196 */ 197static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 ) 198{ 199 MpegEncContext * const s = &h->s; 200 int i; 201 202 s->mb_intra = 0; 203 204 for(i=mba1; i<mba2; i++){ 205 int j, xy; 206 207 s->mb_x= ((h->gob_number-1) % 2) * 11 + i % 11; 208 s->mb_y= ((h->gob_number-1) / 2) * 3 + i / 11; 209 xy = s->mb_x + s->mb_y * s->mb_stride; 210 ff_init_block_index(s); 211 ff_update_block_index(s); 212 213 for(j=0;j<6;j++) 214 s->block_last_index[j] = -1; 215 216 s->mv_dir = MV_DIR_FORWARD; 217 s->mv_type = MV_TYPE_16X16; 218 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 219 s->mv[0][0][0] = 0; 220 s->mv[0][0][1] = 0; 221 s->mb_skipped = 1; 222 h->mtype &= ~MB_TYPE_H261_FIL; 223 224 MPV_decode_mb(s, s->block); 225 } 226 227 return 0; 228} 229 230static int decode_mv_component(GetBitContext *gb, int v){ 231 int mv_diff = get_vlc2(gb, h261_mv_vlc.table, H261_MV_VLC_BITS, 2); 232 233 /* check if mv_diff is valid */ 234 if ( mv_diff < 0 ) 235 return v; 236 237 mv_diff = mvmap[mv_diff]; 238 239 if(mv_diff && !get_bits1(gb)) 240 mv_diff= -mv_diff; 241 242 v += mv_diff; 243 if (v <=-16) v+= 32; 244 else if(v >= 16) v-= 32; 245 246 return v; 247} 248 249static int h261_decode_mb(H261Context *h){ 250 MpegEncContext * const s = &h->s; 251 int i, cbp, xy; 252 253 cbp = 63; 254 // Read mba 255 do{ 256 h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc.table, H261_MBA_VLC_BITS, 2); 257 258 /* Check for slice end */ 259 /* NOTE: GOB can be empty (no MB data) or exist only of MBA_stuffing */ 260 if (h->mba_diff == MBA_STARTCODE){ // start code 261 h->gob_start_code_skipped = 1; 262 return SLICE_END; 263 } 264 } 265 while( h->mba_diff == MBA_STUFFING ); // stuffing 266 267 if ( h->mba_diff < 0 ){ 268 if ( get_bits_count(&s->gb) + 7 >= s->gb.size_in_bits ) 269 return SLICE_END; 270 271 av_log(s->avctx, AV_LOG_ERROR, "illegal mba at %d %d\n", s->mb_x, s->mb_y); 272 return SLICE_ERROR; 273 } 274 275 h->mba_diff += 1; 276 h->current_mba += h->mba_diff; 277 278 if ( h->current_mba > MBA_STUFFING ) 279 return SLICE_ERROR; 280 281 s->mb_x= ((h->gob_number-1) % 2) * 11 + ((h->current_mba-1) % 11); 282 s->mb_y= ((h->gob_number-1) / 2) * 3 + ((h->current_mba-1) / 11); 283 xy = s->mb_x + s->mb_y * s->mb_stride; 284 ff_init_block_index(s); 285 ff_update_block_index(s); 286 287 // Read mtype 288 h->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2); 289 h->mtype = h261_mtype_map[h->mtype]; 290 291 // Read mquant 292 if ( IS_QUANT ( h->mtype ) ){ 293 ff_set_qscale(s, get_bits(&s->gb, 5)); 294 } 295 296 s->mb_intra = IS_INTRA4x4(h->mtype); 297 298 // Read mv 299 if ( IS_16X16 ( h->mtype ) ){ 300 // Motion vector data is included for all MC macroblocks. MVD is obtained from the macroblock vector by subtracting the 301 // vector of the preceding macroblock. For this calculation the vector of the preceding macroblock is regarded as zero in the 302 // following three situations: 303 // 1) evaluating MVD for macroblocks 1, 12 and 23; 304 // 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1; 305 // 3) MTYPE of the previous macroblock was not MC. 306 if ( ( h->current_mba == 1 ) || ( h->current_mba == 12 ) || ( h->current_mba == 23 ) || 307 ( h->mba_diff != 1)) 308 { 309 h->current_mv_x = 0; 310 h->current_mv_y = 0; 311 } 312 313 h->current_mv_x= decode_mv_component(&s->gb, h->current_mv_x); 314 h->current_mv_y= decode_mv_component(&s->gb, h->current_mv_y); 315 }else{ 316 h->current_mv_x = 0; 317 h->current_mv_y = 0; 318 } 319 320 // Read cbp 321 if ( HAS_CBP( h->mtype ) ){ 322 cbp = get_vlc2(&s->gb, h261_cbp_vlc.table, H261_CBP_VLC_BITS, 2) + 1; 323 } 324 325 if(s->mb_intra){ 326 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; 327 goto intra; 328 } 329 330 //set motion vectors 331 s->mv_dir = MV_DIR_FORWARD; 332 s->mv_type = MV_TYPE_16X16; 333 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 334 s->mv[0][0][0] = h->current_mv_x * 2;//gets divided by 2 in motion compensation 335 s->mv[0][0][1] = h->current_mv_y * 2; 336 337intra: 338 /* decode each block */ 339 if(s->mb_intra || HAS_CBP(h->mtype)){ 340 s->dsp.clear_blocks(s->block[0]); 341 for (i = 0; i < 6; i++) { 342 if (h261_decode_block(h, s->block[i], i, cbp&32) < 0){ 343 return SLICE_ERROR; 344 } 345 cbp+=cbp; 346 } 347 }else{ 348 for (i = 0; i < 6; i++) 349 s->block_last_index[i]= -1; 350 } 351 352 MPV_decode_mb(s, s->block); 353 354 return SLICE_OK; 355} 356 357/** 358 * decodes a macroblock 359 * @return <0 if an error occurred 360 */ 361static int h261_decode_block(H261Context * h, DCTELEM * block, 362 int n, int coded) 363{ 364 MpegEncContext * const s = &h->s; 365 int code, level, i, j, run; 366 RLTable *rl = &h261_rl_tcoeff; 367 const uint8_t *scan_table; 368 369 // For the variable length encoding there are two code tables, one being used for 370 // the first transmitted LEVEL in INTER, INTER+MC and INTER+MC+FIL blocks, the second 371 // for all other LEVELs except the first one in INTRA blocks which is fixed length 372 // coded with 8 bits. 373 // NOTE: the two code tables only differ in one VLC so we handle that manually. 374 scan_table = s->intra_scantable.permutated; 375 if (s->mb_intra){ 376 /* DC coef */ 377 level = get_bits(&s->gb, 8); 378 // 0 (00000000b) and -128 (10000000b) are FORBIDDEN 379 if((level&0x7F) == 0){ 380 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); 381 return -1; 382 } 383 // The code 1000 0000 is not used, the reconstruction level of 1024 being coded as 1111 1111. 384 if (level == 255) 385 level = 128; 386 block[0] = level; 387 i = 1; 388 }else if(coded){ 389 // Run Level Code 390 // EOB Not possible for first level when cbp is available (that's why the table is different) 391 // 0 1 1s 392 // * * 0* 393 int check = show_bits(&s->gb, 2); 394 i = 0; 395 if ( check & 0x2 ){ 396 skip_bits(&s->gb, 2); 397 block[0] = ( check & 0x1 ) ? -1 : 1; 398 i = 1; 399 } 400 }else{ 401 i = 0; 402 } 403 if(!coded){ 404 s->block_last_index[n] = i - 1; 405 return 0; 406 } 407 for(;;){ 408 code = get_vlc2(&s->gb, rl->vlc.table, TCOEFF_VLC_BITS, 2); 409 if (code < 0){ 410 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); 411 return -1; 412 } 413 if (code == rl->n) { 414 /* escape */ 415 // The remaining combinations of (run, level) are encoded with a 20-bit word consisting of 6 bits escape, 6 bits run and 8 bits level. 416 run = get_bits(&s->gb, 6); 417 level = get_sbits(&s->gb, 8); 418 }else if(code == 0){ 419 break; 420 }else{ 421 run = rl->table_run[code]; 422 level = rl->table_level[code]; 423 if (get_bits1(&s->gb)) 424 level = -level; 425 } 426 i += run; 427 if (i >= 64){ 428 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y); 429 return -1; 430 } 431 j = scan_table[i]; 432 block[j] = level; 433 i++; 434 } 435 s->block_last_index[n] = i-1; 436 return 0; 437} 438 439/** 440 * decodes the H261 picture header. 441 * @return <0 if no startcode found 442 */ 443static int h261_decode_picture_header(H261Context *h){ 444 MpegEncContext * const s = &h->s; 445 int format, i; 446 uint32_t startcode= 0; 447 448 for(i= get_bits_left(&s->gb); i>24; i-=1){ 449 startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF; 450 451 if(startcode == 0x10) 452 break; 453 } 454 455 if (startcode != 0x10){ 456 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); 457 return -1; 458 } 459 460 /* temporal reference */ 461 i= get_bits(&s->gb, 5); /* picture timestamp */ 462 if(i < (s->picture_number&31)) 463 i += 32; 464 s->picture_number = (s->picture_number&~31) + i; 465 466 s->avctx->time_base= (AVRational){1001, 30000}; 467 s->current_picture.pts= s->picture_number; 468 469 470 /* PTYPE starts here */ 471 skip_bits1(&s->gb); /* split screen off */ 472 skip_bits1(&s->gb); /* camera off */ 473 skip_bits1(&s->gb); /* freeze picture release off */ 474 475 format = get_bits1(&s->gb); 476 477 //only 2 formats possible 478 if (format == 0){//QCIF 479 s->width = 176; 480 s->height = 144; 481 s->mb_width = 11; 482 s->mb_height = 9; 483 }else{//CIF 484 s->width = 352; 485 s->height = 288; 486 s->mb_width = 22; 487 s->mb_height = 18; 488 } 489 490 s->mb_num = s->mb_width * s->mb_height; 491 492 skip_bits1(&s->gb); /* still image mode off */ 493 skip_bits1(&s->gb); /* Reserved */ 494 495 /* PEI */ 496 while (get_bits1(&s->gb) != 0){ 497 skip_bits(&s->gb, 8); 498 } 499 500 // h261 has no I-FRAMES, but if we pass FF_I_TYPE for the first frame, the codec crashes if it does 501 // not contain all I-blocks (e.g. when a packet is lost) 502 s->pict_type = FF_P_TYPE; 503 504 h->gob_number = 0; 505 return 0; 506} 507 508static int h261_decode_gob(H261Context *h){ 509 MpegEncContext * const s = &h->s; 510 511 ff_set_qscale(s, s->qscale); 512 513 /* decode mb's */ 514 while(h->current_mba <= MBA_STUFFING) 515 { 516 int ret; 517 /* DCT & quantize */ 518 ret= h261_decode_mb(h); 519 if(ret<0){ 520 if(ret==SLICE_END){ 521 h261_decode_mb_skipped(h, h->current_mba, 33); 522 return 0; 523 } 524 av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", s->mb_x + s->mb_y*s->mb_stride); 525 return -1; 526 } 527 528 h261_decode_mb_skipped(h, h->current_mba-h->mba_diff, h->current_mba-1); 529 } 530 531 return -1; 532} 533 534/** 535 * returns the number of bytes consumed for building the current frame 536 */ 537static int get_consumed_bytes(MpegEncContext *s, int buf_size){ 538 int pos= get_bits_count(&s->gb)>>3; 539 if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...) 540 if(pos+10>buf_size) pos=buf_size; // oops ;) 541 542 return pos; 543} 544 545static int h261_decode_frame(AVCodecContext *avctx, 546 void *data, int *data_size, 547 AVPacket *avpkt) 548{ 549 const uint8_t *buf = avpkt->data; 550 int buf_size = avpkt->size; 551 H261Context *h= avctx->priv_data; 552 MpegEncContext *s = &h->s; 553 int ret; 554 AVFrame *pict = data; 555 556 dprintf(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size); 557 dprintf(avctx, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]); 558 s->flags= avctx->flags; 559 s->flags2= avctx->flags2; 560 561 h->gob_start_code_skipped=0; 562 563retry: 564 565 init_get_bits(&s->gb, buf, buf_size*8); 566 567 if(!s->context_initialized){ 568 if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix 569 return -1; 570 } 571 572 //we need to set current_picture_ptr before reading the header, otherwise we cannot store anyting im there 573 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){ 574 int i= ff_find_unused_picture(s, 0); 575 s->current_picture_ptr= &s->picture[i]; 576 } 577 578 ret = h261_decode_picture_header(h); 579 580 /* skip if the header was thrashed */ 581 if (ret < 0){ 582 av_log(s->avctx, AV_LOG_ERROR, "header damaged\n"); 583 return -1; 584 } 585 586 if (s->width != avctx->coded_width || s->height != avctx->coded_height){ 587 ParseContext pc= s->parse_context; //FIXME move this demuxing hack to libavformat 588 s->parse_context.buffer=0; 589 MPV_common_end(s); 590 s->parse_context= pc; 591 } 592 if (!s->context_initialized) { 593 avcodec_set_dimensions(avctx, s->width, s->height); 594 595 goto retry; 596 } 597 598 // for hurry_up==5 599 s->current_picture.pict_type= s->pict_type; 600 s->current_picture.key_frame= s->pict_type == FF_I_TYPE; 601 602 /* skip everything if we are in a hurry>=5 */ 603 if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size); 604 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE) 605 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE) 606 || avctx->skip_frame >= AVDISCARD_ALL) 607 return get_consumed_bytes(s, buf_size); 608 609 if(MPV_frame_start(s, avctx) < 0) 610 return -1; 611 612 ff_er_frame_start(s); 613 614 /* decode each macroblock */ 615 s->mb_x=0; 616 s->mb_y=0; 617 618 while(h->gob_number < (s->mb_height==18 ? 12 : 5)){ 619 if(ff_h261_resync(h)<0) 620 break; 621 h261_decode_gob(h); 622 } 623 MPV_frame_end(s); 624 625assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type); 626assert(s->current_picture.pict_type == s->pict_type); 627 *pict= *(AVFrame*)s->current_picture_ptr; 628 ff_print_debug_info(s, pict); 629 630 *data_size = sizeof(AVFrame); 631 632 return get_consumed_bytes(s, buf_size); 633} 634 635static av_cold int h261_decode_end(AVCodecContext *avctx) 636{ 637 H261Context *h= avctx->priv_data; 638 MpegEncContext *s = &h->s; 639 640 MPV_common_end(s); 641 return 0; 642} 643 644AVCodec h261_decoder = { 645 "h261", 646 AVMEDIA_TYPE_VIDEO, 647 CODEC_ID_H261, 648 sizeof(H261Context), 649 h261_decode_init, 650 NULL, 651 h261_decode_end, 652 h261_decode_frame, 653 CODEC_CAP_DR1, 654 .long_name = NULL_IF_CONFIG_SMALL("H.261"), 655}; 656