kill av_mallocz_static() calls in init_rl()
[ffmpeg.git] / libavcodec / h261.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 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 h261.c
25  * h261codec.
26  */
27
28 #include "common.h"
29 #include "dsputil.h"
30 #include "avcodec.h"
31 #include "mpegvideo.h"
32 #include "h261data.h"
33
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
41 #define MBA_STUFFING 33
42 #define MBA_STARTCODE 34
43 #define IS_FIL(a)    ((a)&MB_TYPE_H261_FIL)
44
45 /**
46  * H261Context
47  */
48 typedef struct H261Context{
49     MpegEncContext s;
50
51     int current_mba;
52     int previous_mba;
53     int mba_diff;
54     int mtype;
55     int current_mv_x;
56     int current_mv_y;
57     int gob_number;
58     int gob_start_code_skipped; // 1 if gob start code is already read before gob header is read
59 }H261Context;
60
61 static uint8_t static_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
62
63 void ff_h261_loop_filter(MpegEncContext *s){
64     H261Context * h= (H261Context*)s;
65     const int linesize  = s->linesize;
66     const int uvlinesize= s->uvlinesize;
67     uint8_t *dest_y = s->dest[0];
68     uint8_t *dest_cb= s->dest[1];
69     uint8_t *dest_cr= s->dest[2];
70
71     if(!(IS_FIL (h->mtype)))
72         return;
73
74     s->dsp.h261_loop_filter(dest_y                   , linesize);
75     s->dsp.h261_loop_filter(dest_y                + 8, linesize);
76     s->dsp.h261_loop_filter(dest_y + 8 * linesize    , linesize);
77     s->dsp.h261_loop_filter(dest_y + 8 * linesize + 8, linesize);
78     s->dsp.h261_loop_filter(dest_cb, uvlinesize);
79     s->dsp.h261_loop_filter(dest_cr, uvlinesize);
80 }
81
82 int ff_h261_get_picture_format(int width, int height){
83     // QCIF
84     if (width == 176 && height == 144)
85         return 0;
86     // CIF
87     else if (width == 352 && height == 288)
88         return 1;
89     // ERROR
90     else
91         return -1;
92 }
93
94 static void h261_encode_block(H261Context * h, DCTELEM * block,
95                               int n);
96 static int h261_decode_block(H261Context *h, DCTELEM *block,
97                              int n, int coded);
98
99 void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number){
100     H261Context * h = (H261Context *) s;
101     int format, temp_ref;
102
103     align_put_bits(&s->pb);
104
105     /* Update the pointer to last GOB */
106     s->ptr_lastgob = pbBufPtr(&s->pb);
107
108     put_bits(&s->pb, 20, 0x10); /* PSC */
109
110     temp_ref= s->picture_number * (int64_t)30000 * s->avctx->time_base.num /
111                          (1001 * (int64_t)s->avctx->time_base.den); //FIXME maybe this should use a timestamp
112     put_bits(&s->pb, 5, temp_ref & 0x1f); /* TemporalReference */
113
114     put_bits(&s->pb, 1, 0); /* split screen off */
115     put_bits(&s->pb, 1, 0); /* camera  off */
116     put_bits(&s->pb, 1, 0); /* freeze picture release off */
117
118     format = ff_h261_get_picture_format(s->width, s->height);
119
120     put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */
121
122     put_bits(&s->pb, 1, 0); /* still image mode */
123     put_bits(&s->pb, 1, 0); /* reserved */
124
125     put_bits(&s->pb, 1, 0); /* no PEI */
126     if(format == 0)
127         h->gob_number = -1;
128     else
129         h->gob_number = 0;
130     h->current_mba = 0;
131 }
132
133 /**
134  * Encodes a group of blocks header.
135  */
136 static void h261_encode_gob_header(MpegEncContext * s, int mb_line){
137     H261Context * h = (H261Context *)s;
138     if(ff_h261_get_picture_format(s->width, s->height) == 0){
139         h->gob_number+=2; // QCIF
140     }
141     else{
142         h->gob_number++; // CIF
143     }
144     put_bits(&s->pb, 16, 1); /* GBSC */
145     put_bits(&s->pb, 4, h->gob_number); /* GN */
146     put_bits(&s->pb, 5, s->qscale); /* GQUANT */
147     put_bits(&s->pb, 1, 0); /* no GEI */
148     h->current_mba = 0;
149     h->previous_mba = 0;
150     h->current_mv_x=0;
151     h->current_mv_y=0;
152 }
153
154 void ff_h261_reorder_mb_index(MpegEncContext* s){
155     int index= s->mb_x + s->mb_y*s->mb_width;
156
157     if(index % 33 == 0)
158         h261_encode_gob_header(s,0);
159
160     /* for CIF the GOB's are fragmented in the middle of a scanline
161        that's why we need to adjust the x and y index of the macroblocks */
162     if(ff_h261_get_picture_format(s->width,s->height) == 1){ // CIF
163         s->mb_x =     index % 11 ; index /= 11;
164         s->mb_y =     index %  3 ; index /=  3;
165         s->mb_x+= 11*(index %  2); index /=  2;
166         s->mb_y+=  3*index;
167
168         ff_init_block_index(s);
169         ff_update_block_index(s);
170     }
171 }
172
173 static void h261_encode_motion(H261Context * h, int val){
174     MpegEncContext * const s = &h->s;
175     int sign, code;
176     if(val==0){
177         code = 0;
178         put_bits(&s->pb,h261_mv_tab[code][1],h261_mv_tab[code][0]);
179     }
180     else{
181         if(val > 15)
182             val -=32;
183         if(val < -16)
184             val+=32;
185         sign = val < 0;
186         code = sign ? -val : val;
187         put_bits(&s->pb,h261_mv_tab[code][1],h261_mv_tab[code][0]);
188         put_bits(&s->pb,1,sign);
189     }
190 }
191
192 static inline int get_cbp(MpegEncContext * s,
193                       DCTELEM block[6][64])
194 {
195     int i, cbp;
196     cbp= 0;
197     for (i = 0; i < 6; i++) {
198         if (s->block_last_index[i] >= 0)
199             cbp |= 1 << (5 - i);
200     }
201     return cbp;
202 }
203 void ff_h261_encode_mb(MpegEncContext * s,
204          DCTELEM block[6][64],
205          int motion_x, int motion_y)
206 {
207     H261Context * h = (H261Context *)s;
208     int mvd, mv_diff_x, mv_diff_y, i, cbp;
209     cbp = 63; // avoid warning
210     mvd = 0;
211
212     h->current_mba++;
213     h->mtype = 0;
214
215     if (!s->mb_intra){
216         /* compute cbp */
217         cbp= get_cbp(s, block);
218
219         /* mvd indicates if this block is motion compensated */
220         mvd = motion_x | motion_y;
221
222         if((cbp | mvd | s->dquant ) == 0) {
223             /* skip macroblock */
224             s->skip_count++;
225             h->current_mv_x=0;
226             h->current_mv_y=0;
227             return;
228         }
229     }
230
231     /* MB is not skipped, encode MBA */
232     put_bits(&s->pb, h261_mba_bits[(h->current_mba-h->previous_mba)-1], h261_mba_code[(h->current_mba-h->previous_mba)-1]);
233
234     /* calculate MTYPE */
235     if(!s->mb_intra){
236         h->mtype++;
237
238         if(mvd || s->loop_filter)
239             h->mtype+=3;
240         if(s->loop_filter)
241             h->mtype+=3;
242         if(cbp || s->dquant)
243             h->mtype++;
244         assert(h->mtype > 1);
245     }
246
247     if(s->dquant)
248         h->mtype++;
249
250     put_bits(&s->pb, h261_mtype_bits[h->mtype], h261_mtype_code[h->mtype]);
251
252     h->mtype = h261_mtype_map[h->mtype];
253
254     if(IS_QUANT(h->mtype)){
255         ff_set_qscale(s,s->qscale+s->dquant);
256         put_bits(&s->pb, 5, s->qscale);
257     }
258
259     if(IS_16X16(h->mtype)){
260         mv_diff_x = (motion_x >> 1) - h->current_mv_x;
261         mv_diff_y = (motion_y >> 1) - h->current_mv_y;
262         h->current_mv_x = (motion_x >> 1);
263         h->current_mv_y = (motion_y >> 1);
264         h261_encode_motion(h,mv_diff_x);
265         h261_encode_motion(h,mv_diff_y);
266     }
267
268     h->previous_mba = h->current_mba;
269
270     if(HAS_CBP(h->mtype)){
271         assert(cbp>0);
272         put_bits(&s->pb,h261_cbp_tab[cbp-1][1],h261_cbp_tab[cbp-1][0]);
273     }
274     for(i=0; i<6; i++) {
275         /* encode each block */
276         h261_encode_block(h, block[i], i);
277     }
278
279     if ( ( h->current_mba == 11 ) || ( h->current_mba == 22 ) || ( h->current_mba == 33 ) || ( !IS_16X16 ( h->mtype ) )){
280         h->current_mv_x=0;
281         h->current_mv_y=0;
282     }
283 }
284
285 void ff_h261_encode_init(MpegEncContext *s){
286     static int done = 0;
287
288     if (!done) {
289         done = 1;
290         init_rl(&h261_rl_tcoeff, static_rl_table_store);
291     }
292
293     s->min_qcoeff= -127;
294     s->max_qcoeff=  127;
295     s->y_dc_scale_table=
296     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
297 }
298
299
300 /**
301  * encodes a 8x8 block.
302  * @param block the 8x8 block
303  * @param n block index (0-3 are luma, 4-5 are chroma)
304  */
305 static void h261_encode_block(H261Context * h, DCTELEM * block, int n){
306     MpegEncContext * const s = &h->s;
307     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
308     RLTable *rl;
309
310     rl = &h261_rl_tcoeff;
311     if (s->mb_intra) {
312         /* DC coef */
313         level = block[0];
314         /* 255 cannot be represented, so we clamp */
315         if (level > 254) {
316             level = 254;
317             block[0] = 254;
318         }
319         /* 0 cannot be represented also */
320         else if (level < 1) {
321             level = 1;
322             block[0] = 1;
323         }
324         if (level == 128)
325             put_bits(&s->pb, 8, 0xff);
326         else
327             put_bits(&s->pb, 8, level);
328         i = 1;
329     } else if((block[0]==1 || block[0] == -1) && (s->block_last_index[n] > -1)){
330         //special case
331         put_bits(&s->pb,2,block[0]>0 ? 2 : 3 );
332         i = 1;
333     } else {
334         i = 0;
335     }
336
337     /* AC coefs */
338     last_index = s->block_last_index[n];
339     last_non_zero = i - 1;
340     for (; i <= last_index; i++) {
341         j = s->intra_scantable.permutated[i];
342         level = block[j];
343         if (level) {
344             run = i - last_non_zero - 1;
345             last = (i == last_index);
346             sign = 0;
347             slevel = level;
348             if (level < 0) {
349                 sign = 1;
350                 level = -level;
351             }
352             code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/, run, level);
353             if(run==0 && level < 16)
354             code+=1;
355             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
356             if (code == rl->n) {
357                 put_bits(&s->pb, 6, run);
358                 assert(slevel != 0);
359                 assert(level <= 127);
360                 put_bits(&s->pb, 8, slevel & 0xff);
361             } else {
362                 put_bits(&s->pb, 1, sign);
363             }
364             last_non_zero = i;
365         }
366     }
367     if(last_index > -1){
368         put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]);// END OF BLOCK
369     }
370 }
371
372 /***********************************************/
373 /* decoding */
374
375 static VLC h261_mba_vlc;
376 static VLC h261_mtype_vlc;
377 static VLC h261_mv_vlc;
378 static VLC h261_cbp_vlc;
379
380 static void h261_decode_init_vlc(H261Context *h){
381     static int done = 0;
382
383     if(!done){
384         done = 1;
385         init_vlc(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,
386                  h261_mba_bits, 1, 1,
387                  h261_mba_code, 1, 1, 1);
388         init_vlc(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10,
389                  h261_mtype_bits, 1, 1,
390                  h261_mtype_code, 1, 1, 1);
391         init_vlc(&h261_mv_vlc, H261_MV_VLC_BITS, 17,
392                  &h261_mv_tab[0][1], 2, 1,
393                  &h261_mv_tab[0][0], 2, 1, 1);
394         init_vlc(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63,
395                  &h261_cbp_tab[0][1], 2, 1,
396                  &h261_cbp_tab[0][0], 2, 1, 1);
397         init_rl(&h261_rl_tcoeff, static_rl_table_store);
398         init_vlc_rl(&h261_rl_tcoeff, 1);
399     }
400 }
401
402 static int h261_decode_init(AVCodecContext *avctx){
403     H261Context *h= avctx->priv_data;
404     MpegEncContext * const s = &h->s;
405
406     // set defaults
407     MPV_decode_defaults(s);
408     s->avctx = avctx;
409
410     s->width  = s->avctx->coded_width;
411     s->height = s->avctx->coded_height;
412     s->codec_id = s->avctx->codec->id;
413
414     s->out_format = FMT_H261;
415     s->low_delay= 1;
416     avctx->pix_fmt= PIX_FMT_YUV420P;
417
418     s->codec_id= avctx->codec->id;
419
420     h261_decode_init_vlc(h);
421
422     h->gob_start_code_skipped = 0;
423
424     return 0;
425 }
426
427 /**
428  * decodes the group of blocks header or slice header.
429  * @return <0 if an error occured
430  */
431 static int h261_decode_gob_header(H261Context *h){
432     unsigned int val;
433     MpegEncContext * const s = &h->s;
434
435     if ( !h->gob_start_code_skipped ){
436         /* Check for GOB Start Code */
437         val = show_bits(&s->gb, 15);
438         if(val)
439             return -1;
440
441         /* We have a GBSC */
442         skip_bits(&s->gb, 16);
443     }
444
445     h->gob_start_code_skipped = 0;
446
447     h->gob_number = get_bits(&s->gb, 4); /* GN */
448     s->qscale = get_bits(&s->gb, 5); /* GQUANT */
449
450     /* Check if gob_number is valid */
451     if (s->mb_height==18){ //cif
452         if ((h->gob_number<=0) || (h->gob_number>12))
453             return -1;
454     }
455     else{ //qcif
456         if ((h->gob_number!=1) && (h->gob_number!=3) && (h->gob_number!=5))
457             return -1;
458     }
459
460     /* GEI */
461     while (get_bits1(&s->gb) != 0) {
462         skip_bits(&s->gb, 8);
463     }
464
465     if(s->qscale==0)
466         return -1;
467
468     // For the first transmitted macroblock in a GOB, MBA is the absolute address. For
469     // subsequent macroblocks, MBA is the difference between the absolute addresses of
470     // the macroblock and the last transmitted macroblock.
471     h->current_mba = 0;
472     h->mba_diff = 0;
473
474     return 0;
475 }
476
477 /**
478  * decodes the group of blocks / video packet header.
479  * @return <0 if no resync found
480  */
481 static int ff_h261_resync(H261Context *h){
482     MpegEncContext * const s = &h->s;
483     int left, ret;
484
485     if ( h->gob_start_code_skipped ){
486         ret= h261_decode_gob_header(h);
487         if(ret>=0)
488             return 0;
489     }
490     else{
491         if(show_bits(&s->gb, 15)==0){
492             ret= h261_decode_gob_header(h);
493             if(ret>=0)
494                 return 0;
495         }
496         //ok, its not where its supposed to be ...
497         s->gb= s->last_resync_gb;
498         align_get_bits(&s->gb);
499         left= s->gb.size_in_bits - get_bits_count(&s->gb);
500
501         for(;left>15+1+4+5; left-=8){
502             if(show_bits(&s->gb, 15)==0){
503                 GetBitContext bak= s->gb;
504
505                 ret= h261_decode_gob_header(h);
506                 if(ret>=0)
507                     return 0;
508
509                 s->gb= bak;
510             }
511             skip_bits(&s->gb, 8);
512         }
513     }
514
515     return -1;
516 }
517
518 /**
519  * decodes skipped macroblocks
520  * @return 0
521  */
522 static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
523 {
524     MpegEncContext * const s = &h->s;
525     int i;
526
527     s->mb_intra = 0;
528
529     for(i=mba1; i<mba2; i++){
530         int j, xy;
531
532         s->mb_x= ((h->gob_number-1) % 2) * 11 + i % 11;
533         s->mb_y= ((h->gob_number-1) / 2) * 3 + i / 11;
534         xy = s->mb_x + s->mb_y * s->mb_stride;
535         ff_init_block_index(s);
536         ff_update_block_index(s);
537
538         for(j=0;j<6;j++)
539             s->block_last_index[j] = -1;
540
541         s->mv_dir = MV_DIR_FORWARD;
542         s->mv_type = MV_TYPE_16X16;
543         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
544         s->mv[0][0][0] = 0;
545         s->mv[0][0][1] = 0;
546         s->mb_skipped = 1;
547         h->mtype &= ~MB_TYPE_H261_FIL;
548
549         MPV_decode_mb(s, s->block);
550     }
551
552     return 0;
553 }
554
555 static int decode_mv_component(GetBitContext *gb, int v){
556     int mv_diff = get_vlc2(gb, h261_mv_vlc.table, H261_MV_VLC_BITS, 2);
557
558     /* check if mv_diff is valid */
559     if ( mv_diff < 0 )
560         return v;
561
562     mv_diff = mvmap[mv_diff];
563
564     if(mv_diff && !get_bits1(gb))
565         mv_diff= -mv_diff;
566
567     v += mv_diff;
568     if     (v <=-16) v+= 32;
569     else if(v >= 16) v-= 32;
570
571     return v;
572 }
573
574 static int h261_decode_mb(H261Context *h){
575     MpegEncContext * const s = &h->s;
576     int i, cbp, xy;
577
578     cbp = 63;
579     // Read mba
580     do{
581         h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc.table, H261_MBA_VLC_BITS, 2);
582
583         /* Check for slice end */
584         /* NOTE: GOB can be empty (no MB data) or exist only of MBA_stuffing */
585         if (h->mba_diff == MBA_STARTCODE){ // start code
586             h->gob_start_code_skipped = 1;
587             return SLICE_END;
588         }
589     }
590     while( h->mba_diff == MBA_STUFFING ); // stuffing
591
592     if ( h->mba_diff < 0 ){
593         if ( get_bits_count(&s->gb) + 7 >= s->gb.size_in_bits )
594             return SLICE_END;
595
596         av_log(s->avctx, AV_LOG_ERROR, "illegal mba at %d %d\n", s->mb_x, s->mb_y);
597         return SLICE_ERROR;
598     }
599
600     h->mba_diff += 1;
601     h->current_mba += h->mba_diff;
602
603     if ( h->current_mba > MBA_STUFFING )
604         return SLICE_ERROR;
605
606     s->mb_x= ((h->gob_number-1) % 2) * 11 + ((h->current_mba-1) % 11);
607     s->mb_y= ((h->gob_number-1) / 2) * 3 + ((h->current_mba-1) / 11);
608     xy = s->mb_x + s->mb_y * s->mb_stride;
609     ff_init_block_index(s);
610     ff_update_block_index(s);
611
612     // Read mtype
613     h->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2);
614     h->mtype = h261_mtype_map[h->mtype];
615
616     // Read mquant
617     if ( IS_QUANT ( h->mtype ) ){
618         ff_set_qscale(s, get_bits(&s->gb, 5));
619     }
620
621     s->mb_intra = IS_INTRA4x4(h->mtype);
622
623     // Read mv
624     if ( IS_16X16 ( h->mtype ) ){
625         // Motion vector data is included for all MC macroblocks. MVD is obtained from the macroblock vector by subtracting the
626         // vector of the preceding macroblock. For this calculation the vector of the preceding macroblock is regarded as zero in the
627         // following three situations:
628         // 1) evaluating MVD for macroblocks 1, 12 and 23;
629         // 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
630         // 3) MTYPE of the previous macroblock was not MC.
631         if ( ( h->current_mba == 1 ) || ( h->current_mba == 12 ) || ( h->current_mba == 23 ) ||
632              ( h->mba_diff != 1))
633         {
634             h->current_mv_x = 0;
635             h->current_mv_y = 0;
636         }
637
638         h->current_mv_x= decode_mv_component(&s->gb, h->current_mv_x);
639         h->current_mv_y= decode_mv_component(&s->gb, h->current_mv_y);
640     }else{
641         h->current_mv_x = 0;
642         h->current_mv_y = 0;
643     }
644
645     // Read cbp
646     if ( HAS_CBP( h->mtype ) ){
647         cbp = get_vlc2(&s->gb, h261_cbp_vlc.table, H261_CBP_VLC_BITS, 2) + 1;
648     }
649
650     if(s->mb_intra){
651         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
652         goto intra;
653     }
654
655     //set motion vectors
656     s->mv_dir = MV_DIR_FORWARD;
657     s->mv_type = MV_TYPE_16X16;
658     s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
659     s->mv[0][0][0] = h->current_mv_x * 2;//gets divided by 2 in motion compensation
660     s->mv[0][0][1] = h->current_mv_y * 2;
661
662 intra:
663     /* decode each block */
664     if(s->mb_intra || HAS_CBP(h->mtype)){
665         s->dsp.clear_blocks(s->block[0]);
666         for (i = 0; i < 6; i++) {
667             if (h261_decode_block(h, s->block[i], i, cbp&32) < 0){
668                 return SLICE_ERROR;
669             }
670             cbp+=cbp;
671         }
672     }else{
673         for (i = 0; i < 6; i++)
674             s->block_last_index[i]= -1;
675     }
676
677     MPV_decode_mb(s, s->block);
678
679     return SLICE_OK;
680 }
681
682 /**
683  * decodes a macroblock
684  * @return <0 if an error occured
685  */
686 static int h261_decode_block(H261Context * h, DCTELEM * block,
687                              int n, int coded)
688 {
689     MpegEncContext * const s = &h->s;
690     int code, level, i, j, run;
691     RLTable *rl = &h261_rl_tcoeff;
692     const uint8_t *scan_table;
693
694     // For the variable length encoding there are two code tables, one being used for
695     // the first transmitted LEVEL in INTER, INTER+MC and INTER+MC+FIL blocks, the second
696     // for all other LEVELs except the first one in INTRA blocks which is fixed length
697     // coded with 8 bits.
698     // NOTE: the two code tables only differ in one VLC so we handle that manually.
699     scan_table = s->intra_scantable.permutated;
700     if (s->mb_intra){
701         /* DC coef */
702         level = get_bits(&s->gb, 8);
703         // 0 (00000000b) and -128 (10000000b) are FORBIDDEN
704         if((level&0x7F) == 0){
705             av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
706             return -1;
707         }
708         // The code 1000 0000 is not used, the reconstruction level of 1024 being coded as 1111 1111.
709         if (level == 255)
710             level = 128;
711         block[0] = level;
712         i = 1;
713     }else if(coded){
714         // Run  Level   Code
715         // EOB                  Not possible for first level when cbp is available (that's why the table is different)
716         // 0    1               1s
717         // *    *               0*
718         int check = show_bits(&s->gb, 2);
719         i = 0;
720         if ( check & 0x2 ){
721             skip_bits(&s->gb, 2);
722             block[0] = ( check & 0x1 ) ? -1 : 1;
723             i = 1;
724         }
725     }else{
726         i = 0;
727     }
728     if(!coded){
729         s->block_last_index[n] = i - 1;
730         return 0;
731     }
732     for(;;){
733         code = get_vlc2(&s->gb, rl->vlc.table, TCOEFF_VLC_BITS, 2);
734         if (code < 0){
735             av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
736             return -1;
737         }
738         if (code == rl->n) {
739             /* escape */
740             // 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.
741             run = get_bits(&s->gb, 6);
742             level = get_sbits(&s->gb, 8);
743         }else if(code == 0){
744             break;
745         }else{
746             run = rl->table_run[code];
747             level = rl->table_level[code];
748             if (get_bits1(&s->gb))
749                 level = -level;
750         }
751         i += run;
752         if (i >= 64){
753             av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
754             return -1;
755         }
756         j = scan_table[i];
757         block[j] = level;
758         i++;
759     }
760     s->block_last_index[n] = i-1;
761     return 0;
762 }
763
764 /**
765  * decodes the H261 picture header.
766  * @return <0 if no startcode found
767  */
768 static int h261_decode_picture_header(H261Context *h){
769     MpegEncContext * const s = &h->s;
770     int format, i;
771     uint32_t startcode= 0;
772
773     for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=1){
774         startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
775
776         if(startcode == 0x10)
777             break;
778     }
779
780     if (startcode != 0x10){
781         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
782         return -1;
783     }
784
785     /* temporal reference */
786     i= get_bits(&s->gb, 5); /* picture timestamp */
787     if(i < (s->picture_number&31))
788         i += 32;
789     s->picture_number = (s->picture_number&~31) + i;
790
791     s->avctx->time_base= (AVRational){1001, 30000};
792     s->current_picture.pts= s->picture_number;
793
794
795     /* PTYPE starts here */
796     skip_bits1(&s->gb); /* split screen off */
797     skip_bits1(&s->gb); /* camera  off */
798     skip_bits1(&s->gb); /* freeze picture release off */
799
800     format = get_bits1(&s->gb);
801
802     //only 2 formats possible
803     if (format == 0){//QCIF
804         s->width = 176;
805         s->height = 144;
806         s->mb_width = 11;
807         s->mb_height = 9;
808     }else{//CIF
809         s->width = 352;
810         s->height = 288;
811         s->mb_width = 22;
812         s->mb_height = 18;
813     }
814
815     s->mb_num = s->mb_width * s->mb_height;
816
817     skip_bits1(&s->gb); /* still image mode off */
818     skip_bits1(&s->gb); /* Reserved */
819
820     /* PEI */
821     while (get_bits1(&s->gb) != 0){
822         skip_bits(&s->gb, 8);
823     }
824
825     // h261 has no I-FRAMES, but if we pass I_TYPE for the first frame, the codec crashes if it does
826     // not contain all I-blocks (e.g. when a packet is lost)
827     s->pict_type = P_TYPE;
828
829     h->gob_number = 0;
830     return 0;
831 }
832
833 static int h261_decode_gob(H261Context *h){
834     MpegEncContext * const s = &h->s;
835
836     ff_set_qscale(s, s->qscale);
837
838     /* decode mb's */
839     while(h->current_mba <= MBA_STUFFING)
840     {
841         int ret;
842         /* DCT & quantize */
843         ret= h261_decode_mb(h);
844         if(ret<0){
845             if(ret==SLICE_END){
846                 h261_decode_mb_skipped(h, h->current_mba, 33);
847                 return 0;
848             }
849             av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", s->mb_x + s->mb_y*s->mb_stride);
850             return -1;
851         }
852
853         h261_decode_mb_skipped(h, h->current_mba-h->mba_diff, h->current_mba-1);
854     }
855
856     return -1;
857 }
858
859 #ifdef CONFIG_H261_PARSER
860 static int h261_find_frame_end(ParseContext *pc, AVCodecContext* avctx, const uint8_t *buf, int buf_size){
861     int vop_found, i, j;
862     uint32_t state;
863
864     vop_found= pc->frame_start_found;
865     state= pc->state;
866
867     for(i=0; i<buf_size && !vop_found; i++){
868         state= (state<<8) | buf[i];
869         for(j=0; j<8; j++){
870             if(((state>>j)&0xFFFFF) == 0x00010){
871                 vop_found=1;
872                 break;
873             }
874         }
875     }
876     if(vop_found){
877         for(; i<buf_size; i++){
878             state= (state<<8) | buf[i];
879             for(j=0; j<8; j++){
880                 if(((state>>j)&0xFFFFF) == 0x00010){
881                     pc->frame_start_found=0;
882                     pc->state= state>>(2*8);
883                     return i-1;
884                 }
885             }
886         }
887     }
888
889     pc->frame_start_found= vop_found;
890     pc->state= state;
891     return END_NOT_FOUND;
892 }
893
894 static int h261_parse(AVCodecParserContext *s,
895                       AVCodecContext *avctx,
896                       uint8_t **poutbuf, int *poutbuf_size,
897                       const uint8_t *buf, int buf_size)
898 {
899     ParseContext *pc = s->priv_data;
900     int next;
901
902     next= h261_find_frame_end(pc,avctx, buf, buf_size);
903     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
904         *poutbuf = NULL;
905         *poutbuf_size = 0;
906         return buf_size;
907     }
908     *poutbuf = (uint8_t *)buf;
909     *poutbuf_size = buf_size;
910     return next;
911 }
912 #endif
913
914 /**
915  * returns the number of bytes consumed for building the current frame
916  */
917 static int get_consumed_bytes(MpegEncContext *s, int buf_size){
918     int pos= get_bits_count(&s->gb)>>3;
919     if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
920     if(pos+10>buf_size) pos=buf_size; // oops ;)
921
922     return pos;
923 }
924
925 static int h261_decode_frame(AVCodecContext *avctx,
926                              void *data, int *data_size,
927                              uint8_t *buf, int buf_size)
928 {
929     H261Context *h= avctx->priv_data;
930     MpegEncContext *s = &h->s;
931     int ret;
932     AVFrame *pict = data;
933
934 #ifdef DEBUG
935     av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
936     av_log(avctx, AV_LOG_DEBUG, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
937 #endif
938     s->flags= avctx->flags;
939     s->flags2= avctx->flags2;
940
941     h->gob_start_code_skipped=0;
942
943 retry:
944
945     init_get_bits(&s->gb, buf, buf_size*8);
946
947     if(!s->context_initialized){
948         if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
949             return -1;
950     }
951
952     //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
953     if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
954         int i= ff_find_unused_picture(s, 0);
955         s->current_picture_ptr= &s->picture[i];
956     }
957
958     ret = h261_decode_picture_header(h);
959
960     /* skip if the header was thrashed */
961     if (ret < 0){
962         av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
963         return -1;
964     }
965
966     if (s->width != avctx->coded_width || s->height != avctx->coded_height){
967         ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat
968         s->parse_context.buffer=0;
969         MPV_common_end(s);
970         s->parse_context= pc;
971     }
972     if (!s->context_initialized) {
973         avcodec_set_dimensions(avctx, s->width, s->height);
974
975         goto retry;
976     }
977
978     // for hurry_up==5
979     s->current_picture.pict_type= s->pict_type;
980     s->current_picture.key_frame= s->pict_type == I_TYPE;
981
982     /* skip everything if we are in a hurry>=5 */
983     if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);
984     if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
985        ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
986        || avctx->skip_frame >= AVDISCARD_ALL)
987         return get_consumed_bytes(s, buf_size);
988
989     if(MPV_frame_start(s, avctx) < 0)
990         return -1;
991
992     ff_er_frame_start(s);
993
994     /* decode each macroblock */
995     s->mb_x=0;
996     s->mb_y=0;
997
998     while(h->gob_number < (s->mb_height==18 ? 12 : 5)){
999         if(ff_h261_resync(h)<0)
1000             break;
1001         h261_decode_gob(h);
1002     }
1003     MPV_frame_end(s);
1004
1005 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
1006 assert(s->current_picture.pict_type == s->pict_type);
1007     *pict= *(AVFrame*)s->current_picture_ptr;
1008     ff_print_debug_info(s, pict);
1009
1010     *data_size = sizeof(AVFrame);
1011
1012     return get_consumed_bytes(s, buf_size);
1013 }
1014
1015 static int h261_decode_end(AVCodecContext *avctx)
1016 {
1017     H261Context *h= avctx->priv_data;
1018     MpegEncContext *s = &h->s;
1019
1020     MPV_common_end(s);
1021     return 0;
1022 }
1023
1024 #ifdef CONFIG_ENCODERS
1025 AVCodec h261_encoder = {
1026     "h261",
1027     CODEC_TYPE_VIDEO,
1028     CODEC_ID_H261,
1029     sizeof(H261Context),
1030     MPV_encode_init,
1031     MPV_encode_picture,
1032     MPV_encode_end,
1033     .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
1034 };
1035 #endif
1036
1037 AVCodec h261_decoder = {
1038     "h261",
1039     CODEC_TYPE_VIDEO,
1040     CODEC_ID_H261,
1041     sizeof(H261Context),
1042     h261_decode_init,
1043     NULL,
1044     h261_decode_end,
1045     h261_decode_frame,
1046     CODEC_CAP_DR1,
1047 };
1048
1049 #ifdef CONFIG_H261_PARSER
1050 AVCodecParser h261_parser = {
1051     { CODEC_ID_H261 },
1052     sizeof(ParseContext),
1053     NULL,
1054     h261_parse,
1055     ff_parse_close,
1056 };
1057 #endif