4aaf5d6ad494a699e0813ed329d5756ad10c76a4
[ffmpeg.git] / libavcodec / h263.c
1 /*
2  * H263/MPEG4 backend for ffmpeg encoder and decoder
3  * Copyright (c) 2000,2001 Gerard Lantau.
4  * H263+ support.
5  * Copyright (c) 2001 Juan J. Sierralta P.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21 #include "common.h"
22 #include "dsputil.h"
23 #include "avcodec.h"
24 #include "mpegvideo.h"
25 #include "h263data.h"
26 #include "mpeg4data.h"
27
28 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
29                               int n);
30 static void h263_encode_motion(MpegEncContext * s, int val);
31 static void h263p_encode_umotion(MpegEncContext * s, int val);
32 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
33                                int n);
34 static int h263_decode_motion(MpegEncContext * s, int pred);
35 static int h263p_decode_umotion(MpegEncContext * s, int pred);
36 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
37                              int n, int coded);
38 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
39                               int n, int coded);
40
41 int h263_get_picture_format(int width, int height)
42 {
43     int format;
44
45     if (width == 128 && height == 96)
46         format = 1;
47     else if (width == 176 && height == 144)
48         format = 2;
49     else if (width == 352 && height == 288)
50         format = 3;
51     else if (width == 704 && height == 576)
52         format = 4;
53     else if (width == 1408 && height == 1152)
54         format = 5;
55     else
56         format = 7;
57     return format;
58 }
59
60 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
61 {
62     int format;
63
64     align_put_bits(&s->pb);
65     put_bits(&s->pb, 22, 0x20);
66     put_bits(&s->pb, 8, ((s->picture_number * 30 * FRAME_RATE_BASE) / 
67                          s->frame_rate) & 0xff);
68
69     put_bits(&s->pb, 1, 1);     /* marker */
70     put_bits(&s->pb, 1, 0);     /* h263 id */
71     put_bits(&s->pb, 1, 0);     /* split screen off */
72     put_bits(&s->pb, 1, 0);     /* camera  off */
73     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
74     
75     format = h263_get_picture_format(s->width, s->height);
76     if (!s->h263_plus) {
77         /* H.263v1 */
78         put_bits(&s->pb, 3, format);
79         put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
80         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
81         of H.263v1 UMV implies to check the predicted MV after
82         calculation of the current MB to see if we're on the limits */
83         put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
84         put_bits(&s->pb, 1, 0); /* SAC: off */
85         put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
86         put_bits(&s->pb, 1, 0); /* not PB frame */
87         put_bits(&s->pb, 5, s->qscale);
88         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
89     } else {
90         /* H.263v2 */
91         /* H.263 Plus PTYPE */
92         put_bits(&s->pb, 3, 7);
93         put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
94         if (format == 7)
95             put_bits(&s->pb,3,6); /* Custom Source Format */
96         else
97             put_bits(&s->pb, 3, format);
98             
99         put_bits(&s->pb,1,0); /* Custom PCF: off */
100         s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
101         put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
102         put_bits(&s->pb,1,0); /* SAC: off */
103         put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
104         put_bits(&s->pb,1,0); /* Advanced Intra Coding: off */
105         put_bits(&s->pb,1,0); /* Deblocking Filter: off */
106         put_bits(&s->pb,1,0); /* Slice Structured: off */
107         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
108         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
109         put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
110         put_bits(&s->pb,1,0); /* Modified Quantization: off */
111         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
112         put_bits(&s->pb,3,0); /* Reserved */
113                 
114         put_bits(&s->pb, 3, s->pict_type == P_TYPE);
115                 
116         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
117         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
118         put_bits(&s->pb,1,0); /* Rounding Type */
119         put_bits(&s->pb,2,0); /* Reserved */
120         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
121                 
122         /* This should be here if PLUSPTYPE */
123         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
124                 
125                 if (format == 7) {
126             /* Custom Picture Format (CPFMT) */
127                 
128             put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
129             put_bits(&s->pb,9,(s->width >> 2) - 1);
130             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
131             put_bits(&s->pb,9,(s->height >> 2));
132         }
133         
134         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
135         if (s->umvplus)
136             put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
137         put_bits(&s->pb, 5, s->qscale);
138     }
139
140     put_bits(&s->pb, 1, 0);     /* no PEI */
141 }
142
143 void h263_encode_mb(MpegEncContext * s,
144                     DCTELEM block[6][64],
145                     int motion_x, int motion_y)
146 {
147     int cbpc, cbpy, i, cbp, pred_x, pred_y;
148
149     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
150    if (!s->mb_intra) {
151            /* compute cbp */
152            cbp = 0;
153            for (i = 0; i < 6; i++) {
154               if (s->block_last_index[i] >= 0)
155                    cbp |= 1 << (5 - i);
156            }
157            if ((cbp | motion_x | motion_y) == 0) {
158               /* skip macroblock */
159               put_bits(&s->pb, 1, 1);
160               return;
161            }
162            put_bits(&s->pb, 1, 0);      /* mb coded */
163            cbpc = cbp & 3;
164            put_bits(&s->pb,
165                 inter_MCBPC_bits[cbpc],
166                 inter_MCBPC_code[cbpc]);
167            cbpy = cbp >> 2;
168            cbpy ^= 0xf;
169            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
170
171            /* motion vectors: 16x16 mode only now */
172       h263_pred_motion(s, 0, &pred_x, &pred_y);
173       
174       if (!s->umvplus) {  
175          h263_encode_motion(s, motion_x - pred_x);
176          h263_encode_motion(s, motion_y - pred_y);
177       }
178       else {
179          h263p_encode_umotion(s, motion_x - pred_x);
180          h263p_encode_umotion(s, motion_y - pred_y);
181          if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
182             /* To prevent Start Code emulation */
183             put_bits(&s->pb,1,1);
184       }
185    } else {
186         /* compute cbp */
187         cbp = 0;
188         for (i = 0; i < 6; i++) {
189             if (s->block_last_index[i] >= 1)
190                 cbp |= 1 << (5 - i);
191         }
192
193         cbpc = cbp & 3;
194         if (s->pict_type == I_TYPE) {
195             put_bits(&s->pb,
196                      intra_MCBPC_bits[cbpc],
197                      intra_MCBPC_code[cbpc]);
198         } else {
199             put_bits(&s->pb, 1, 0);     /* mb coded */
200             put_bits(&s->pb,
201                      inter_MCBPC_bits[cbpc + 4],
202                      inter_MCBPC_code[cbpc + 4]);
203         }
204         if (s->h263_pred) {
205             /* XXX: currently, we do not try to use ac prediction */
206             put_bits(&s->pb, 1, 0);     /* no ac prediction */
207         }
208         cbpy = cbp >> 2;
209         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
210     }
211
212     /* encode each block */
213     if (s->h263_pred) {
214         for (i = 0; i < 6; i++) {
215             mpeg4_encode_block(s, block[i], i);
216         }
217     } else {
218         for (i = 0; i < 6; i++) {
219             h263_encode_block(s, block[i], i);
220         }
221     }
222 }
223
224 static inline int mid_pred(int a, int b, int c)
225 {
226     int vmin, vmax;
227     vmin = a;
228     if (b < vmin)
229         vmin = b;
230     if (c < vmin)
231         vmin = c;
232
233     vmax = a;
234     if (b > vmax)
235         vmax = b;
236     if (c > vmax)
237         vmax = c;
238
239     return a + b + c - vmin - vmax;
240 }
241
242 INT16 *h263_pred_motion(MpegEncContext * s, int block, 
243                         int *px, int *py)
244 {
245     int x, y, wrap;
246     INT16 *A, *B, *C, *mot_val;
247
248     x = 2 * s->mb_x + 1 + (block & 1);
249     y = 2 * s->mb_y + 1 + ((block >> 1) & 1);
250     wrap = 2 * s->mb_width + 2;
251
252     mot_val = s->motion_val[(x) + (y) * wrap];
253
254     /* special case for first line */
255     if (y == 1 || s->first_slice_line || s->first_gob_line) {
256         A = s->motion_val[(x-1) + (y) * wrap];
257         *px = A[0];
258         *py = A[1];
259     } else {
260         switch(block) {
261         default:
262         case 0:
263             A = s->motion_val[(x-1) + (y) * wrap];
264             B = s->motion_val[(x) + (y-1) * wrap];
265             C = s->motion_val[(x+2) + (y-1) * wrap];
266             break;
267         case 1:
268         case 2:
269             A = s->motion_val[(x-1) + (y) * wrap];
270             B = s->motion_val[(x) + (y-1) * wrap];
271             C = s->motion_val[(x+1) + (y-1) * wrap];
272             break;
273         case 3:
274             A = s->motion_val[(x-1) + (y) * wrap];
275             B = s->motion_val[(x-1) + (y-1) * wrap];
276             C = s->motion_val[(x) + (y-1) * wrap];
277             break;
278         }
279         *px = mid_pred(A[0], B[0], C[0]);
280         *py = mid_pred(A[1], B[1], C[1]);
281     }
282     return mot_val;
283 }
284
285
286 static void h263_encode_motion(MpegEncContext * s, int val)
287 {
288     int range, l, m, bit_size, sign, code, bits;
289
290     if (val == 0) {
291         /* zero vector */
292         code = 0;
293         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
294     } else {
295         bit_size = s->f_code - 1;
296         range = 1 << bit_size;
297         /* modulo encoding */
298         l = range * 32;
299         m = 2 * l;
300         if (val < -l) {
301             val += m;
302         } else if (val >= l) {
303             val -= m;
304         }
305
306         if (val >= 0) {
307             val--;
308             code = (val >> bit_size) + 1;
309             bits = val & (range - 1);
310             sign = 0;
311         } else {
312             val = -val;
313             val--;
314             code = (val >> bit_size) + 1;
315             bits = val & (range - 1);
316             sign = 1;
317         }
318
319         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
320         if (bit_size > 0) {
321             put_bits(&s->pb, bit_size, bits);
322         }
323     }
324 }
325
326 /* Encode MV differences on H.263+ with Unrestricted MV mode */
327 static void h263p_encode_umotion(MpegEncContext * s, int val)
328 {
329     short sval = 0; 
330     short i = 0;
331     short n_bits = 0;
332     short temp_val;
333     int code = 0;
334     int tcode;
335     
336     if ( val == 0)
337         put_bits(&s->pb, 1, 1);
338     else if (val == 1)
339         put_bits(&s->pb, 3, 0);
340     else if (val == -1)
341         put_bits(&s->pb, 3, 2);
342     else {
343         
344         sval = ((val < 0) ? (short)(-val):(short)val);
345         temp_val = sval;
346         
347         while (temp_val != 0) {
348             temp_val = temp_val >> 1;
349             n_bits++;
350         }
351         
352         i = n_bits - 1;
353         while (i > 0) {
354             tcode = (sval & (1 << (i-1))) >> (i-1);
355             tcode = (tcode << 1) | 1;
356             code = (code << 2) | tcode;
357             i--;
358         }
359         code = ((code << 1) | (val < 0)) << 1;
360         put_bits(&s->pb, (2*n_bits)+1, code);
361         //printf("\nVal = %d\tCode = %d", sval, code);
362     }
363 }
364
365 void h263_encode_init_vlc(MpegEncContext *s)
366 {
367     static int done = 0;
368
369     if (!done) {
370         done = 1;
371         init_rl(&rl_inter);
372         init_rl(&rl_intra);
373     }
374 }
375
376 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
377 {
378     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
379     int code;
380     RLTable *rl = &rl_inter;
381
382     if (s->mb_intra) {
383         /* DC coef */
384         level = block[0];
385         /* 255 cannot be represented, so we clamp */
386         if (level > 254) {
387             level = 254;
388             block[0] = 254;
389         }
390         if (level == 128)
391             put_bits(&s->pb, 8, 0xff);
392         else
393             put_bits(&s->pb, 8, level & 0xff);
394         i = 1;
395     } else {
396         i = 0;
397     }
398
399     /* AC coefs */
400     last_index = s->block_last_index[n];
401     last_non_zero = i - 1;
402     for (; i <= last_index; i++) {
403         j = zigzag_direct[i];
404         level = block[j];
405         if (level) {
406             run = i - last_non_zero - 1;
407             last = (i == last_index);
408             sign = 0;
409             slevel = level;
410             if (level < 0) {
411                 sign = 1;
412                 level = -level;
413             }
414             code = get_rl_index(rl, last, run, level);
415             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
416             if (code == rl->n) {
417                 put_bits(&s->pb, 1, last);
418                 put_bits(&s->pb, 6, run);
419                 put_bits(&s->pb, 8, slevel & 0xff);
420             } else {
421                 put_bits(&s->pb, 1, sign);
422             }
423             last_non_zero = i;
424         }
425     }
426 }
427
428 /***************************************************/
429
430 /* write mpeg4 VOP header */
431 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
432 {
433     align_put_bits(&s->pb);
434
435     put_bits(&s->pb, 32, 0x1B6);        /* vop header */
436     put_bits(&s->pb, 2, s->pict_type - 1);      /* pict type: I = 0 , P = 1 */
437     /* XXX: time base + 1 not always correct */
438     put_bits(&s->pb, 1, 1);
439     put_bits(&s->pb, 1, 0);
440
441     put_bits(&s->pb, 1, 1);     /* marker */
442     put_bits(&s->pb, 4, 1);     /* XXX: correct time increment */
443     put_bits(&s->pb, 1, 1);     /* marker */
444     put_bits(&s->pb, 1, 1);     /* vop coded */
445     if (s->pict_type == P_TYPE) {
446         s->no_rounding = 0;
447         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
448     }
449     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
450
451     put_bits(&s->pb, 5, s->qscale);
452
453     if (s->pict_type != I_TYPE)
454         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
455     //    printf("****frame %d\n", picture_number);
456 }
457
458 void h263_dc_scale(MpegEncContext * s)
459 {
460     int quant;
461
462     quant = s->qscale;
463     /* luminance */
464     if (quant < 5)
465         s->y_dc_scale = 8;
466     else if (quant > 4 && quant < 9)
467         s->y_dc_scale = (2 * quant);
468     else if (quant > 8 && quant < 25)
469         s->y_dc_scale = (quant + 8);
470     else
471         s->y_dc_scale = (2 * quant - 16);
472     /* chrominance */
473     if (quant < 5)
474         s->c_dc_scale = 8;
475     else if (quant > 4 && quant < 25)
476         s->c_dc_scale = ((quant + 13) / 2);
477     else
478         s->c_dc_scale = (quant - 6);
479 }
480
481 static int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
482 {
483     int a, b, c, x, y, wrap, pred, scale;
484     UINT16 *dc_val;
485
486     /* find prediction */
487     if (n < 4) {
488         x = 2 * s->mb_x + 1 + (n & 1);
489         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
490         wrap = s->mb_width * 2 + 2;
491         dc_val = s->dc_val[0];
492         scale = s->y_dc_scale;
493     } else {
494         x = s->mb_x + 1;
495         y = s->mb_y + 1;
496         wrap = s->mb_width + 2;
497         dc_val = s->dc_val[n - 4 + 1];
498         scale = s->c_dc_scale;
499     }
500
501     /* B C
502      * A X 
503      */
504     a = dc_val[(x - 1) + (y) * wrap];
505     b = dc_val[(x - 1) + (y - 1) * wrap];
506     c = dc_val[(x) + (y - 1) * wrap];
507
508     if (abs(a - b) < abs(b - c)) {
509         pred = c;
510         *dir_ptr = 1; /* top */
511     } else {
512         pred = a;
513         *dir_ptr = 0; /* left */
514     }
515     /* we assume pred is positive */
516     pred = (pred + (scale >> 1)) / scale;
517
518     /* prepare address for prediction update */
519     *dc_val_ptr = &dc_val[(x) + (y) * wrap];
520
521     return pred;
522 }
523
524 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n, 
525                    int dir)
526 {
527     int x, y, wrap, i;
528     INT16 *ac_val, *ac_val1;
529
530     /* find prediction */
531     if (n < 4) {
532         x = 2 * s->mb_x + 1 + (n & 1);
533         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
534         wrap = s->mb_width * 2 + 2;
535         ac_val = s->ac_val[0][0];
536     } else {
537         x = s->mb_x + 1;
538         y = s->mb_y + 1;
539         wrap = s->mb_width + 2;
540         ac_val = s->ac_val[n - 4 + 1][0];
541     }
542     ac_val += ((y) * wrap + (x)) * 16;
543     ac_val1 = ac_val;
544     if (s->ac_pred) {
545         if (dir == 0) {
546             /* left prediction */
547             ac_val -= 16;
548             for(i=1;i<8;i++) {
549                 block[i*8] += ac_val[i];
550             }
551         } else {
552             /* top prediction */
553             ac_val -= 16 * wrap;
554             for(i=1;i<8;i++) {
555                 block[i] += ac_val[i + 8];
556             }
557         }
558     }
559     /* left copy */
560     for(i=1;i<8;i++)
561         ac_val1[i] = block[i * 8];
562     /* top copy */
563     for(i=1;i<8;i++)
564         ac_val1[8 + i] = block[i];
565 }
566
567 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
568 {
569     int size, v, pred;
570     UINT16 *dc_val;
571
572     pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
573     if (n < 4) {
574         *dc_val = level * s->y_dc_scale;
575     } else {
576         *dc_val = level * s->c_dc_scale;
577     }
578
579     /* do the prediction */
580     level -= pred;
581     /* find number of bits */
582     size = 0;
583     v = abs(level);
584     while (v) {
585         v >>= 1;
586         size++;
587     }
588
589     if (n < 4) {
590         /* luminance */
591         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
592     } else {
593         /* chrominance */
594         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
595     }
596
597     /* encode remaining bits */
598     if (size > 0) {
599         if (level < 0)
600             level = (-level) ^ ((1 << size) - 1);
601         put_bits(&s->pb, size, level);
602         if (size > 8)
603             put_bits(&s->pb, 1, 1);
604     }
605 }
606
607 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
608 {
609     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
610     int code, dc_pred_dir;
611     const RLTable *rl;
612
613     if (s->mb_intra) {
614         /* mpeg4 based DC predictor */
615         mpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
616         i = 1;
617         rl = &rl_intra;
618     } else {
619         i = 0;
620         rl = &rl_inter;
621     }
622
623     /* AC coefs */
624     last_index = s->block_last_index[n];
625     last_non_zero = i - 1;
626     for (; i <= last_index; i++) {
627         j = zigzag_direct[i];
628         level = block[j];
629         if (level) {
630             run = i - last_non_zero - 1;
631             last = (i == last_index);
632             sign = 0;
633             slevel = level;
634             if (level < 0) {
635                 sign = 1;
636                 level = -level;
637             }
638             code = get_rl_index(rl, last, run, level);
639             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
640             if (code == rl->n) {
641                 int level1, run1;
642                 level1 = level - rl->max_level[last][run];
643                 if (level1 < 1) 
644                     goto esc2;
645                 code = get_rl_index(rl, last, run, level1);
646                 if (code == rl->n) {
647                 esc2:
648                     put_bits(&s->pb, 1, 1);
649                     if (level > MAX_LEVEL)
650                         goto esc3;
651                     run1 = run - rl->max_run[last][level] - 1;
652                     if (run1 < 0)
653                         goto esc3;
654                     code = get_rl_index(rl, last, run1, level);
655                     if (code == rl->n) {
656                     esc3:
657                         /* third escape */
658                         put_bits(&s->pb, 1, 1);
659                         put_bits(&s->pb, 1, last);
660                         put_bits(&s->pb, 6, run);
661                         put_bits(&s->pb, 1, 1);
662                         put_bits(&s->pb, 12, slevel & 0xfff);
663                         put_bits(&s->pb, 1, 1);
664                     } else {
665                         /* second escape */
666                         put_bits(&s->pb, 1, 0);
667                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
668                         put_bits(&s->pb, 1, sign);
669                     }
670                 } else {
671                     /* first escape */
672                     put_bits(&s->pb, 1, 0);
673                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
674                     put_bits(&s->pb, 1, sign);
675                 }
676             } else {
677                 put_bits(&s->pb, 1, sign);
678             }
679             last_non_zero = i;
680         }
681     }
682 }
683
684
685
686 /***********************************************/
687 /* decoding */
688
689 static VLC intra_MCBPC_vlc;
690 static VLC inter_MCBPC_vlc;
691 static VLC cbpy_vlc;
692 static VLC mv_vlc;
693 static VLC dc_lum, dc_chrom;
694
695 void init_rl(RLTable *rl)
696 {
697     INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
698     UINT8 index_run[MAX_RUN+1];
699     int last, run, level, start, end, i;
700
701     /* compute max_level[], max_run[] and index_run[] */
702     for(last=0;last<2;last++) {
703         if (last == 0) {
704             start = 0;
705             end = rl->last;
706         } else {
707             start = rl->last;
708             end = rl->n;
709         }
710
711         memset(max_level, 0, MAX_RUN + 1);
712         memset(max_run, 0, MAX_LEVEL + 1);
713         memset(index_run, rl->n, MAX_RUN + 1);
714         for(i=start;i<end;i++) {
715             run = rl->table_run[i];
716             level = rl->table_level[i];
717             if (index_run[run] == rl->n)
718                 index_run[run] = i;
719             if (level > max_level[run])
720                 max_level[run] = level;
721             if (run > max_run[level])
722                 max_run[level] = run;
723         }
724         rl->max_level[last] = malloc(MAX_RUN + 1);
725         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
726         rl->max_run[last] = malloc(MAX_LEVEL + 1);
727         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
728         rl->index_run[last] = malloc(MAX_RUN + 1);
729         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
730     }
731 }
732
733 void init_vlc_rl(RLTable *rl)
734 {
735     init_vlc(&rl->vlc, 9, rl->n + 1, 
736              &rl->table_vlc[0][1], 4, 2,
737              &rl->table_vlc[0][0], 4, 2);
738 }
739
740 /* init vlcs */
741
742 /* XXX: find a better solution to handle static init */
743 void h263_decode_init_vlc(MpegEncContext *s)
744 {
745     static int done = 0;
746
747     if (!done) {
748         done = 1;
749
750         init_vlc(&intra_MCBPC_vlc, 6, 8, 
751                  intra_MCBPC_bits, 1, 1,
752                  intra_MCBPC_code, 1, 1);
753         init_vlc(&inter_MCBPC_vlc, 9, 25, 
754                  inter_MCBPC_bits, 1, 1,
755                  inter_MCBPC_code, 1, 1);
756         init_vlc(&cbpy_vlc, 6, 16,
757                  &cbpy_tab[0][1], 2, 1,
758                  &cbpy_tab[0][0], 2, 1);
759         init_vlc(&mv_vlc, 9, 33,
760                  &mvtab[0][1], 2, 1,
761                  &mvtab[0][0], 2, 1);
762         init_rl(&rl_inter);
763         init_rl(&rl_intra);
764         init_vlc_rl(&rl_inter);
765         init_vlc_rl(&rl_intra);
766         init_vlc(&dc_lum, 9, 13,
767                  &DCtab_lum[0][1], 2, 1,
768                  &DCtab_lum[0][0], 2, 1);
769         init_vlc(&dc_chrom, 9, 13,
770                  &DCtab_chrom[0][1], 2, 1,
771                  &DCtab_chrom[0][0], 2, 1);
772     }
773 }
774
775 int h263_decode_mb(MpegEncContext *s,
776                    DCTELEM block[6][64])
777 {
778     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
779     unsigned int val;
780     INT16 *mot_val;
781     static INT8 quant_tab[4] = { -1, -2, 1, 2 };
782     unsigned int gfid;        
783     
784     /* Check for GOB Start Code */
785     if (s->mb_x == 0) {
786         val = show_bits(&s->gb, 16);
787         if (val == 0) {
788             /* We have a GBSC probably with GSTUFF */
789             skip_bits(&s->gb, 16); /* Drop the zeros */
790             while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
791 #ifdef DEBUG
792             fprintf(stderr,"\nGOB Start Code at MB %d\n", 
793                 (s->mb_y * s->mb_width) + s->mb_x);
794 #endif
795             s->gob_number = get_bits(&s->gb, 5); /* GN */
796             gfid = get_bits(&s->gb, 2); /* GFID */
797             s->qscale = get_bits(&s->gb, 5); /* GQUANT */
798 #ifdef DEBUG
799             fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", gn, gfid, s->qscale);
800 #endif
801         }
802     }
803     /* FIXME: In the future H.263+ will have intra prediction */
804     /* and we are gonna need another way to detect MPEG4      */
805     if (!s->h263_pred) {
806         if (s->mb_y == s->gob_number)
807             s->first_gob_line = 1;
808         else
809             s->first_gob_line = 0;
810     }        
811     if (s->pict_type == P_TYPE) {
812         if (get_bits1(&s->gb)) {
813             /* skip mb */
814             s->mb_intra = 0;
815             for(i=0;i<6;i++)
816                 s->block_last_index[i] = -1;
817             s->mv_dir = MV_DIR_FORWARD;
818             s->mv_type = MV_TYPE_16X16;
819             s->mv[0][0][0] = 0;
820             s->mv[0][0][1] = 0;
821             s->mb_skiped = 1;
822             return 0;
823         }
824         cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
825         //fprintf(stderr, "\tCBPC: %d", cbpc);
826         if (cbpc < 0)
827             return -1;
828         if (cbpc > 20)
829             cbpc+=3;
830         else if (cbpc == 20)
831             fprintf(stderr, "Stuffing !");
832         
833         dquant = cbpc & 8;
834         s->mb_intra = ((cbpc & 4) != 0);
835     } else {
836         cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
837         if (cbpc < 0)
838             return -1;
839         dquant = cbpc & 4;
840         s->mb_intra = 1;
841     }
842
843     if (!s->mb_intra) {
844         cbpy = get_vlc(&s->gb, &cbpy_vlc);
845         cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
846         if (dquant) {
847             s->qscale += quant_tab[get_bits(&s->gb, 2)];
848             if (s->qscale < 1)
849                 s->qscale = 1;
850             else if (s->qscale > 31)
851                 s->qscale = 31;
852         }
853         s->mv_dir = MV_DIR_FORWARD;
854         if ((cbpc & 16) == 0) {
855             /* 16x16 motion prediction */
856             s->mv_type = MV_TYPE_16X16;
857             h263_pred_motion(s, 0, &pred_x, &pred_y);
858             if (s->umvplus_dec)
859                mx = h263p_decode_umotion(s, pred_x);
860             else
861                mx = h263_decode_motion(s, pred_x);
862             if (mx >= 0xffff)
863                 return -1;
864             
865             if (s->umvplus_dec)
866                my = h263p_decode_umotion(s, pred_y);
867             else    
868                my = h263_decode_motion(s, pred_y);
869             if (my >= 0xffff)
870                 return -1;
871             s->mv[0][0][0] = mx;
872             s->mv[0][0][1] = my;
873             /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
874             fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
875             fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
876             if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
877                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
878                            
879         } else {
880             s->mv_type = MV_TYPE_8X8;
881             for(i=0;i<4;i++) {
882                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
883                 if (s->umvplus_dec)
884                   mx = h263p_decode_umotion(s, pred_x);
885                 else
886                   mx = h263_decode_motion(s, pred_x);
887                 if (mx >= 0xffff)
888                     return -1;
889                 
890                 if (s->umvplus_dec)
891                   my = h263p_decode_umotion(s, pred_y);
892                 else    
893                   my = h263_decode_motion(s, pred_y);
894                 if (my >= 0xffff)
895                     return -1;
896                 s->mv[0][i][0] = mx;
897                 s->mv[0][i][1] = my;
898                 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
899                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
900                 mot_val[0] = mx;
901                 mot_val[1] = my;
902             }
903         }
904     } else {
905         s->ac_pred = 0;
906             if (s->h263_pred) {
907             s->ac_pred = get_bits1(&s->gb);
908         }
909         cbpy = get_vlc(&s->gb, &cbpy_vlc);
910         cbp = (cbpc & 3) | (cbpy << 2);
911         if (dquant) {
912             s->qscale += quant_tab[get_bits(&s->gb, 2)];
913             if (s->qscale < 1)
914                 s->qscale = 1;
915             else if (s->qscale > 31)
916                 s->qscale = 31;
917         }
918     }
919
920     /* decode each block */
921     if (s->h263_pred) {
922         for (i = 0; i < 6; i++) {
923             if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
924                 return -1;
925         }
926     } else {
927         for (i = 0; i < 6; i++) {
928             if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
929                 return -1;
930         }
931     }
932     return 0;
933 }
934
935 static int h263_decode_motion(MpegEncContext * s, int pred)
936 {
937     int code, val, sign, shift, l, m;
938
939     code = get_vlc(&s->gb, &mv_vlc);
940     if (code < 0)
941         return 0xffff;
942
943     if (code == 0)
944         return pred;
945     sign = get_bits1(&s->gb);
946     shift = s->f_code - 1;
947     val = (code - 1) << shift;
948     if (shift > 0)
949         val |= get_bits(&s->gb, shift);
950     val++;
951     if (sign)
952         val = -val;
953     val += pred;
954     
955     /* modulo decoding */
956     if (!s->h263_long_vectors) {
957         l = (1 << (s->f_code - 1)) * 32;
958         m = 2 * l;
959         if (val < -l) {
960             val += m;
961         } else if (val >= l) {
962             val -= m;
963         }
964     } else {
965         /* horrible h263 long vector mode */
966         if (pred < -31 && val < -63)
967             val += 64;
968         if (pred > 32 && val > 63)
969             val -= 64;
970         
971     }
972     return val;
973 }
974
975 /* Decodes RVLC of H.263+ UMV */
976 static int h263p_decode_umotion(MpegEncContext * s, int pred)
977 {
978    int code = 0, sign;
979    
980    if (get_bits1(&s->gb)) /* Motion difference = 0 */
981       return pred;
982    
983    code = 2 + get_bits1(&s->gb);
984    
985    while (get_bits1(&s->gb))
986    {
987       code <<= 1;
988       code += get_bits1(&s->gb);
989    }
990    sign = code & 1;
991    code >>= 1;
992    
993    code = (sign) ? (pred - code) : (pred + code);
994 #ifdef DEBUG
995    fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
996 #endif
997    return code;   
998
999 }
1000
1001 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
1002                              int n, int coded)
1003 {
1004     int code, level, i, j, last, run;
1005     RLTable *rl = &rl_inter;
1006
1007     if (s->mb_intra) {
1008         /* DC coef */
1009         if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
1010             int component, diff;
1011             component = (n <= 3 ? 0 : n - 4 + 1);
1012             level = s->last_dc[component];
1013             if (s->rv10_first_dc_coded[component]) {
1014                 diff = rv_decode_dc(s, n);
1015                 if (diff == 0xffff)
1016                     return -1;
1017                 level += diff;
1018                 level = level & 0xff; /* handle wrap round */
1019                 s->last_dc[component] = level;
1020             } else {
1021                 s->rv10_first_dc_coded[component] = 1;
1022             }
1023         } else {
1024             level = get_bits(&s->gb, 8);
1025             if (level == 255)
1026                 level = 128;
1027         }
1028         block[0] = level;
1029         i = 1;
1030     } else {
1031         i = 0;
1032     }
1033     if (!coded) {
1034         s->block_last_index[n] = i - 1;
1035         return 0;
1036     }
1037
1038     for(;;) {
1039         code = get_vlc(&s->gb, &rl->vlc);
1040         if (code < 0)
1041             return -1;
1042         if (code == rl->n) {
1043             /* escape */
1044             last = get_bits1(&s->gb);
1045             run = get_bits(&s->gb, 6);
1046             level = (INT8)get_bits(&s->gb, 8);
1047             if (s->h263_rv10 && level == -128) {
1048                 /* XXX: should patch encoder too */
1049                 level = get_bits(&s->gb, 12);
1050                 level = (level << 20) >> 20;
1051             }
1052         } else {
1053             run = rl->table_run[code];
1054             level = rl->table_level[code];
1055             last = code >= rl->last;
1056             if (get_bits1(&s->gb))
1057                 level = -level;
1058         }
1059         i += run;
1060         if (i >= 64)
1061             return -1;
1062         j = zigzag_direct[i];
1063         block[j] = level;
1064         if (last)
1065             break;
1066         i++;
1067     }
1068     s->block_last_index[n] = i;
1069     return 0;
1070 }
1071
1072 static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1073 {
1074     int level, pred, code;
1075     UINT16 *dc_val;
1076
1077     if (n < 4) 
1078         code = get_vlc(&s->gb, &dc_lum);
1079     else 
1080         code = get_vlc(&s->gb, &dc_chrom);
1081     if (code < 0)
1082         return -1;
1083     if (code == 0) {
1084         level = 0;
1085     } else {
1086         level = get_bits(&s->gb, code);
1087         if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
1088             level = - (level ^ ((1 << code) - 1));
1089         if (code > 8)
1090             skip_bits1(&s->gb); /* marker */
1091     }
1092
1093     pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1094     level += pred;
1095     if (level < 0)
1096         level = 0;
1097     if (n < 4) {
1098         *dc_val = level * s->y_dc_scale;
1099     } else {
1100         *dc_val = level * s->c_dc_scale;
1101     }
1102     return level;
1103 }
1104
1105 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1106                               int n, int coded)
1107 {
1108     int code, level, i, j, last, run;
1109     int dc_pred_dir;
1110     RLTable *rl;
1111     const UINT8 *scan_table;
1112
1113     if (s->mb_intra) {
1114         /* DC coef */
1115         level = mpeg4_decode_dc(s, n, &dc_pred_dir);
1116         if (level < 0)
1117             return -1;
1118         block[0] = level;
1119         i = 1;
1120         if (!coded) 
1121             goto not_coded;
1122         rl = &rl_intra;
1123         if (s->ac_pred) {
1124             if (dc_pred_dir == 0) 
1125                 scan_table = ff_alternate_vertical_scan; /* left */
1126             else
1127                 scan_table = ff_alternate_horizontal_scan; /* top */
1128         } else {
1129             scan_table = zigzag_direct;
1130         }
1131     } else {
1132         i = 0;
1133         if (!coded) {
1134             s->block_last_index[n] = i - 1;
1135             return 0;
1136         }
1137         rl = &rl_inter;
1138         scan_table = zigzag_direct;
1139     }
1140
1141     for(;;) {
1142         code = get_vlc(&s->gb, &rl->vlc);
1143         if (code < 0)
1144             return -1;
1145         if (code == rl->n) {
1146             /* escape */
1147             if (get_bits1(&s->gb) != 0) {
1148                 if (get_bits1(&s->gb) != 0) {
1149                     /* third escape */
1150                     last = get_bits1(&s->gb);
1151                     run = get_bits(&s->gb, 6);
1152                     get_bits1(&s->gb); /* marker */
1153                     level = get_bits(&s->gb, 12);
1154                     level = (level << 20) >> 20; /* sign extend */
1155                     skip_bits1(&s->gb); /* marker */
1156                 } else {
1157                     /* second escape */
1158                     code = get_vlc(&s->gb, &rl->vlc);
1159                     if (code < 0 || code >= rl->n)
1160                         return -1;
1161                     run = rl->table_run[code];
1162                     level = rl->table_level[code];
1163                     last = code >= rl->last;
1164                     run += rl->max_run[last][level] + 1;
1165                     if (get_bits1(&s->gb))
1166                         level = -level;
1167                 }
1168             } else {
1169                 /* first escape */
1170                 code = get_vlc(&s->gb, &rl->vlc);
1171                 if (code < 0 || code >= rl->n)
1172                     return -1;
1173                 run = rl->table_run[code];
1174                 level = rl->table_level[code];
1175                 last = code >= rl->last;
1176                 level += rl->max_level[last][run];
1177                 if (get_bits1(&s->gb))
1178                     level = -level;
1179             }
1180         } else {
1181             run = rl->table_run[code];
1182             level = rl->table_level[code];
1183             last = code >= rl->last;
1184             if (get_bits1(&s->gb))
1185                 level = -level;
1186         }
1187         i += run;
1188         if (i >= 64)
1189             return -1;
1190         j = scan_table[i];
1191         block[j] = level;
1192         i++;
1193         if (last)
1194             break;
1195     }
1196  not_coded:
1197     if (s->mb_intra) {
1198         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1199         if (s->ac_pred) {
1200             i = 64; /* XXX: not optimal */
1201         }
1202     }
1203     s->block_last_index[n] = i - 1;
1204     return 0;
1205 }
1206
1207 /* most is hardcoded. should extend to handle all h263 streams */
1208 int h263_decode_picture_header(MpegEncContext *s)
1209 {
1210     int format, width, height;
1211
1212     /* picture header */
1213     if (get_bits(&s->gb, 22) != 0x20)
1214         return -1;
1215     skip_bits(&s->gb, 8); /* picture timestamp */
1216
1217     if (get_bits1(&s->gb) != 1)
1218         return -1;      /* marker */
1219     if (get_bits1(&s->gb) != 0)
1220         return -1;      /* h263 id */
1221     skip_bits1(&s->gb); /* split screen off */
1222     skip_bits1(&s->gb); /* camera  off */
1223     skip_bits1(&s->gb); /* freeze picture release off */
1224
1225     /* Reset GOB number */
1226     s->gob_number = 0;
1227         
1228     format = get_bits(&s->gb, 3);
1229
1230     if (format != 7 && format != 6) {
1231         s->h263_plus = 0;
1232         /* H.263v1 */
1233         width = h263_format[format][0];
1234         height = h263_format[format][1];
1235         if (!width)
1236             return -1;
1237         
1238         s->width = width;
1239         s->height = height;
1240         s->pict_type = I_TYPE + get_bits1(&s->gb);
1241
1242         s->unrestricted_mv = get_bits1(&s->gb); 
1243         s->h263_long_vectors = s->unrestricted_mv;
1244
1245         if (get_bits1(&s->gb) != 0)
1246             return -1;  /* SAC: off */
1247         if (get_bits1(&s->gb) != 0) {
1248             s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1249         }   
1250         
1251         if (get_bits1(&s->gb) != 0)
1252             return -1;  /* not PB frame */
1253
1254         s->qscale = get_bits(&s->gb, 5);
1255         skip_bits1(&s->gb);     /* Continuous Presence Multipoint mode: off */
1256     } else {
1257         int ufep;
1258         
1259         /* H.263v2 */
1260         s->h263_plus = 1;
1261         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
1262         
1263         if (ufep == 1) {
1264             /* OPPTYPE */       
1265             format = get_bits(&s->gb, 3);
1266             skip_bits(&s->gb,1); /* Custom PCF */
1267             s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
1268             skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
1269             if (get_bits1(&s->gb) != 0) {
1270                 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1271             }
1272             skip_bits(&s->gb, 8);
1273             skip_bits(&s->gb, 3); /* Reserved */
1274         } else if (ufep != 0)
1275             return -1;
1276             
1277         /* MPPTYPE */
1278         s->pict_type = get_bits(&s->gb, 3) + 1;
1279         if (s->pict_type != I_TYPE &&
1280             s->pict_type != P_TYPE)
1281             return -1;
1282         skip_bits(&s->gb, 7);
1283         
1284         /* Get the picture dimensions */
1285         if (ufep) {
1286             if (format == 6) {
1287                 /* Custom Picture Format (CPFMT) */
1288                 skip_bits(&s->gb, 4); /* aspect ratio */
1289                 width = (get_bits(&s->gb, 9) + 1) * 4;
1290                 skip_bits1(&s->gb);
1291                 height = get_bits(&s->gb, 9) * 4;
1292 #ifdef DEBUG 
1293                 fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);
1294 #endif            
1295             }
1296             else {
1297                 width = h263_format[format][0];
1298                 height = h263_format[format][1];
1299             }
1300             if ((width == 0) || (height == 0))
1301                 return -1;
1302             s->width = width;
1303             s->height = height;
1304             if (s->umvplus_dec) {
1305                 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1306             }
1307         }
1308             
1309         s->qscale = get_bits(&s->gb, 5);
1310     }
1311     /* PEI */
1312     while (get_bits1(&s->gb) != 0) {
1313         skip_bits(&s->gb, 8);
1314     }
1315     s->f_code = 1;
1316     return 0;
1317 }
1318
1319 /* decode mpeg4 VOP header */
1320 int mpeg4_decode_picture_header(MpegEncContext * s)
1321 {
1322     int time_incr, startcode, state, v;
1323
1324  redo:
1325     /* search next start code */
1326     align_get_bits(&s->gb);
1327     state = 0xff;
1328     for(;;) {
1329         v = get_bits(&s->gb, 8);
1330         if (state == 0x000001) {
1331             state = ((state << 8) | v) & 0xffffff;
1332             startcode = state;
1333             break;
1334         }
1335         state = ((state << 8) | v) & 0xffffff;
1336         /* XXX: really detect end of frame */
1337         if (state == 0)
1338             return -1;
1339     }
1340
1341     if (startcode == 0x120) {
1342         int time_increment_resolution, width, height, vo_ver_id;
1343
1344         /* vol header */
1345         skip_bits(&s->gb, 1); /* random access */
1346         skip_bits(&s->gb, 8); /* vo_type */
1347         if (get_bits1(&s->gb) != 0) { /* is_ol_id */
1348             vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
1349             skip_bits(&s->gb, 3); /* vo_priority */
1350         } else {
1351             vo_ver_id = 1;
1352         }
1353         
1354         skip_bits(&s->gb, 4); /* aspect_ratio_info */
1355         skip_bits1(&s->gb); /* vol control parameter */
1356         s->shape = get_bits(&s->gb, 2); /* vol shape */
1357         skip_bits1(&s->gb);   /* marker */
1358         
1359         time_increment_resolution = get_bits(&s->gb, 16);
1360         s->time_increment_bits = av_log2(time_increment_resolution - 1) + 1;
1361         if (s->time_increment_bits < 1)
1362             s->time_increment_bits = 1;
1363         skip_bits1(&s->gb);   /* marker */
1364
1365         if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
1366             skip_bits(&s->gb, s->time_increment_bits);
1367         }
1368
1369         if (s->shape != 2) {
1370             if (s->shape == 0) {
1371                 skip_bits1(&s->gb);   /* marker */
1372                 width = get_bits(&s->gb, 13);
1373                 skip_bits1(&s->gb);   /* marker */
1374                 height = get_bits(&s->gb, 13);
1375                 skip_bits1(&s->gb);   /* marker */
1376             }
1377             
1378             skip_bits1(&s->gb);   /* interlaced */
1379             skip_bits1(&s->gb);   /* OBMC */
1380             if (vo_ver_id == 1) {
1381                 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
1382             } else {
1383                 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
1384             }
1385             if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
1386                 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
1387                 skip_bits(&s->gb, 4); /* bits_per_pixel */
1388             } else {
1389                 s->quant_precision = 5;
1390             }
1391             
1392             skip_bits1(&s->gb);   /* vol_quant_type */
1393             skip_bits1(&s->gb);   /* vol_quarter_pixel */
1394             skip_bits1(&s->gb);   /* complexity_estimation_disabled */
1395             skip_bits1(&s->gb);   /* resync_marker_disabled */
1396             skip_bits1(&s->gb);   /* data_partioning_enabled */
1397             if (get_bits1(&s->gb) != 0) { /* scalability */
1398                 printf("bad scalability!!!\n");
1399                 return -1;
1400             }
1401         }
1402         goto redo;
1403     } else if (startcode != 0x1b6) {
1404         goto redo;
1405     }
1406
1407     s->pict_type = get_bits(&s->gb, 2) + 1;     /* pict type: I = 0 , P = 1 */
1408     if (s->pict_type != I_TYPE &&
1409         s->pict_type != P_TYPE)
1410         return -1;
1411     
1412     /* XXX: parse time base */
1413     time_incr = 0;
1414     while (get_bits1(&s->gb) != 0) 
1415         time_incr++;
1416
1417     skip_bits1(&s->gb);         /* marker */
1418     skip_bits(&s->gb, s->time_increment_bits);
1419     skip_bits1(&s->gb);         /* marker */
1420     /* vop coded */
1421     if (get_bits1(&s->gb) != 1)
1422         goto redo;
1423     
1424     if (s->shape != 2 && s->pict_type == P_TYPE) {
1425         /* rounding type for motion estimation */
1426         s->no_rounding = get_bits1(&s->gb);
1427     } else {
1428         s->no_rounding = 0;
1429     }
1430     
1431      if (s->shape != 0) {
1432          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
1433              int width, height, hor_spat_ref, ver_spat_ref;
1434  
1435              width = get_bits(&s->gb, 13);
1436              skip_bits1(&s->gb);   /* marker */
1437              height = get_bits(&s->gb, 13);
1438              skip_bits1(&s->gb);   /* marker */
1439              hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
1440              skip_bits1(&s->gb);   /* marker */
1441              ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
1442          }
1443          skip_bits1(&s->gb); /* change_CR_disable */
1444  
1445          if (get_bits1(&s->gb) != 0) {
1446              skip_bits(&s->gb, 8); /* constant_alpha_value */
1447          }
1448      }
1449
1450      if (s->shape != 2) {
1451          skip_bits(&s->gb, 3); /* intra dc VLC threshold */
1452   
1453          /* note: we do not use quant_precision to avoid problem if no
1454             MPEG4 vol header as it is found on some old opendivx
1455             movies */
1456          s->qscale = get_bits(&s->gb, 5);
1457   
1458          if (s->pict_type != I_TYPE) {
1459              s->f_code = get_bits(&s->gb, 3);   /* fcode_for */
1460          }
1461          if (s->shape && (s->pict_type != I_TYPE)) {
1462              skip_bits1(&s->gb); // vop shape coding type
1463          }
1464      }
1465      return 0;
1466 }
1467
1468 /* don't understand why they choose a different header ! */
1469 int intel_h263_decode_picture_header(MpegEncContext *s)
1470 {
1471     int format;
1472
1473     /* picture header */
1474     if (get_bits(&s->gb, 22) != 0x20)
1475         return -1;
1476     skip_bits(&s->gb, 8); /* picture timestamp */
1477
1478     if (get_bits1(&s->gb) != 1)
1479         return -1;      /* marker */
1480     if (get_bits1(&s->gb) != 0)
1481         return -1;      /* h263 id */
1482     skip_bits1(&s->gb); /* split screen off */
1483     skip_bits1(&s->gb); /* camera  off */
1484     skip_bits1(&s->gb); /* freeze picture release off */
1485
1486     format = get_bits(&s->gb, 3);
1487     if (format != 7)
1488         return -1;
1489
1490     s->h263_plus = 0;
1491
1492     s->pict_type = I_TYPE + get_bits1(&s->gb);
1493     
1494     s->unrestricted_mv = get_bits1(&s->gb); 
1495     s->h263_long_vectors = s->unrestricted_mv;
1496
1497     if (get_bits1(&s->gb) != 0)
1498         return -1;      /* SAC: off */
1499     if (get_bits1(&s->gb) != 0)
1500         return -1;      /* advanced prediction mode: off */
1501     if (get_bits1(&s->gb) != 0)
1502         return -1;      /* not PB frame */
1503
1504     /* skip unknown header garbage */
1505     skip_bits(&s->gb, 41);
1506
1507     s->qscale = get_bits(&s->gb, 5);
1508     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1509
1510     /* PEI */
1511     while (get_bits1(&s->gb) != 0) {
1512         skip_bits(&s->gb, 8);
1513     }
1514     s->f_code = 1;
1515     return 0;
1516 }
1517