00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00028 #include "dsputil.h"
00029 #include "avcodec.h"
00030 #include "mpegvideo.h"
00031 #include "h261.h"
00032 #include "h261data.h"
00033
00034 #define H261_MBA_VLC_BITS 9
00035 #define H261_MTYPE_VLC_BITS 6
00036 #define H261_MV_VLC_BITS 7
00037 #define H261_CBP_VLC_BITS 9
00038 #define TCOEFF_VLC_BITS 9
00039 #define MBA_STUFFING 33
00040 #define MBA_STARTCODE 34
00041
00042 extern uint8_t ff_h261_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
00043
00044 static VLC h261_mba_vlc;
00045 static VLC h261_mtype_vlc;
00046 static VLC h261_mv_vlc;
00047 static VLC h261_cbp_vlc;
00048
00049 static int h261_decode_block(H261Context * h, DCTELEM * block, int n, int coded);
00050
00051 static void h261_decode_init_vlc(H261Context *h){
00052 static int done = 0;
00053
00054 if(!done){
00055 done = 1;
00056 init_vlc(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,
00057 h261_mba_bits, 1, 1,
00058 h261_mba_code, 1, 1, 1);
00059 init_vlc(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10,
00060 h261_mtype_bits, 1, 1,
00061 h261_mtype_code, 1, 1, 1);
00062 init_vlc(&h261_mv_vlc, H261_MV_VLC_BITS, 17,
00063 &h261_mv_tab[0][1], 2, 1,
00064 &h261_mv_tab[0][0], 2, 1, 1);
00065 init_vlc(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63,
00066 &h261_cbp_tab[0][1], 2, 1,
00067 &h261_cbp_tab[0][0], 2, 1, 1);
00068 init_rl(&h261_rl_tcoeff, ff_h261_rl_table_store);
00069 init_vlc_rl(&h261_rl_tcoeff, 1);
00070 }
00071 }
00072
00073 static int h261_decode_init(AVCodecContext *avctx){
00074 H261Context *h= avctx->priv_data;
00075 MpegEncContext * const s = &h->s;
00076
00077
00078 MPV_decode_defaults(s);
00079 s->avctx = avctx;
00080
00081 s->width = s->avctx->coded_width;
00082 s->height = s->avctx->coded_height;
00083 s->codec_id = s->avctx->codec->id;
00084
00085 s->out_format = FMT_H261;
00086 s->low_delay= 1;
00087 avctx->pix_fmt= PIX_FMT_YUV420P;
00088
00089 s->codec_id= avctx->codec->id;
00090
00091 h261_decode_init_vlc(h);
00092
00093 h->gob_start_code_skipped = 0;
00094
00095 return 0;
00096 }
00097
00102 static int h261_decode_gob_header(H261Context *h){
00103 unsigned int val;
00104 MpegEncContext * const s = &h->s;
00105
00106 if ( !h->gob_start_code_skipped ){
00107
00108 val = show_bits(&s->gb, 15);
00109 if(val)
00110 return -1;
00111
00112
00113 skip_bits(&s->gb, 16);
00114 }
00115
00116 h->gob_start_code_skipped = 0;
00117
00118 h->gob_number = get_bits(&s->gb, 4);
00119 s->qscale = get_bits(&s->gb, 5);
00120
00121
00122 if (s->mb_height==18){
00123 if ((h->gob_number<=0) || (h->gob_number>12))
00124 return -1;
00125 }
00126 else{
00127 if ((h->gob_number!=1) && (h->gob_number!=3) && (h->gob_number!=5))
00128 return -1;
00129 }
00130
00131
00132 while (get_bits1(&s->gb) != 0) {
00133 skip_bits(&s->gb, 8);
00134 }
00135
00136 if(s->qscale==0)
00137 return -1;
00138
00139
00140
00141
00142 h->current_mba = 0;
00143 h->mba_diff = 0;
00144
00145 return 0;
00146 }
00147
00152 static int ff_h261_resync(H261Context *h){
00153 MpegEncContext * const s = &h->s;
00154 int left, ret;
00155
00156 if ( h->gob_start_code_skipped ){
00157 ret= h261_decode_gob_header(h);
00158 if(ret>=0)
00159 return 0;
00160 }
00161 else{
00162 if(show_bits(&s->gb, 15)==0){
00163 ret= h261_decode_gob_header(h);
00164 if(ret>=0)
00165 return 0;
00166 }
00167
00168 s->gb= s->last_resync_gb;
00169 align_get_bits(&s->gb);
00170 left= s->gb.size_in_bits - get_bits_count(&s->gb);
00171
00172 for(;left>15+1+4+5; left-=8){
00173 if(show_bits(&s->gb, 15)==0){
00174 GetBitContext bak= s->gb;
00175
00176 ret= h261_decode_gob_header(h);
00177 if(ret>=0)
00178 return 0;
00179
00180 s->gb= bak;
00181 }
00182 skip_bits(&s->gb, 8);
00183 }
00184 }
00185
00186 return -1;
00187 }
00188
00193 static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
00194 {
00195 MpegEncContext * const s = &h->s;
00196 int i;
00197
00198 s->mb_intra = 0;
00199
00200 for(i=mba1; i<mba2; i++){
00201 int j, xy;
00202
00203 s->mb_x= ((h->gob_number-1) % 2) * 11 + i % 11;
00204 s->mb_y= ((h->gob_number-1) / 2) * 3 + i / 11;
00205 xy = s->mb_x + s->mb_y * s->mb_stride;
00206 ff_init_block_index(s);
00207 ff_update_block_index(s);
00208
00209 for(j=0;j<6;j++)
00210 s->block_last_index[j] = -1;
00211
00212 s->mv_dir = MV_DIR_FORWARD;
00213 s->mv_type = MV_TYPE_16X16;
00214 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
00215 s->mv[0][0][0] = 0;
00216 s->mv[0][0][1] = 0;
00217 s->mb_skipped = 1;
00218 h->mtype &= ~MB_TYPE_H261_FIL;
00219
00220 MPV_decode_mb(s, s->block);
00221 }
00222
00223 return 0;
00224 }
00225
00226 static int decode_mv_component(GetBitContext *gb, int v){
00227 int mv_diff = get_vlc2(gb, h261_mv_vlc.table, H261_MV_VLC_BITS, 2);
00228
00229
00230 if ( mv_diff < 0 )
00231 return v;
00232
00233 mv_diff = mvmap[mv_diff];
00234
00235 if(mv_diff && !get_bits1(gb))
00236 mv_diff= -mv_diff;
00237
00238 v += mv_diff;
00239 if (v <=-16) v+= 32;
00240 else if(v >= 16) v-= 32;
00241
00242 return v;
00243 }
00244
00245 static int h261_decode_mb(H261Context *h){
00246 MpegEncContext * const s = &h->s;
00247 int i, cbp, xy;
00248
00249 cbp = 63;
00250
00251 do{
00252 h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc.table, H261_MBA_VLC_BITS, 2);
00253
00254
00255
00256 if (h->mba_diff == MBA_STARTCODE){
00257 h->gob_start_code_skipped = 1;
00258 return SLICE_END;
00259 }
00260 }
00261 while( h->mba_diff == MBA_STUFFING );
00262
00263 if ( h->mba_diff < 0 ){
00264 if ( get_bits_count(&s->gb) + 7 >= s->gb.size_in_bits )
00265 return SLICE_END;
00266
00267 av_log(s->avctx, AV_LOG_ERROR, "illegal mba at %d %d\n", s->mb_x, s->mb_y);
00268 return SLICE_ERROR;
00269 }
00270
00271 h->mba_diff += 1;
00272 h->current_mba += h->mba_diff;
00273
00274 if ( h->current_mba > MBA_STUFFING )
00275 return SLICE_ERROR;
00276
00277 s->mb_x= ((h->gob_number-1) % 2) * 11 + ((h->current_mba-1) % 11);
00278 s->mb_y= ((h->gob_number-1) / 2) * 3 + ((h->current_mba-1) / 11);
00279 xy = s->mb_x + s->mb_y * s->mb_stride;
00280 ff_init_block_index(s);
00281 ff_update_block_index(s);
00282
00283
00284 h->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2);
00285 h->mtype = h261_mtype_map[h->mtype];
00286
00287
00288 if ( IS_QUANT ( h->mtype ) ){
00289 ff_set_qscale(s, get_bits(&s->gb, 5));
00290 }
00291
00292 s->mb_intra = IS_INTRA4x4(h->mtype);
00293
00294
00295 if ( IS_16X16 ( h->mtype ) ){
00296
00297
00298
00299
00300
00301
00302 if ( ( h->current_mba == 1 ) || ( h->current_mba == 12 ) || ( h->current_mba == 23 ) ||
00303 ( h->mba_diff != 1))
00304 {
00305 h->current_mv_x = 0;
00306 h->current_mv_y = 0;
00307 }
00308
00309 h->current_mv_x= decode_mv_component(&s->gb, h->current_mv_x);
00310 h->current_mv_y= decode_mv_component(&s->gb, h->current_mv_y);
00311 }else{
00312 h->current_mv_x = 0;
00313 h->current_mv_y = 0;
00314 }
00315
00316
00317 if ( HAS_CBP( h->mtype ) ){
00318 cbp = get_vlc2(&s->gb, h261_cbp_vlc.table, H261_CBP_VLC_BITS, 2) + 1;
00319 }
00320
00321 if(s->mb_intra){
00322 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
00323 goto intra;
00324 }
00325
00326
00327 s->mv_dir = MV_DIR_FORWARD;
00328 s->mv_type = MV_TYPE_16X16;
00329 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
00330 s->mv[0][0][0] = h->current_mv_x * 2;
00331 s->mv[0][0][1] = h->current_mv_y * 2;
00332
00333 intra:
00334
00335 if(s->mb_intra || HAS_CBP(h->mtype)){
00336 s->dsp.clear_blocks(s->block[0]);
00337 for (i = 0; i < 6; i++) {
00338 if (h261_decode_block(h, s->block[i], i, cbp&32) < 0){
00339 return SLICE_ERROR;
00340 }
00341 cbp+=cbp;
00342 }
00343 }else{
00344 for (i = 0; i < 6; i++)
00345 s->block_last_index[i]= -1;
00346 }
00347
00348 MPV_decode_mb(s, s->block);
00349
00350 return SLICE_OK;
00351 }
00352
00357 static int h261_decode_block(H261Context * h, DCTELEM * block,
00358 int n, int coded)
00359 {
00360 MpegEncContext * const s = &h->s;
00361 int code, level, i, j, run;
00362 RLTable *rl = &h261_rl_tcoeff;
00363 const uint8_t *scan_table;
00364
00365
00366
00367
00368
00369
00370 scan_table = s->intra_scantable.permutated;
00371 if (s->mb_intra){
00372
00373 level = get_bits(&s->gb, 8);
00374
00375 if((level&0x7F) == 0){
00376 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
00377 return -1;
00378 }
00379
00380 if (level == 255)
00381 level = 128;
00382 block[0] = level;
00383 i = 1;
00384 }else if(coded){
00385
00386
00387
00388
00389 int check = show_bits(&s->gb, 2);
00390 i = 0;
00391 if ( check & 0x2 ){
00392 skip_bits(&s->gb, 2);
00393 block[0] = ( check & 0x1 ) ? -1 : 1;
00394 i = 1;
00395 }
00396 }else{
00397 i = 0;
00398 }
00399 if(!coded){
00400 s->block_last_index[n] = i - 1;
00401 return 0;
00402 }
00403 for(;;){
00404 code = get_vlc2(&s->gb, rl->vlc.table, TCOEFF_VLC_BITS, 2);
00405 if (code < 0){
00406 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
00407 return -1;
00408 }
00409 if (code == rl->n) {
00410
00411
00412 run = get_bits(&s->gb, 6);
00413 level = get_sbits(&s->gb, 8);
00414 }else if(code == 0){
00415 break;
00416 }else{
00417 run = rl->table_run[code];
00418 level = rl->table_level[code];
00419 if (get_bits1(&s->gb))
00420 level = -level;
00421 }
00422 i += run;
00423 if (i >= 64){
00424 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
00425 return -1;
00426 }
00427 j = scan_table[i];
00428 block[j] = level;
00429 i++;
00430 }
00431 s->block_last_index[n] = i-1;
00432 return 0;
00433 }
00434
00439 static int h261_decode_picture_header(H261Context *h){
00440 MpegEncContext * const s = &h->s;
00441 int format, i;
00442 uint32_t startcode= 0;
00443
00444 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=1){
00445 startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
00446
00447 if(startcode == 0x10)
00448 break;
00449 }
00450
00451 if (startcode != 0x10){
00452 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
00453 return -1;
00454 }
00455
00456
00457 i= get_bits(&s->gb, 5);
00458 if(i < (s->picture_number&31))
00459 i += 32;
00460 s->picture_number = (s->picture_number&~31) + i;
00461
00462 s->avctx->time_base= (AVRational){1001, 30000};
00463 s->current_picture.pts= s->picture_number;
00464
00465
00466
00467 skip_bits1(&s->gb);
00468 skip_bits1(&s->gb);
00469 skip_bits1(&s->gb);
00470
00471 format = get_bits1(&s->gb);
00472
00473
00474 if (format == 0){
00475 s->width = 176;
00476 s->height = 144;
00477 s->mb_width = 11;
00478 s->mb_height = 9;
00479 }else{
00480 s->width = 352;
00481 s->height = 288;
00482 s->mb_width = 22;
00483 s->mb_height = 18;
00484 }
00485
00486 s->mb_num = s->mb_width * s->mb_height;
00487
00488 skip_bits1(&s->gb);
00489 skip_bits1(&s->gb);
00490
00491
00492 while (get_bits1(&s->gb) != 0){
00493 skip_bits(&s->gb, 8);
00494 }
00495
00496
00497
00498 s->pict_type = P_TYPE;
00499
00500 h->gob_number = 0;
00501 return 0;
00502 }
00503
00504 static int h261_decode_gob(H261Context *h){
00505 MpegEncContext * const s = &h->s;
00506
00507 ff_set_qscale(s, s->qscale);
00508
00509
00510 while(h->current_mba <= MBA_STUFFING)
00511 {
00512 int ret;
00513
00514 ret= h261_decode_mb(h);
00515 if(ret<0){
00516 if(ret==SLICE_END){
00517 h261_decode_mb_skipped(h, h->current_mba, 33);
00518 return 0;
00519 }
00520 av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", s->mb_x + s->mb_y*s->mb_stride);
00521 return -1;
00522 }
00523
00524 h261_decode_mb_skipped(h, h->current_mba-h->mba_diff, h->current_mba-1);
00525 }
00526
00527 return -1;
00528 }
00529
00533 static int get_consumed_bytes(MpegEncContext *s, int buf_size){
00534 int pos= get_bits_count(&s->gb)>>3;
00535 if(pos==0) pos=1;
00536 if(pos+10>buf_size) pos=buf_size;
00537
00538 return pos;
00539 }
00540
00541 static int h261_decode_frame(AVCodecContext *avctx,
00542 void *data, int *data_size,
00543 const uint8_t *buf, int buf_size)
00544 {
00545 H261Context *h= avctx->priv_data;
00546 MpegEncContext *s = &h->s;
00547 int ret;
00548 AVFrame *pict = data;
00549
00550 #ifdef DEBUG
00551 av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
00552 av_log(avctx, AV_LOG_DEBUG, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
00553 #endif
00554 s->flags= avctx->flags;
00555 s->flags2= avctx->flags2;
00556
00557 h->gob_start_code_skipped=0;
00558
00559 retry:
00560
00561 init_get_bits(&s->gb, buf, buf_size*8);
00562
00563 if(!s->context_initialized){
00564 if (MPV_common_init(s) < 0)
00565 return -1;
00566 }
00567
00568
00569 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
00570 int i= ff_find_unused_picture(s, 0);
00571 s->current_picture_ptr= &s->picture[i];
00572 }
00573
00574 ret = h261_decode_picture_header(h);
00575
00576
00577 if (ret < 0){
00578 av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
00579 return -1;
00580 }
00581
00582 if (s->width != avctx->coded_width || s->height != avctx->coded_height){
00583 ParseContext pc= s->parse_context;
00584 s->parse_context.buffer=0;
00585 MPV_common_end(s);
00586 s->parse_context= pc;
00587 }
00588 if (!s->context_initialized) {
00589 avcodec_set_dimensions(avctx, s->width, s->height);
00590
00591 goto retry;
00592 }
00593
00594
00595 s->current_picture.pict_type= s->pict_type;
00596 s->current_picture.key_frame= s->pict_type == I_TYPE;
00597
00598
00599 if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);
00600 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
00601 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
00602 || avctx->skip_frame >= AVDISCARD_ALL)
00603 return get_consumed_bytes(s, buf_size);
00604
00605 if(MPV_frame_start(s, avctx) < 0)
00606 return -1;
00607
00608 ff_er_frame_start(s);
00609
00610
00611 s->mb_x=0;
00612 s->mb_y=0;
00613
00614 while(h->gob_number < (s->mb_height==18 ? 12 : 5)){
00615 if(ff_h261_resync(h)<0)
00616 break;
00617 h261_decode_gob(h);
00618 }
00619 MPV_frame_end(s);
00620
00621 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
00622 assert(s->current_picture.pict_type == s->pict_type);
00623 *pict= *(AVFrame*)s->current_picture_ptr;
00624 ff_print_debug_info(s, pict);
00625
00626 *data_size = sizeof(AVFrame);
00627
00628 return get_consumed_bytes(s, buf_size);
00629 }
00630
00631 static int h261_decode_end(AVCodecContext *avctx)
00632 {
00633 H261Context *h= avctx->priv_data;
00634 MpegEncContext *s = &h->s;
00635
00636 MPV_common_end(s);
00637 return 0;
00638 }
00639
00640 AVCodec h261_decoder = {
00641 "h261",
00642 CODEC_TYPE_VIDEO,
00643 CODEC_ID_H261,
00644 sizeof(H261Context),
00645 h261_decode_init,
00646 NULL,
00647 h261_decode_end,
00648 h261_decode_frame,
00649 CODEC_CAP_DR1,
00650 };