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