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 av_cold 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, 552);
00070 }
00071 }
00072
00073 static av_cold 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 av_log(s->avctx, AV_LOG_ERROR, "qscale has forbidden 0 value\n");
00138 if (s->avctx->error_recognition >= FF_ER_COMPLIANT)
00139 return -1;
00140 }
00141
00142
00143
00144
00145 h->current_mba = 0;
00146 h->mba_diff = 0;
00147
00148 return 0;
00149 }
00150
00155 static int ff_h261_resync(H261Context *h){
00156 MpegEncContext * const s = &h->s;
00157 int left, ret;
00158
00159 if ( h->gob_start_code_skipped ){
00160 ret= h261_decode_gob_header(h);
00161 if(ret>=0)
00162 return 0;
00163 }
00164 else{
00165 if(show_bits(&s->gb, 15)==0){
00166 ret= h261_decode_gob_header(h);
00167 if(ret>=0)
00168 return 0;
00169 }
00170
00171 s->gb= s->last_resync_gb;
00172 align_get_bits(&s->gb);
00173 left= s->gb.size_in_bits - get_bits_count(&s->gb);
00174
00175 for(;left>15+1+4+5; left-=8){
00176 if(show_bits(&s->gb, 15)==0){
00177 GetBitContext bak= s->gb;
00178
00179 ret= h261_decode_gob_header(h);
00180 if(ret>=0)
00181 return 0;
00182
00183 s->gb= bak;
00184 }
00185 skip_bits(&s->gb, 8);
00186 }
00187 }
00188
00189 return -1;
00190 }
00191
00196 static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
00197 {
00198 MpegEncContext * const s = &h->s;
00199 int i;
00200
00201 s->mb_intra = 0;
00202
00203 for(i=mba1; i<mba2; i++){
00204 int j, xy;
00205
00206 s->mb_x= ((h->gob_number-1) % 2) * 11 + i % 11;
00207 s->mb_y= ((h->gob_number-1) / 2) * 3 + i / 11;
00208 xy = s->mb_x + s->mb_y * s->mb_stride;
00209 ff_init_block_index(s);
00210 ff_update_block_index(s);
00211
00212 for(j=0;j<6;j++)
00213 s->block_last_index[j] = -1;
00214
00215 s->mv_dir = MV_DIR_FORWARD;
00216 s->mv_type = MV_TYPE_16X16;
00217 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
00218 s->mv[0][0][0] = 0;
00219 s->mv[0][0][1] = 0;
00220 s->mb_skipped = 1;
00221 h->mtype &= ~MB_TYPE_H261_FIL;
00222
00223 MPV_decode_mb(s, s->block);
00224 }
00225
00226 return 0;
00227 }
00228
00229 static int decode_mv_component(GetBitContext *gb, int v){
00230 int mv_diff = get_vlc2(gb, h261_mv_vlc.table, H261_MV_VLC_BITS, 2);
00231
00232
00233 if ( mv_diff < 0 )
00234 return v;
00235
00236 mv_diff = mvmap[mv_diff];
00237
00238 if(mv_diff && !get_bits1(gb))
00239 mv_diff= -mv_diff;
00240
00241 v += mv_diff;
00242 if (v <=-16) v+= 32;
00243 else if(v >= 16) v-= 32;
00244
00245 return v;
00246 }
00247
00248 static int h261_decode_mb(H261Context *h){
00249 MpegEncContext * const s = &h->s;
00250 int i, cbp, xy;
00251
00252 cbp = 63;
00253
00254 do{
00255 h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc.table, H261_MBA_VLC_BITS, 2);
00256
00257
00258
00259 if (h->mba_diff == MBA_STARTCODE){
00260 h->gob_start_code_skipped = 1;
00261 return SLICE_END;
00262 }
00263 }
00264 while( h->mba_diff == MBA_STUFFING );
00265
00266 if ( h->mba_diff < 0 ){
00267 if ( get_bits_count(&s->gb) + 7 >= s->gb.size_in_bits )
00268 return SLICE_END;
00269
00270 av_log(s->avctx, AV_LOG_ERROR, "illegal mba at %d %d\n", s->mb_x, s->mb_y);
00271 return SLICE_ERROR;
00272 }
00273
00274 h->mba_diff += 1;
00275 h->current_mba += h->mba_diff;
00276
00277 if ( h->current_mba > MBA_STUFFING )
00278 return SLICE_ERROR;
00279
00280 s->mb_x= ((h->gob_number-1) % 2) * 11 + ((h->current_mba-1) % 11);
00281 s->mb_y= ((h->gob_number-1) / 2) * 3 + ((h->current_mba-1) / 11);
00282 xy = s->mb_x + s->mb_y * s->mb_stride;
00283 ff_init_block_index(s);
00284 ff_update_block_index(s);
00285
00286
00287 h->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2);
00288 h->mtype = h261_mtype_map[h->mtype];
00289
00290
00291 if ( IS_QUANT ( h->mtype ) ){
00292 ff_set_qscale(s, get_bits(&s->gb, 5));
00293 }
00294
00295 s->mb_intra = IS_INTRA4x4(h->mtype);
00296
00297
00298 if ( IS_16X16 ( h->mtype ) ){
00299
00300
00301
00302
00303
00304
00305 if ( ( h->current_mba == 1 ) || ( h->current_mba == 12 ) || ( h->current_mba == 23 ) ||
00306 ( h->mba_diff != 1))
00307 {
00308 h->current_mv_x = 0;
00309 h->current_mv_y = 0;
00310 }
00311
00312 h->current_mv_x= decode_mv_component(&s->gb, h->current_mv_x);
00313 h->current_mv_y= decode_mv_component(&s->gb, h->current_mv_y);
00314 }else{
00315 h->current_mv_x = 0;
00316 h->current_mv_y = 0;
00317 }
00318
00319
00320 if ( HAS_CBP( h->mtype ) ){
00321 cbp = get_vlc2(&s->gb, h261_cbp_vlc.table, H261_CBP_VLC_BITS, 2) + 1;
00322 }
00323
00324 if(s->mb_intra){
00325 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
00326 goto intra;
00327 }
00328
00329
00330 s->mv_dir = MV_DIR_FORWARD;
00331 s->mv_type = MV_TYPE_16X16;
00332 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
00333 s->mv[0][0][0] = h->current_mv_x * 2;
00334 s->mv[0][0][1] = h->current_mv_y * 2;
00335
00336 intra:
00337
00338 if(s->mb_intra || HAS_CBP(h->mtype)){
00339 s->dsp.clear_blocks(s->block[0]);
00340 for (i = 0; i < 6; i++) {
00341 if (h261_decode_block(h, s->block[i], i, cbp&32) < 0){
00342 return SLICE_ERROR;
00343 }
00344 cbp+=cbp;
00345 }
00346 }else{
00347 for (i = 0; i < 6; i++)
00348 s->block_last_index[i]= -1;
00349 }
00350
00351 MPV_decode_mb(s, s->block);
00352
00353 return SLICE_OK;
00354 }
00355
00360 static int h261_decode_block(H261Context * h, DCTELEM * block,
00361 int n, int coded)
00362 {
00363 MpegEncContext * const s = &h->s;
00364 int code, level, i, j, run;
00365 RLTable *rl = &h261_rl_tcoeff;
00366 const uint8_t *scan_table;
00367
00368
00369
00370
00371
00372
00373 scan_table = s->intra_scantable.permutated;
00374 if (s->mb_intra){
00375
00376 level = get_bits(&s->gb, 8);
00377
00378 if((level&0x7F) == 0){
00379 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
00380 return -1;
00381 }
00382
00383 if (level == 255)
00384 level = 128;
00385 block[0] = level;
00386 i = 1;
00387 }else if(coded){
00388
00389
00390
00391
00392 int check = show_bits(&s->gb, 2);
00393 i = 0;
00394 if ( check & 0x2 ){
00395 skip_bits(&s->gb, 2);
00396 block[0] = ( check & 0x1 ) ? -1 : 1;
00397 i = 1;
00398 }
00399 }else{
00400 i = 0;
00401 }
00402 if(!coded){
00403 s->block_last_index[n] = i - 1;
00404 return 0;
00405 }
00406 for(;;){
00407 code = get_vlc2(&s->gb, rl->vlc.table, TCOEFF_VLC_BITS, 2);
00408 if (code < 0){
00409 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
00410 return -1;
00411 }
00412 if (code == rl->n) {
00413
00414
00415 run = get_bits(&s->gb, 6);
00416 level = get_sbits(&s->gb, 8);
00417 }else if(code == 0){
00418 break;
00419 }else{
00420 run = rl->table_run[code];
00421 level = rl->table_level[code];
00422 if (get_bits1(&s->gb))
00423 level = -level;
00424 }
00425 i += run;
00426 if (i >= 64){
00427 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
00428 return -1;
00429 }
00430 j = scan_table[i];
00431 block[j] = level;
00432 i++;
00433 }
00434 s->block_last_index[n] = i-1;
00435 return 0;
00436 }
00437
00442 static int h261_decode_picture_header(H261Context *h){
00443 MpegEncContext * const s = &h->s;
00444 int format, i;
00445 uint32_t startcode= 0;
00446
00447 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=1){
00448 startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
00449
00450 if(startcode == 0x10)
00451 break;
00452 }
00453
00454 if (startcode != 0x10){
00455 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
00456 return -1;
00457 }
00458
00459
00460 i= get_bits(&s->gb, 5);
00461 if(i < (s->picture_number&31))
00462 i += 32;
00463 s->picture_number = (s->picture_number&~31) + i;
00464
00465 s->avctx->time_base= (AVRational){1001, 30000};
00466 s->current_picture.pts= s->picture_number;
00467
00468
00469
00470 skip_bits1(&s->gb);
00471 skip_bits1(&s->gb);
00472 skip_bits1(&s->gb);
00473
00474 format = get_bits1(&s->gb);
00475
00476
00477 if (format == 0){
00478 s->width = 176;
00479 s->height = 144;
00480 s->mb_width = 11;
00481 s->mb_height = 9;
00482 }else{
00483 s->width = 352;
00484 s->height = 288;
00485 s->mb_width = 22;
00486 s->mb_height = 18;
00487 }
00488
00489 s->mb_num = s->mb_width * s->mb_height;
00490
00491 skip_bits1(&s->gb);
00492 skip_bits1(&s->gb);
00493
00494
00495 while (get_bits1(&s->gb) != 0){
00496 skip_bits(&s->gb, 8);
00497 }
00498
00499
00500
00501 s->pict_type = FF_P_TYPE;
00502
00503 h->gob_number = 0;
00504 return 0;
00505 }
00506
00507 static int h261_decode_gob(H261Context *h){
00508 MpegEncContext * const s = &h->s;
00509
00510 ff_set_qscale(s, s->qscale);
00511
00512
00513 while(h->current_mba <= MBA_STUFFING)
00514 {
00515 int ret;
00516
00517 ret= h261_decode_mb(h);
00518 if(ret<0){
00519 if(ret==SLICE_END){
00520 h261_decode_mb_skipped(h, h->current_mba, 33);
00521 return 0;
00522 }
00523 av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", s->mb_x + s->mb_y*s->mb_stride);
00524 return -1;
00525 }
00526
00527 h261_decode_mb_skipped(h, h->current_mba-h->mba_diff, h->current_mba-1);
00528 }
00529
00530 return -1;
00531 }
00532
00536 static int get_consumed_bytes(MpegEncContext *s, int buf_size){
00537 int pos= get_bits_count(&s->gb)>>3;
00538 if(pos==0) pos=1;
00539 if(pos+10>buf_size) pos=buf_size;
00540
00541 return pos;
00542 }
00543
00544 static int h261_decode_frame(AVCodecContext *avctx,
00545 void *data, int *data_size,
00546 const uint8_t *buf, int buf_size)
00547 {
00548 H261Context *h= avctx->priv_data;
00549 MpegEncContext *s = &h->s;
00550 int ret;
00551 AVFrame *pict = data;
00552
00553 #ifdef DEBUG
00554 av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
00555 av_log(avctx, AV_LOG_DEBUG, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
00556 #endif
00557 s->flags= avctx->flags;
00558 s->flags2= avctx->flags2;
00559
00560 h->gob_start_code_skipped=0;
00561
00562 retry:
00563
00564 init_get_bits(&s->gb, buf, buf_size*8);
00565
00566 if(!s->context_initialized){
00567 if (MPV_common_init(s) < 0)
00568 return -1;
00569 }
00570
00571
00572 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
00573 int i= ff_find_unused_picture(s, 0);
00574 s->current_picture_ptr= &s->picture[i];
00575 }
00576
00577 ret = h261_decode_picture_header(h);
00578
00579
00580 if (ret < 0){
00581 av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
00582 return -1;
00583 }
00584
00585 if (s->width != avctx->coded_width || s->height != avctx->coded_height){
00586 ParseContext pc= s->parse_context;
00587 s->parse_context.buffer=0;
00588 MPV_common_end(s);
00589 s->parse_context= pc;
00590 }
00591 if (!s->context_initialized) {
00592 avcodec_set_dimensions(avctx, s->width, s->height);
00593
00594 goto retry;
00595 }
00596
00597
00598 s->current_picture.pict_type= s->pict_type;
00599 s->current_picture.key_frame= s->pict_type == FF_I_TYPE;
00600
00601
00602 if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);
00603 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
00604 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
00605 || avctx->skip_frame >= AVDISCARD_ALL)
00606 return get_consumed_bytes(s, buf_size);
00607
00608 if(MPV_frame_start(s, avctx) < 0)
00609 return -1;
00610
00611 ff_er_frame_start(s);
00612
00613
00614 s->mb_x=0;
00615 s->mb_y=0;
00616
00617 while(h->gob_number < (s->mb_height==18 ? 12 : 5)){
00618 if(ff_h261_resync(h)<0)
00619 break;
00620 h261_decode_gob(h);
00621 }
00622 MPV_frame_end(s);
00623
00624 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
00625 assert(s->current_picture.pict_type == s->pict_type);
00626 *pict= *(AVFrame*)s->current_picture_ptr;
00627 ff_print_debug_info(s, pict);
00628
00629 *data_size = sizeof(AVFrame);
00630
00631 return get_consumed_bytes(s, buf_size);
00632 }
00633
00634 static av_cold int h261_decode_end(AVCodecContext *avctx)
00635 {
00636 H261Context *h= avctx->priv_data;
00637 MpegEncContext *s = &h->s;
00638
00639 MPV_common_end(s);
00640 return 0;
00641 }
00642
00643 AVCodec h261_decoder = {
00644 "h261",
00645 CODEC_TYPE_VIDEO,
00646 CODEC_ID_H261,
00647 sizeof(H261Context),
00648 h261_decode_init,
00649 NULL,
00650 h261_decode_end,
00651 h261_decode_frame,
00652 CODEC_CAP_DR1,
00653 .long_name = NULL_IF_CONFIG_SMALL("H.261"),
00654 };