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