Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 11ce8834

History | View | Annotate | Download (80.3 KB)

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
 * ac prediction encoding by Michael Niedermayer <michaelni@gmx.at>
22
 */
23
#include "common.h"
24
#include "dsputil.h"
25
#include "avcodec.h"
26
#include "mpegvideo.h"
27
#include "h263data.h"
28
#include "mpeg4data.h"
29

    
30
//rounded divison & shift
31
#define RDIV(a,b) ((a) > 0 ? ((a)+((b)>>1))/(b) : ((a)-((b)>>1))/(b))
32
#define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
33
#define ABS(a) (((a)>=0)?(a):(-(a)))
34

    
35
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
36
                              int n);
37
static void h263_encode_motion(MpegEncContext * s, int val);
38
static void h263p_encode_umotion(MpegEncContext * s, int val);
39
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
40
                               int n, int dc, UINT8 *scan_table);
41
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
42
static int h263p_decode_umotion(MpegEncContext * s, int pred);
43
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
44
                             int n, int coded);
45
static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
46
                              int n, int coded);
47
static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
48
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
49
                              int dir);
50
extern UINT32 inverse[256];
51

    
52
static UINT16 mv_penalty[MAX_FCODE][MAX_MV*2+1];
53
static UINT8 fcode_tab[MAX_MV*2+1];
54

    
55
int h263_get_picture_format(int width, int height)
56
{
57
    int format;
58

    
59
    if (width == 128 && height == 96)
60
        format = 1;
61
    else if (width == 176 && height == 144)
62
        format = 2;
63
    else if (width == 352 && height == 288)
64
        format = 3;
65
    else if (width == 704 && height == 576)
66
        format = 4;
67
    else if (width == 1408 && height == 1152)
68
        format = 5;
69
    else
70
        format = 7;
71
    return format;
72
}
73

    
74
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
75
{
76
    int format;
77

    
78
    align_put_bits(&s->pb);
79

    
80
    /* Update the pointer to last GOB */
81
    s->ptr_lastgob = pbBufPtr(&s->pb);
82
    s->gob_number = 0;
83

    
84
    put_bits(&s->pb, 22, 0x20); /* PSC */
85
    put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / 
86
                         s->frame_rate) & 0xff);
87

    
88
    put_bits(&s->pb, 1, 1);        /* marker */
89
    put_bits(&s->pb, 1, 0);        /* h263 id */
90
    put_bits(&s->pb, 1, 0);        /* split screen off */
91
    put_bits(&s->pb, 1, 0);        /* camera  off */
92
    put_bits(&s->pb, 1, 0);        /* freeze picture release off */
93
    
94
    format = h263_get_picture_format(s->width, s->height);
95
    if (!s->h263_plus) {
96
        /* H.263v1 */
97
        put_bits(&s->pb, 3, format);
98
        put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
99
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
100
        of H.263v1 UMV implies to check the predicted MV after
101
        calculation of the current MB to see if we're on the limits */
102
        put_bits(&s->pb, 1, 0);        /* unrestricted motion vector: off */
103
        put_bits(&s->pb, 1, 0);        /* SAC: off */
104
        put_bits(&s->pb, 1, 0);        /* advanced prediction mode: off */
105
        put_bits(&s->pb, 1, 0);        /* not PB frame */
106
        put_bits(&s->pb, 5, s->qscale);
107
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
108
    } else {
109
        /* H.263v2 */
110
        /* H.263 Plus PTYPE */
111
        put_bits(&s->pb, 3, 7);
112
        put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
113
        if (format == 7)
114
            put_bits(&s->pb,3,6); /* Custom Source Format */
115
        else
116
            put_bits(&s->pb, 3, format);
117
            
118
        put_bits(&s->pb,1,0); /* Custom PCF: off */
119
        s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
120
        put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
121
        put_bits(&s->pb,1,0); /* SAC: off */
122
        put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
123
        put_bits(&s->pb,1,0); /* Advanced Intra Coding: off */
124
        put_bits(&s->pb,1,0); /* Deblocking Filter: off */
125
        put_bits(&s->pb,1,0); /* Slice Structured: off */
126
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
127
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
128
        put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
129
        put_bits(&s->pb,1,0); /* Modified Quantization: off */
130
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
131
        put_bits(&s->pb,3,0); /* Reserved */
132
                
133
        put_bits(&s->pb, 3, s->pict_type == P_TYPE);
134
                
135
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
136
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
137
        put_bits(&s->pb,1,0); /* Rounding Type */
138
        put_bits(&s->pb,2,0); /* Reserved */
139
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
140
                
141
        /* This should be here if PLUSPTYPE */
142
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
143
                
144
                if (format == 7) {
145
            /* Custom Picture Format (CPFMT) */
146
                
147
            put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
148
            put_bits(&s->pb,9,(s->width >> 2) - 1);
149
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
150
            put_bits(&s->pb,9,(s->height >> 2));
151
        }
152
        
153
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
154
        if (s->umvplus)
155
            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
156
        put_bits(&s->pb, 5, s->qscale);
157
    }
158

    
159
    put_bits(&s->pb, 1, 0);        /* no PEI */
160
}
161

    
162
int h263_encode_gob_header(MpegEncContext * s, int mb_line)
163
{
164
    int pdif=0;
165
    
166
    /* Check to see if we need to put a new GBSC */
167
    /* for RTP packetization                    */
168
    if (s->rtp_mode) {
169
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
170
        if (pdif >= s->rtp_payload_size) {
171
            /* Bad luck, packet must be cut before */
172
            align_put_bits(&s->pb);
173
            flush_put_bits(&s->pb);
174
            /* Call the RTP callback to send the last GOB */
175
            if (s->rtp_callback) {
176
                pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
177
                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
178
            }
179
            s->ptr_lastgob = pbBufPtr(&s->pb);
180
            put_bits(&s->pb, 17, 1); /* GBSC */
181
            s->gob_number = mb_line / s->gob_index;
182
            put_bits(&s->pb, 5, s->gob_number); /* GN */
183
            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
184
            put_bits(&s->pb, 5, s->qscale); /* GQUANT */
185
            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
186
            return pdif;
187
       } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
188
           /* Cut the packet before we can't */
189
           align_put_bits(&s->pb);
190
           flush_put_bits(&s->pb);
191
           /* Call the RTP callback to send the last GOB */
192
           if (s->rtp_callback) {
193
               pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
194
               s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
195
           }
196
           s->ptr_lastgob = pbBufPtr(&s->pb);
197
           put_bits(&s->pb, 17, 1); /* GBSC */
198
           s->gob_number = mb_line / s->gob_index;
199
           put_bits(&s->pb, 5, s->gob_number); /* GN */
200
           put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
201
           put_bits(&s->pb, 5, s->qscale); /* GQUANT */
202
           //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
203
           return pdif;
204
       }
205
   }
206
   return 0;
207
}
208

    
209
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
210
{
211
    int score0=0, score1=0;
212
    int i, n;
213

    
214
    for(n=0; n<6; n++){
215
        INT16 *ac_val, *ac_val1;
216

    
217
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
218
        ac_val1= ac_val;
219
        if(dir[n]){
220
            ac_val-= s->block_wrap[n]*16;
221
            for(i=1; i<8; i++){
222
                const int level= block[n][block_permute_op(i   )];
223
                score0+= ABS(level);
224
                score1+= ABS(level - ac_val[i+8]);
225
                ac_val1[i  ]=    block[n][block_permute_op(i<<3)];
226
                ac_val1[i+8]= level;
227
            }
228
        }else{
229
            ac_val-= 16;
230
            for(i=1; i<8; i++){
231
                const int level= block[n][block_permute_op(i<<3)];
232
                score0+= ABS(level);
233
                score1+= ABS(level - ac_val[i]);
234
                ac_val1[i  ]= level;
235
                ac_val1[i+8]=    block[n][block_permute_op(i   )];
236
            }
237
        }
238
    }
239

    
240
    return score0 > score1 ? 1 : 0;    
241
}
242

    
243
void mpeg4_encode_mb(MpegEncContext * s,
244
                    DCTELEM block[6][64],
245
                    int motion_x, int motion_y)
246
{
247
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
248
    
249
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
250
    if (!s->mb_intra) {
251
        /* compute cbp */
252
        cbp = 0;
253
        for (i = 0; i < 6; i++) {
254
        if (s->block_last_index[i] >= 0)
255
            cbp |= 1 << (5 - i);
256
        }
257
        if ((cbp | motion_x | motion_y) == 0) {
258
            /* skip macroblock */
259
            put_bits(&s->pb, 1, 1);
260
            return;
261
        }
262
        put_bits(&s->pb, 1, 0);        /* mb coded */
263
        cbpc = cbp & 3;
264
        put_bits(&s->pb,
265
                inter_MCBPC_bits[cbpc],
266
                inter_MCBPC_code[cbpc]);
267
        cbpy = cbp >> 2;
268
        cbpy ^= 0xf;
269
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
270

    
271
        /* motion vectors: 16x16 mode only now */
272
        h263_pred_motion(s, 0, &pred_x, &pred_y);
273
      
274
        h263_encode_motion(s, motion_x - pred_x);
275
        h263_encode_motion(s, motion_y - pred_y);
276

    
277
        /* encode each block */
278
        for (i = 0; i < 6; i++) {
279
            mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);
280
        }
281
    } else {
282
        int dc_diff[6];   //dc values with the dc prediction subtracted 
283
        int dir[6];  //prediction direction
284
        int zigzag_last_index[6];
285
        UINT8 *scan_table[6];
286

    
287
        for(i=0; i<6; i++){
288
            const int level= block[i][0];
289
            UINT16 *dc_ptr;
290

    
291
            dc_diff[i]= level - mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
292
            if (i < 4) {
293
                *dc_ptr = level * s->y_dc_scale;
294
            } else {
295
                *dc_ptr = level * s->c_dc_scale;
296
            }
297
        }
298

    
299
        s->ac_pred= decide_ac_pred(s, block, dir);
300

    
301
        if(s->ac_pred){
302
            for(i=0; i<6; i++){
303
                UINT8 *st;
304
                int last_index;
305

    
306
                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
307
                if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
308
                else           st = ff_alternate_horizontal_scan; /* top */
309

    
310
                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
311
                    if(block[i][st[last_index]]) break;
312
                zigzag_last_index[i]= s->block_last_index[i];
313
                s->block_last_index[i]= last_index;
314
                scan_table[i]= st;
315
            }
316
        }else{
317
            for(i=0; i<6; i++)
318
                scan_table[i]= zigzag_direct;
319
        }
320

    
321
        /* compute cbp */
322
        cbp = 0;
323
        for (i = 0; i < 6; i++) {
324
            if (s->block_last_index[i] >= 1)
325
                cbp |= 1 << (5 - i);
326
        }
327

    
328
        cbpc = cbp & 3;
329
        if (s->pict_type == I_TYPE) {
330
            put_bits(&s->pb,
331
                intra_MCBPC_bits[cbpc],
332
                intra_MCBPC_code[cbpc]);
333
        } else {
334
            put_bits(&s->pb, 1, 0);        /* mb coded */
335
            put_bits(&s->pb,
336
                inter_MCBPC_bits[cbpc + 4],
337
                inter_MCBPC_code[cbpc + 4]);
338
        }
339
        put_bits(&s->pb, 1, s->ac_pred);
340
        cbpy = cbp >> 2;
341
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
342

    
343
        /* encode each block */
344
        for (i = 0; i < 6; i++) {
345
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i]);
346
        }
347

    
348
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
349
        if(s->ac_pred){
350
            for(i=0; i<6; i++){
351
                int j;    
352
                INT16 *ac_val;
353

    
354
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
355

    
356
                if(dir[i]){
357
                    for(j=1; j<8; j++) 
358
                        block[i][block_permute_op(j   )]= ac_val[j+8];
359
                }else{
360
                    for(j=1; j<8; j++) 
361
                        block[i][block_permute_op(j<<3)]= ac_val[j  ];
362
                }
363
                s->block_last_index[i]= zigzag_last_index[i];
364
            }
365
        }
366
    }
367
}
368

    
369
void h263_encode_mb(MpegEncContext * s,
370
                    DCTELEM block[6][64],
371
                    int motion_x, int motion_y)
372
{
373
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
374
   
375
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
376
   if (!s->mb_intra) {
377
           /* compute cbp */
378
           cbp = 0;
379
           for (i = 0; i < 6; i++) {
380
              if (s->block_last_index[i] >= 0)
381
                   cbp |= 1 << (5 - i);
382
           }
383
           if ((cbp | motion_x | motion_y) == 0) {
384
              /* skip macroblock */
385
              put_bits(&s->pb, 1, 1);
386
              return;
387
           }
388
           put_bits(&s->pb, 1, 0);        /* mb coded */
389
           cbpc = cbp & 3;
390
           put_bits(&s->pb,
391
                inter_MCBPC_bits[cbpc],
392
                inter_MCBPC_code[cbpc]);
393
           cbpy = cbp >> 2;
394
           cbpy ^= 0xf;
395
           put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
396

    
397
           /* motion vectors: 16x16 mode only now */
398
      h263_pred_motion(s, 0, &pred_x, &pred_y);
399
      
400
      if (!s->umvplus) {  
401
         h263_encode_motion(s, motion_x - pred_x);
402
         h263_encode_motion(s, motion_y - pred_y);
403
      }
404
      else {
405
         h263p_encode_umotion(s, motion_x - pred_x);
406
         h263p_encode_umotion(s, motion_y - pred_y);
407
         if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
408
            /* To prevent Start Code emulation */
409
            put_bits(&s->pb,1,1);
410
      }
411
   } else {
412
        /* compute cbp */
413
        cbp = 0;
414
        for (i = 0; i < 6; i++) {
415
            if (s->block_last_index[i] >= 1)
416
                cbp |= 1 << (5 - i);
417
        }
418

    
419
        cbpc = cbp & 3;
420
        if (s->pict_type == I_TYPE) {
421
            put_bits(&s->pb,
422
                     intra_MCBPC_bits[cbpc],
423
                     intra_MCBPC_code[cbpc]);
424
        } else {
425
            put_bits(&s->pb, 1, 0);        /* mb coded */
426
            put_bits(&s->pb,
427
                     inter_MCBPC_bits[cbpc + 4],
428
                     inter_MCBPC_code[cbpc + 4]);
429
        }
430
        if (s->h263_pred) {
431
            /* XXX: currently, we do not try to use ac prediction */
432
            put_bits(&s->pb, 1, 0);        /* no ac prediction */
433
        }
434
        cbpy = cbp >> 2;
435
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
436
    }
437

    
438
    /* encode each block */
439
    if (s->h263_pred) {
440
        for (i = 0; i < 6; i++) {
441
//            mpeg4_encode_block(s, block[i], i);
442
        }
443
    } else {
444
        for (i = 0; i < 6; i++) {
445
            h263_encode_block(s, block[i], i);
446
        }
447
    }
448
}
449

    
450
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
451
{
452
    int x, y, wrap, a, c, pred_dc, scale, i;
453
    INT16 *dc_val, *ac_val, *ac_val1;
454

    
455
    /* find prediction */
456
    if (n < 4) {
457
        x = 2 * s->mb_x + 1 + (n & 1);
458
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
459
        wrap = s->mb_width * 2 + 2;
460
        dc_val = s->dc_val[0];
461
        ac_val = s->ac_val[0][0];
462
        scale = s->y_dc_scale;
463
    } else {
464
        x = s->mb_x + 1;
465
        y = s->mb_y + 1;
466
        wrap = s->mb_width + 2;
467
        dc_val = s->dc_val[n - 4 + 1];
468
        ac_val = s->ac_val[n - 4 + 1][0];
469
        scale = s->c_dc_scale;
470
    }
471
    
472
    ac_val += ((y) * wrap + (x)) * 16;
473
    ac_val1 = ac_val;
474
    
475
    /* B C
476
     * A X 
477
     */
478
    a = dc_val[(x - 1) + (y) * wrap];
479
    c = dc_val[(x) + (y - 1) * wrap];
480
    
481
    pred_dc = 1024;
482
    if (s->ac_pred) {
483
        if (s->h263_aic_dir) {
484
            /* left prediction */
485
            if (a != 1024) {
486
                ac_val -= 16;
487
                for(i=1;i<8;i++) {
488
                    block[block_permute_op(i*8)] += ac_val[i];
489
                }
490
                pred_dc = a;
491
            }
492
        } else {
493
            /* top prediction */
494
            if (c != 1024) {
495
                ac_val -= 16 * wrap;
496
                for(i=1;i<8;i++) {
497
                    block[block_permute_op(i)] += ac_val[i + 8];
498
                }
499
                pred_dc = c;
500
            }
501
        }
502
    } else {
503
        /* just DC prediction */
504
        if (a != 1024 && c != 1024)
505
            pred_dc = (a + c) >> 1;
506
        else if (a != 1024)
507
            pred_dc = a;
508
        else
509
            pred_dc = c;
510
    }
511
    
512
    /* we assume pred is positive */
513
    block[0]=block[0]*scale + pred_dc;
514
    
515
    if (block[0] < 0)
516
        block[0] = 0;
517
    else if (!(block[0] & 1))
518
        block[0]++;
519
    
520
    /* Update AC/DC tables */
521
    dc_val[(x) + (y) * wrap] = block[0];
522
    
523
    /* left copy */
524
    for(i=1;i<8;i++)
525
        ac_val1[i] = block[block_permute_op(i * 8)];
526
    /* top copy */
527
    for(i=1;i<8;i++)
528
        ac_val1[8 + i] = block[block_permute_op(i)];
529
}
530

    
531
INT16 *h263_pred_motion(MpegEncContext * s, int block, 
532
                        int *px, int *py)
533
{
534
    int xy, wrap;
535
    INT16 *A, *B, *C, *mot_val;
536
    static const int off[4]= {2, 1, 1, -1};
537

    
538
    wrap = s->block_wrap[0];
539
    xy = s->block_index[block];
540

    
541
    mot_val = s->motion_val[xy];
542

    
543
    /* special case for first line */
544
    if ((s->mb_y == 0 || s->first_slice_line || s->first_gob_line) && block<2) {
545
        A = s->motion_val[xy - 1];
546
        *px = A[0];
547
        *py = A[1];
548
    } else {
549
        A = s->motion_val[xy - 1];
550
        B = s->motion_val[xy - wrap];
551
        C = s->motion_val[xy + off[block] - wrap];
552
        *px = mid_pred(A[0], B[0], C[0]);
553
        *py = mid_pred(A[1], B[1], C[1]);
554
    }
555
    return mot_val;
556
}
557

    
558
static void h263_encode_motion(MpegEncContext * s, int val)
559
{
560
    int range, l, m, bit_size, sign, code, bits;
561

    
562
    if (val == 0) {
563
        /* zero vector */
564
        code = 0;
565
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
566
    } else {
567
        bit_size = s->f_code - 1;
568
        range = 1 << bit_size;
569
        /* modulo encoding */
570
        l = range * 32;
571
        m = 2 * l;
572
        if (val < -l) {
573
            val += m;
574
        } else if (val >= l) {
575
            val -= m;
576
        }
577

    
578
        if (val >= 0) {
579
            val--;
580
            code = (val >> bit_size) + 1;
581
            bits = val & (range - 1);
582
            sign = 0;
583
        } else {
584
            val = -val;
585
            val--;
586
            code = (val >> bit_size) + 1;
587
            bits = val & (range - 1);
588
            sign = 1;
589
        }
590

    
591
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
592
        if (bit_size > 0) {
593
            put_bits(&s->pb, bit_size, bits);
594
        }
595
    }
596
}
597

    
598
/* Encode MV differences on H.263+ with Unrestricted MV mode */
599
static void h263p_encode_umotion(MpegEncContext * s, int val)
600
{
601
    short sval = 0; 
602
    short i = 0;
603
    short n_bits = 0;
604
    short temp_val;
605
    int code = 0;
606
    int tcode;
607
    
608
    if ( val == 0)
609
        put_bits(&s->pb, 1, 1);
610
    else if (val == 1)
611
        put_bits(&s->pb, 3, 0);
612
    else if (val == -1)
613
        put_bits(&s->pb, 3, 2);
614
    else {
615
        
616
        sval = ((val < 0) ? (short)(-val):(short)val);
617
        temp_val = sval;
618
        
619
        while (temp_val != 0) {
620
            temp_val = temp_val >> 1;
621
            n_bits++;
622
        }
623
        
624
        i = n_bits - 1;
625
        while (i > 0) {
626
            tcode = (sval & (1 << (i-1))) >> (i-1);
627
            tcode = (tcode << 1) | 1;
628
            code = (code << 2) | tcode;
629
            i--;
630
        }
631
        code = ((code << 1) | (val < 0)) << 1;
632
        put_bits(&s->pb, (2*n_bits)+1, code);
633
        //printf("\nVal = %d\tCode = %d", sval, code);
634
    }
635
}
636

    
637
static void init_mv_penalty_and_fcode(MpegEncContext *s)
638
{
639
    int f_code;
640
    int mv;
641
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
642
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
643
            int len;
644

    
645
            if(mv==0) len= mvtab[0][1];
646
            else{
647
                int val, bit_size, range, code;
648

    
649
                bit_size = s->f_code - 1;
650
                range = 1 << bit_size;
651

    
652
                val=mv;
653
                if (val < 0) 
654
                    val = -val;
655
                val--;
656
                code = (val >> bit_size) + 1;
657
                if(code<33){
658
                    len= mvtab[code][1] + 1 + bit_size;
659
                }else{
660
                    len= mvtab[32][1] + 2 + bit_size;
661
                }
662
            }
663

    
664
            mv_penalty[f_code][mv+MAX_MV]= len;
665
        }
666
    }
667
    
668

    
669
    for(f_code=MAX_FCODE; f_code>0; f_code--){
670
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
671
            fcode_tab[mv+MAX_MV]= f_code;
672
        }
673
    }
674
}
675

    
676
void h263_encode_init(MpegEncContext *s)
677
{
678
    static int done = 0;
679

    
680
    if (!done) {
681
        done = 1;
682
        init_rl(&rl_inter);
683
        init_rl(&rl_intra);
684

    
685
        init_mv_penalty_and_fcode(s);
686
    }
687
    s->mv_penalty= mv_penalty;
688
    
689
    // use fcodes >1 only for mpeg4 FIXME
690
    if(!s->h263_msmpeg4 && s->h263_pred) s->fcode_tab= fcode_tab;
691
}
692

    
693
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
694
{
695
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
696
    int code;
697
    RLTable *rl = &rl_inter;
698

    
699
    if (s->mb_intra) {
700
        /* DC coef */
701
            level = block[0];
702
        /* 255 cannot be represented, so we clamp */
703
        if (level > 254) {
704
            level = 254;
705
            block[0] = 254;
706
        }
707
        /* 0 cannot be represented also */
708
        else if (!level) {
709
            level = 1;
710
            block[0] = 1;
711
        }
712
            if (level == 128)
713
                put_bits(&s->pb, 8, 0xff);
714
            else
715
                put_bits(&s->pb, 8, level & 0xff);
716
            i = 1;
717
    } else {
718
            i = 0;
719
    }
720

    
721
    /* AC coefs */
722
    last_index = s->block_last_index[n];
723
    last_non_zero = i - 1;
724
    for (; i <= last_index; i++) {
725
        j = zigzag_direct[i];
726
        level = block[j];
727
        if (level) {
728
            run = i - last_non_zero - 1;
729
            last = (i == last_index);
730
            sign = 0;
731
            slevel = level;
732
            if (level < 0) {
733
                sign = 1;
734
                level = -level;
735
            }
736
            code = get_rl_index(rl, last, run, level);
737
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
738
            if (code == rl->n) {
739
                put_bits(&s->pb, 1, last);
740
                put_bits(&s->pb, 6, run);
741
                put_bits(&s->pb, 8, slevel & 0xff);
742
            } else {
743
                put_bits(&s->pb, 1, sign);
744
            }
745
            last_non_zero = i;
746
        }
747
    }
748
}
749

    
750
/***************************************************/
751

    
752
static void mpeg4_stuffing(PutBitContext * pbc)
753
{
754
    int length;
755
    put_bits(pbc, 1, 0);
756
    length= (-get_bit_count(pbc))&7;
757
    put_bits(pbc, length, (1<<length)-1);
758
}
759

    
760
static void put_string(PutBitContext * pbc, char *s)
761
{
762
    while(*s){
763
        put_bits(pbc, 8, *s);
764
        s++;
765
    }
766
    put_bits(pbc, 8, 0);
767
}
768

    
769
static void mpeg4_encode_vol_header(MpegEncContext * s)
770
{
771
    int vo_ver_id=1; //must be 2 if we want GMC or q-pel
772

    
773
    if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
774
    put_bits(&s->pb, 16, 0);
775
    put_bits(&s->pb, 16, 0x100);        /* video obj */
776
    put_bits(&s->pb, 16, 0);
777
    put_bits(&s->pb, 16, 0x120);        /* video obj layer */
778

    
779
    put_bits(&s->pb, 1, 0);                /* random access vol */
780
    put_bits(&s->pb, 8, 1);                /* video obj type indication= simple obj */
781
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
782
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
783
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
784
    if(s->aspect_ratio_info) 
785
        put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
786
    else
787
        put_bits(&s->pb, 4, 1);                /* aspect ratio info= sqare pixel */
788
    put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
789
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
790
    put_bits(&s->pb, 1, 1);                /* marker bit */
791
    put_bits(&s->pb, 16, s->time_increment_resolution=30000);
792
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
793
    if (s->time_increment_bits < 1)
794
        s->time_increment_bits = 1;
795
    put_bits(&s->pb, 1, 1);                /* marker bit */
796
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
797
    put_bits(&s->pb, 1, 1);                /* marker bit */
798
    put_bits(&s->pb, 13, s->width);        /* vol width */
799
    put_bits(&s->pb, 1, 1);                /* marker bit */
800
    put_bits(&s->pb, 13, s->height);        /* vol height */
801
    put_bits(&s->pb, 1, 1);                /* marker bit */
802
    put_bits(&s->pb, 1, 0);                /* interlace */
803
    put_bits(&s->pb, 1, 1);                /* obmc disable */
804
    if (vo_ver_id == 1) {
805
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
806
    }else{ /* vo_ver_id == 2 */
807
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
808
    }
809
    put_bits(&s->pb, 1, 0);                /* not 8 bit */
810
    put_bits(&s->pb, 1, 0);                /* quant type= h263 style*/
811
    if (vo_ver_id != 1)
812
        put_bits(&s->pb, 1, s->quarter_sample=0);
813
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
814
    put_bits(&s->pb, 1, 1);                /* resync marker disable */
815
    put_bits(&s->pb, 1, 0);                /* data partitioned */
816
    if (vo_ver_id != 1){
817
        put_bits(&s->pb, 1, 0);                /* newpred */
818
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
819
    }
820
    put_bits(&s->pb, 1, 0);                /* scalability */
821

    
822
    mpeg4_stuffing(&s->pb);
823
    put_bits(&s->pb, 16, 0);
824
    put_bits(&s->pb, 16, 0x1B2);        /* user_data */
825
    put_string(&s->pb, "ffmpeg"); //FIXME append some version ...
826

    
827
    s->no_rounding = 0;
828
}
829

    
830
/* write mpeg4 VOP header */
831
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
832
{
833
    if(s->pict_type==I_TYPE) mpeg4_encode_vol_header(s);
834

    
835
    if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
836
    put_bits(&s->pb, 16, 0);                /* vop header */
837
    put_bits(&s->pb, 16, 0x1B6);        /* vop header */
838
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
839
    /* XXX: time base + 1 not always correct */
840
    put_bits(&s->pb, 1, 1);
841
    put_bits(&s->pb, 1, 0);
842

    
843
    put_bits(&s->pb, 1, 1);        /* marker */
844
    put_bits(&s->pb, s->time_increment_bits, 1);        /* XXX: correct time increment */
845
    put_bits(&s->pb, 1, 1);        /* marker */
846
    put_bits(&s->pb, 1, 1);        /* vop coded */
847
    if (    s->pict_type == P_TYPE 
848
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
849
        s->no_rounding ^= 1;
850
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
851
    }
852
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
853
    //FIXME sprite stuff
854

    
855
    put_bits(&s->pb, 5, s->qscale);
856

    
857
    if (s->pict_type != I_TYPE)
858
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
859
    if (s->pict_type == B_TYPE)
860
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
861
    //    printf("****frame %d\n", picture_number);
862
}
863

    
864
void h263_dc_scale(MpegEncContext * s)
865
{
866
#if 1
867
    const static UINT8 y_tab[32]={
868
    //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
869
        0, 8, 8, 8, 8,10,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,36,38,40,42,44,46
870
    };
871
    const static UINT8 c_tab[32]={
872
    //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
873
        0, 8, 8, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,20,21,22,23,24,25
874
    };
875
    s->y_dc_scale = y_tab[s->qscale];
876
    s->c_dc_scale = c_tab[s->qscale];
877
#else
878
    int quant;
879
    quant = s->qscale;
880
    /* luminance */
881
    if (quant < 5)
882
        s->y_dc_scale = 8;
883
    else if (quant > 4 && quant < 9)
884
        s->y_dc_scale = (2 * quant);
885
    else if (quant > 8 && quant < 25)
886
        s->y_dc_scale = (quant + 8);
887
    else
888
        s->y_dc_scale = (2 * quant - 16);
889
    /* chrominance */
890
    if (quant < 5)
891
        s->c_dc_scale = 8;
892
    else if (quant > 4 && quant < 25)
893
        s->c_dc_scale = ((quant + 13) / 2);
894
    else
895
        s->c_dc_scale = (quant - 6);
896
#endif
897
}
898

    
899
static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
900
{
901
    int a, b, c, wrap, pred, scale;
902
    UINT16 *dc_val;
903
    int dummy;
904

    
905
    /* find prediction */
906
    if (n < 4) {
907
        scale = s->y_dc_scale;
908
    } else {
909
        scale = s->c_dc_scale;
910
    }
911
    wrap= s->block_wrap[n];
912
    dc_val = s->dc_val[0] + s->block_index[n];
913

    
914
    /* B C
915
     * A X 
916
     */
917
    a = dc_val[ - 1];
918
    b = dc_val[ - 1 - wrap];
919
    c = dc_val[ - wrap];
920

    
921
    if (abs(a - b) < abs(b - c)) {
922
        pred = c;
923
        *dir_ptr = 1; /* top */
924
    } else {
925
        pred = a;
926
        *dir_ptr = 0; /* left */
927
    }
928
    /* we assume pred is positive */
929
#ifdef ARCH_X86
930
        asm volatile (
931
                "xorl %%edx, %%edx        \n\t"
932
                "mul %%ecx                \n\t"
933
                : "=d" (pred), "=a"(dummy)
934
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
935
        );
936
#else
937
    pred = (pred + (scale >> 1)) / scale;
938
#endif
939

    
940
    /* prepare address for prediction update */
941
    *dc_val_ptr = &dc_val[0];
942

    
943
    return pred;
944
}
945

    
946
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
947
                   int dir)
948
{
949
    int i;
950
    INT16 *ac_val, *ac_val1;
951

    
952
    /* find prediction */
953
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
954
    ac_val1 = ac_val;
955
    if (s->ac_pred) {
956
        if (dir == 0) {
957
            /* left prediction */
958
            ac_val -= 16;
959
            for(i=1;i<8;i++) {
960
                block[block_permute_op(i*8)] += ac_val[i];
961
            }
962
        } else {
963
            /* top prediction */
964
            ac_val -= 16 * s->block_wrap[n];
965
            for(i=1;i<8;i++) {
966
                block[block_permute_op(i)] += ac_val[i + 8];
967
            }
968
        }
969
    }
970
    /* left copy */
971
    for(i=1;i<8;i++)
972
        ac_val1[i] = block[block_permute_op(i * 8)];
973
    /* top copy */
974
    for(i=1;i<8;i++)
975
        ac_val1[8 + i] = block[block_permute_op(i)];
976
}
977

    
978
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
979
                              int dir)
980
{
981
    int i;
982
    INT16 *ac_val;
983

    
984
    /* find prediction */
985
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
986
 
987
    if (dir == 0) {
988
        /* left prediction */
989
        ac_val -= 16;
990
        for(i=1;i<8;i++) {
991
            block[block_permute_op(i*8)] -= ac_val[i];
992
        }
993
    } else {
994
        /* top prediction */
995
        ac_val -= 16 * s->block_wrap[n];
996
        for(i=1;i<8;i++) {
997
            block[block_permute_op(i)] -= ac_val[i + 8];
998
        }
999
    }
1000
}
1001

    
1002

    
1003
static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)
1004
{
1005
    int size, v;
1006
    /* find number of bits */
1007
    size = 0;
1008
    v = abs(level);
1009
    while (v) {
1010
        v >>= 1;
1011
        size++;
1012
    }
1013

    
1014
    if (n < 4) {
1015
        /* luminance */
1016
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1017
    } else {
1018
        /* chrominance */
1019
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1020
    }
1021

    
1022
    /* encode remaining bits */
1023
    if (size > 0) {
1024
        if (level < 0)
1025
            level = (-level) ^ ((1 << size) - 1);
1026
        put_bits(&s->pb, size, level);
1027
        if (size > 8)
1028
            put_bits(&s->pb, 1, 1);
1029
    }
1030
}
1031

    
1032
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table)
1033
{
1034
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
1035
    int code;
1036
    const RLTable *rl;
1037

    
1038
    if (s->mb_intra) {
1039
        /* mpeg4 based DC predictor */
1040
        mpeg4_encode_dc(s, intra_dc, n);
1041
        i = 1;
1042
        rl = &rl_intra;
1043
    } else {
1044
        i = 0;
1045
        rl = &rl_inter;
1046
    }
1047

    
1048
    /* AC coefs */
1049
    last_index = s->block_last_index[n];
1050
    last_non_zero = i - 1;
1051
    for (; i <= last_index; i++) {
1052
        j = scan_table[i];
1053
        level = block[j];
1054
        if (level) {
1055
            run = i - last_non_zero - 1;
1056
            last = (i == last_index);
1057
            sign = 0;
1058
            slevel = level;
1059
            if (level < 0) {
1060
                sign = 1;
1061
                level = -level;
1062
            }
1063
            code = get_rl_index(rl, last, run, level);
1064
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1065
            if (code == rl->n) {
1066
                int level1, run1;
1067
                level1 = level - rl->max_level[last][run];
1068
                if (level1 < 1) 
1069
                    goto esc2;
1070
                code = get_rl_index(rl, last, run, level1);
1071
                if (code == rl->n) {
1072
                esc2:
1073
                    put_bits(&s->pb, 1, 1);
1074
                    if (level > MAX_LEVEL)
1075
                        goto esc3;
1076
                    run1 = run - rl->max_run[last][level] - 1;
1077
                    if (run1 < 0)
1078
                        goto esc3;
1079
                    code = get_rl_index(rl, last, run1, level);
1080
                    if (code == rl->n) {
1081
                    esc3:
1082
                        /* third escape */
1083
                        put_bits(&s->pb, 1, 1);
1084
                        put_bits(&s->pb, 1, last);
1085
                        put_bits(&s->pb, 6, run);
1086
                        put_bits(&s->pb, 1, 1);
1087
                        put_bits(&s->pb, 12, slevel & 0xfff);
1088
                        put_bits(&s->pb, 1, 1);
1089
                    } else {
1090
                        /* second escape */
1091
                        put_bits(&s->pb, 1, 0);
1092
                        put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1093
                        put_bits(&s->pb, 1, sign);
1094
                    }
1095
                } else {
1096
                    /* first escape */
1097
                    put_bits(&s->pb, 1, 0);
1098
                    put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1099
                    put_bits(&s->pb, 1, sign);
1100
                }
1101
            } else {
1102
                put_bits(&s->pb, 1, sign);
1103
            }
1104
            last_non_zero = i;
1105
        }
1106
    }
1107
}
1108

    
1109

    
1110

    
1111
/***********************************************/
1112
/* decoding */
1113

    
1114
static VLC intra_MCBPC_vlc;
1115
static VLC inter_MCBPC_vlc;
1116
static VLC cbpy_vlc;
1117
static VLC mv_vlc;
1118
static VLC dc_lum, dc_chrom;
1119
static VLC sprite_trajectory;
1120
static VLC mb_type_b_vlc;
1121

    
1122
void init_rl(RLTable *rl)
1123
{
1124
    INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1125
    UINT8 index_run[MAX_RUN+1];
1126
    int last, run, level, start, end, i;
1127

    
1128
    /* compute max_level[], max_run[] and index_run[] */
1129
    for(last=0;last<2;last++) {
1130
        if (last == 0) {
1131
            start = 0;
1132
            end = rl->last;
1133
        } else {
1134
            start = rl->last;
1135
            end = rl->n;
1136
        }
1137

    
1138
        memset(max_level, 0, MAX_RUN + 1);
1139
        memset(max_run, 0, MAX_LEVEL + 1);
1140
        memset(index_run, rl->n, MAX_RUN + 1);
1141
        for(i=start;i<end;i++) {
1142
            run = rl->table_run[i];
1143
            level = rl->table_level[i];
1144
            if (index_run[run] == rl->n)
1145
                index_run[run] = i;
1146
            if (level > max_level[run])
1147
                max_level[run] = level;
1148
            if (run > max_run[level])
1149
                max_run[level] = run;
1150
        }
1151
        rl->max_level[last] = malloc(MAX_RUN + 1);
1152
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1153
        rl->max_run[last] = malloc(MAX_LEVEL + 1);
1154
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1155
        rl->index_run[last] = malloc(MAX_RUN + 1);
1156
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1157
    }
1158
}
1159

    
1160
void init_vlc_rl(RLTable *rl)
1161
{
1162
    init_vlc(&rl->vlc, 9, rl->n + 1, 
1163
             &rl->table_vlc[0][1], 4, 2,
1164
             &rl->table_vlc[0][0], 4, 2);
1165
}
1166

    
1167
/* init vlcs */
1168

    
1169
/* XXX: find a better solution to handle static init */
1170
void h263_decode_init_vlc(MpegEncContext *s)
1171
{
1172
    static int done = 0;
1173

    
1174
    if (!done) {
1175
        done = 1;
1176

    
1177
        init_vlc(&intra_MCBPC_vlc, 6, 8, 
1178
                 intra_MCBPC_bits, 1, 1,
1179
                 intra_MCBPC_code, 1, 1);
1180
        init_vlc(&inter_MCBPC_vlc, 9, 25, 
1181
                 inter_MCBPC_bits, 1, 1,
1182
                 inter_MCBPC_code, 1, 1);
1183
        init_vlc(&cbpy_vlc, 6, 16,
1184
                 &cbpy_tab[0][1], 2, 1,
1185
                 &cbpy_tab[0][0], 2, 1);
1186
        init_vlc(&mv_vlc, 9, 33,
1187
                 &mvtab[0][1], 2, 1,
1188
                 &mvtab[0][0], 2, 1);
1189
        init_rl(&rl_inter);
1190
        init_rl(&rl_intra);
1191
        init_rl(&rl_intra_aic);
1192
        init_vlc_rl(&rl_inter);
1193
        init_vlc_rl(&rl_intra);
1194
        init_vlc_rl(&rl_intra_aic);
1195
        init_vlc(&dc_lum, 9, 13,
1196
                 &DCtab_lum[0][1], 2, 1,
1197
                 &DCtab_lum[0][0], 2, 1);
1198
        init_vlc(&dc_chrom, 9, 13,
1199
                 &DCtab_chrom[0][1], 2, 1,
1200
                 &DCtab_chrom[0][0], 2, 1);
1201
        init_vlc(&sprite_trajectory, 9, 15,
1202
                 &sprite_trajectory_tab[0][1], 4, 2,
1203
                 &sprite_trajectory_tab[0][0], 4, 2);
1204
        init_vlc(&mb_type_b_vlc, 4, 4,
1205
                 &mb_type_b_tab[0][1], 2, 1,
1206
                 &mb_type_b_tab[0][0], 2, 1);
1207
    }
1208
}
1209

    
1210
int h263_decode_gob_header(MpegEncContext *s)
1211
{
1212
    unsigned int val, gfid;
1213
    
1214
    /* Check for GOB Start Code */
1215
    val = show_bits(&s->gb, 16);
1216
    if (val == 0) {
1217
        /* We have a GBSC probably with GSTUFF */
1218
        skip_bits(&s->gb, 16); /* Drop the zeros */
1219
        while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1220
#ifdef DEBUG
1221
        fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1222
#endif
1223
        s->gob_number = get_bits(&s->gb, 5); /* GN */
1224
        gfid = get_bits(&s->gb, 2); /* GFID */
1225
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1226
#ifdef DEBUG
1227
        fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1228
#endif
1229
        return 1;
1230
    }
1231
    return 0;
1232
            
1233
}
1234

    
1235
int h263_decode_mb(MpegEncContext *s,
1236
                   DCTELEM block[6][64])
1237
{
1238
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1239
    INT16 *mot_val;
1240
    static INT8 quant_tab[4] = { -1, -2, 1, 2 };
1241

    
1242
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
1243
        if (get_bits1(&s->gb)) {
1244
            /* skip mb */
1245
            s->mb_intra = 0;
1246
            for(i=0;i<6;i++)
1247
                s->block_last_index[i] = -1;
1248
            s->mv_dir = MV_DIR_FORWARD;
1249
            s->mv_type = MV_TYPE_16X16;
1250
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
1251
                const int a= s->sprite_warping_accuracy;
1252
//                int l = (1 << (s->f_code - 1)) * 32;
1253

    
1254
                s->mcsel=1;
1255
                s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1256
                s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1257
/*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
1258
                else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
1259
                if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
1260
                else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
1261

    
1262
                s->mb_skiped = 0;
1263
            }else{
1264
                s->mcsel=0;
1265
                s->mv[0][0][0] = 0;
1266
                s->mv[0][0][1] = 0;
1267
                s->mb_skiped = 1;
1268
            }
1269
            return 0;
1270
        }
1271
        cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
1272
        //fprintf(stderr, "\tCBPC: %d", cbpc);
1273
        if (cbpc < 0)
1274
            return -1;
1275
        if (cbpc > 20)
1276
            cbpc+=3;
1277
        else if (cbpc == 20)
1278
            fprintf(stderr, "Stuffing !");
1279
        
1280
        dquant = cbpc & 8;
1281
        s->mb_intra = ((cbpc & 4) != 0);
1282
        if (s->mb_intra) goto intra;
1283
        
1284
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
1285
            s->mcsel= get_bits1(&s->gb);
1286
        else s->mcsel= 0;
1287
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
1288
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
1289
        if (dquant) {
1290
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
1291
            if (s->qscale < 1)
1292
                s->qscale = 1;
1293
            else if (s->qscale > 31)
1294
                s->qscale = 31;
1295
        }
1296
        s->mv_dir = MV_DIR_FORWARD;
1297
        if ((cbpc & 16) == 0) {
1298
            /* 16x16 motion prediction */
1299
            s->mv_type = MV_TYPE_16X16;
1300
            h263_pred_motion(s, 0, &pred_x, &pred_y);
1301
            if (s->umvplus_dec)
1302
               mx = h263p_decode_umotion(s, pred_x);
1303
            else if(!s->mcsel)
1304
               mx = h263_decode_motion(s, pred_x, s->f_code);
1305
            else {
1306
               const int a= s->sprite_warping_accuracy;
1307
//        int l = (1 << (s->f_code - 1)) * 32;
1308
               mx= RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1309
//        if (mx < -l) mx= -l;
1310
//        else if (mx >= l) mx= l-1;
1311
            }
1312
            if (mx >= 0xffff)
1313
                return -1;
1314
            
1315
            if (s->umvplus_dec)
1316
               my = h263p_decode_umotion(s, pred_y);
1317
            else if(!s->mcsel)
1318
               my = h263_decode_motion(s, pred_y, s->f_code);
1319
            else{
1320
               const int a= s->sprite_warping_accuracy;
1321
//       int l = (1 << (s->f_code - 1)) * 32;
1322
               my= RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1323
//       if (my < -l) my= -l;
1324
//       else if (my >= l) my= l-1;
1325
            }
1326
            if (my >= 0xffff)
1327
                return -1;
1328
            s->mv[0][0][0] = mx;
1329
            s->mv[0][0][1] = my;
1330
            /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
1331
            fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
1332
            fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
1333
            if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1334
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1335
                           
1336
        } else {
1337
            s->mv_type = MV_TYPE_8X8;
1338
            for(i=0;i<4;i++) {
1339
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1340
                if (s->umvplus_dec)
1341
                  mx = h263p_decode_umotion(s, pred_x);
1342
                else
1343
                  mx = h263_decode_motion(s, pred_x, s->f_code);
1344
                if (mx >= 0xffff)
1345
                    return -1;
1346
                
1347
                if (s->umvplus_dec)
1348
                  my = h263p_decode_umotion(s, pred_y);
1349
                else    
1350
                  my = h263_decode_motion(s, pred_y, s->f_code);
1351
                if (my >= 0xffff)
1352
                    return -1;
1353
                s->mv[0][i][0] = mx;
1354
                s->mv[0][i][1] = my;
1355
                if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1356
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1357
                mot_val[0] = mx;
1358
                mot_val[1] = my;
1359
            }
1360
        }
1361
    } else if(s->pict_type==B_TYPE) {
1362
        int modb1; // first bit of modb
1363
        int modb2; // second bit of modb
1364
        int mb_type;
1365
        int time_pp;
1366
        int time_pb;
1367
        int xy;
1368

    
1369
        s->mb_intra = 0; //B-frames never contain intra blocks
1370
        s->mcsel=0;      //     ...               true gmc blocks
1371

    
1372
        if(s->mb_x==0){
1373
            s->last_mv[0][0][0]= 
1374
            s->last_mv[0][0][1]= 
1375
            s->last_mv[1][0][0]= 
1376
            s->last_mv[1][0][1]= 0;
1377
        }
1378

    
1379
        /* if we skipped it in the future P Frame than skip it now too */
1380
        s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
1381

    
1382
        if(s->mb_skiped){
1383
                /* skip mb */
1384
            for(i=0;i<6;i++)
1385
                s->block_last_index[i] = -1;
1386

    
1387
            s->mv_dir = MV_DIR_FORWARD;
1388
            s->mv_type = MV_TYPE_16X16;
1389
            s->mv[0][0][0] = 0;
1390
            s->mv[0][0][1] = 0;
1391
            s->mv[1][0][0] = 0;
1392
            s->mv[1][0][1] = 0;
1393
            s->last_mv[0][0][0]=
1394
            s->last_mv[0][0][1]= 
1395
            s->last_mv[1][0][0]= 
1396
            s->last_mv[1][0][1]= 0;
1397
            s->mb_skiped = 1;
1398
            return 0;
1399
        }
1400

    
1401
        modb1= get_bits1(&s->gb);
1402
        if(modb1==0){
1403
            modb2= get_bits1(&s->gb);
1404
            mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
1405
            if(modb2==0) cbp= get_bits(&s->gb, 6);
1406
            else cbp=0;
1407
            if (mb_type && cbp) {
1408
                if(get_bits1(&s->gb)){
1409
                    s->qscale +=get_bits1(&s->gb)*4 - 2;
1410
                    if (s->qscale < 1)
1411
                        s->qscale = 1;
1412
                    else if (s->qscale > 31)
1413
                        s->qscale = 31;
1414
                }
1415
            }
1416
        }else{
1417
            mb_type=4; //like 0 but no vectors coded
1418
            cbp=0;
1419
        }
1420
        s->mv_type = MV_TYPE_16X16; // we'll switch to 8x8 only if the last P frame had 8x8 for this MB and mb_type=0 here
1421
        mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
1422
        switch(mb_type)
1423
        {
1424
        case 0: 
1425
            mx = h263_decode_motion(s, 0, 1);
1426
            my = h263_decode_motion(s, 0, 1);
1427
        case 4: 
1428
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1429
            xy= s->block_index[0];
1430
            time_pp= s->last_non_b_time[0] - s->last_non_b_time[1];
1431
            time_pb= s->time - s->last_non_b_time[1];
1432
//if(time_pp>3000 )printf("%d %d  ", time_pp, time_pb);
1433
            //FIXME 4MV
1434
            //FIXME avoid divides
1435
            s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
1436
            s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
1437
            s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
1438
                                : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
1439
            s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
1440
                                : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
1441
/*            s->mv[0][0][0] = 
1442
            s->mv[0][0][1] = 
1443
            s->mv[1][0][0] = 
1444
            s->mv[1][0][1] = 1000;*/
1445
            break;
1446
        case 1: 
1447
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
1448
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1449
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1450
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1451
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1452

    
1453
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1454
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1455
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1456
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1457
            break;
1458
        case 2: 
1459
            s->mv_dir = MV_DIR_BACKWARD;
1460
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1461
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1462
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1463
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1464
            break;
1465
        case 3:
1466
            s->mv_dir = MV_DIR_FORWARD;
1467
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1468
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1469
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1470
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1471
            break;
1472
        default: return -1;
1473
        }
1474
    } else { /* I-Frame */
1475
        cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
1476
        if (cbpc < 0)
1477
            return -1;
1478
        dquant = cbpc & 4;
1479
        s->mb_intra = 1;
1480
intra:
1481
        s->ac_pred = 0;
1482
        if (s->h263_pred || s->h263_aic) {
1483
            s->ac_pred = get_bits1(&s->gb);
1484
            if (s->ac_pred && s->h263_aic)
1485
                s->h263_aic_dir = get_bits1(&s->gb);
1486
        }
1487
        if (s->h263_aic) {
1488
            s->y_dc_scale = 2 * s->qscale;
1489
            s->c_dc_scale = 2 * s->qscale;
1490
        }
1491
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
1492
        cbp = (cbpc & 3) | (cbpy << 2);
1493
        if (dquant) {
1494
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
1495
            if (s->qscale < 1)
1496
                s->qscale = 1;
1497
            else if (s->qscale > 31)
1498
                s->qscale = 31;
1499
        }
1500
    }
1501

    
1502
    /* decode each block */
1503
    if (s->h263_pred) {
1504
        for (i = 0; i < 6; i++) {
1505
            if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1506
                return -1;
1507
        }
1508
    } else {
1509
        for (i = 0; i < 6; i++) {
1510
            if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1511
                return -1;
1512
        }
1513
    }
1514
    return 0;
1515
}
1516

    
1517
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
1518
{
1519
    int code, val, sign, shift, l, m;
1520

    
1521
    code = get_vlc(&s->gb, &mv_vlc);
1522
    if (code < 0)
1523
        return 0xffff;
1524

    
1525
    if (code == 0)
1526
        return pred;
1527
    sign = get_bits1(&s->gb);
1528
    shift = f_code - 1;
1529
    val = (code - 1) << shift;
1530
    if (shift > 0)
1531
        val |= get_bits(&s->gb, shift);
1532
    val++;
1533
    if (sign)
1534
        val = -val;
1535
    val += pred;
1536
    
1537
    /* modulo decoding */
1538
    if (!s->h263_long_vectors) {
1539
        l = (1 << (f_code - 1)) * 32;
1540
        m = 2 * l;
1541
        if (val < -l) {
1542
            val += m;
1543
        } else if (val >= l) {
1544
            val -= m;
1545
        }
1546
    } else {
1547
        /* horrible h263 long vector mode */
1548
        if (pred < -31 && val < -63)
1549
            val += 64;
1550
        if (pred > 32 && val > 63)
1551
            val -= 64;
1552
        
1553
    }
1554
    return val;
1555
}
1556

    
1557
/* Decodes RVLC of H.263+ UMV */
1558
static int h263p_decode_umotion(MpegEncContext * s, int pred)
1559
{
1560
   int code = 0, sign;
1561
   
1562
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
1563
      return pred;
1564
   
1565
   code = 2 + get_bits1(&s->gb);
1566
   
1567
   while (get_bits1(&s->gb))
1568
   {
1569
      code <<= 1;
1570
      code += get_bits1(&s->gb);
1571
   }
1572
   sign = code & 1;
1573
   code >>= 1;
1574
   
1575
   code = (sign) ? (pred - code) : (pred + code);
1576
#ifdef DEBUG
1577
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
1578
#endif
1579
   return code;   
1580

    
1581
}
1582

    
1583
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
1584
                             int n, int coded)
1585
{
1586
    int code, level, i, j, last, run;
1587
    RLTable *rl = &rl_inter;
1588
    const UINT8 *scan_table;
1589

    
1590
    scan_table = zigzag_direct;
1591
    if (s->h263_aic && s->mb_intra) {
1592
        rl = &rl_intra_aic;
1593
        i = 0;
1594
        if (s->ac_pred) {
1595
            if (s->h263_aic_dir) 
1596
                scan_table = ff_alternate_vertical_scan; /* left */
1597
            else
1598
                scan_table = ff_alternate_horizontal_scan; /* top */
1599
        }
1600
    } else if (s->mb_intra) {
1601
        /* DC coef */
1602
        if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
1603
            int component, diff;
1604
            component = (n <= 3 ? 0 : n - 4 + 1);
1605
            level = s->last_dc[component];
1606
            if (s->rv10_first_dc_coded[component]) {
1607
                diff = rv_decode_dc(s, n);
1608
                if (diff == 0xffff)
1609
                    return -1;
1610
                level += diff;
1611
                level = level & 0xff; /* handle wrap round */
1612
                s->last_dc[component] = level;
1613
            } else {
1614
                s->rv10_first_dc_coded[component] = 1;
1615
            }
1616
        } else {
1617
            level = get_bits(&s->gb, 8);
1618
            if (level == 255)
1619
                level = 128;
1620
        }
1621
        block[0] = level;
1622
        i = 1;
1623
    } else {
1624
        i = 0;
1625
    }
1626
    if (!coded) {
1627
        if (s->mb_intra && s->h263_aic)
1628
            goto not_coded;
1629
        s->block_last_index[n] = i - 1;
1630
        return 0;
1631
    }
1632

    
1633
    for(;;) {
1634
        code = get_vlc(&s->gb, &rl->vlc);
1635
        if (code < 0)
1636
            return -1;
1637
        if (code == rl->n) {
1638
            /* escape */
1639
            last = get_bits1(&s->gb);
1640
            run = get_bits(&s->gb, 6);
1641
            level = (INT8)get_bits(&s->gb, 8);
1642
            if (s->h263_rv10 && level == -128) {
1643
                /* XXX: should patch encoder too */
1644
                level = get_bits(&s->gb, 12);
1645
                level = (level << 20) >> 20;
1646
            }
1647
        } else {
1648
            run = rl->table_run[code];
1649
            level = rl->table_level[code];
1650
            last = code >= rl->last;
1651
            if (get_bits1(&s->gb))
1652
                level = -level;
1653
        }
1654
        i += run;
1655
        if (i >= 64)
1656
            return -1;
1657
        j = scan_table[i];
1658
        block[j] = level;
1659
        if (last)
1660
            break;
1661
        i++;
1662
    }
1663
not_coded:    
1664
    if (s->mb_intra && s->h263_aic) {
1665
        h263_pred_acdc(s, block, n);
1666
        i = 63;
1667
    }
1668
    s->block_last_index[n] = i;
1669
    return 0;
1670
}
1671

    
1672
static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1673
{
1674
    int level, pred, code;
1675
    UINT16 *dc_val;
1676

    
1677
    if (n < 4) 
1678
        code = get_vlc(&s->gb, &dc_lum);
1679
    else 
1680
        code = get_vlc(&s->gb, &dc_chrom);
1681
    if (code < 0)
1682
        return -1;
1683
    if (code == 0) {
1684
        level = 0;
1685
    } else {
1686
        level = get_bits(&s->gb, code);
1687
        if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
1688
            level = - (level ^ ((1 << code) - 1));
1689
        if (code > 8)
1690
            skip_bits1(&s->gb); /* marker */
1691
    }
1692

    
1693
    pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1694
    level += pred;
1695
    if (level < 0)
1696
        level = 0;
1697
    if (n < 4) {
1698
        *dc_val = level * s->y_dc_scale;
1699
    } else {
1700
        *dc_val = level * s->c_dc_scale;
1701
    }
1702
    return level;
1703
}
1704

    
1705
static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1706
                              int n, int coded)
1707
{
1708
    int code, level, i, j, last, run;
1709
    int dc_pred_dir;
1710
    RLTable *rl;
1711
    const UINT8 *scan_table;
1712

    
1713
    if (s->mb_intra) {
1714
        /* DC coef */
1715
        level = mpeg4_decode_dc(s, n, &dc_pred_dir);
1716
        if (level < 0)
1717
            return -1;
1718
        block[0] = level;
1719
        i = 1;
1720
        if (!coded) 
1721
            goto not_coded;
1722
        rl = &rl_intra;
1723
        if (s->ac_pred) {
1724
            if (dc_pred_dir == 0) 
1725
                scan_table = ff_alternate_vertical_scan; /* left */
1726
            else
1727
                scan_table = ff_alternate_horizontal_scan; /* top */
1728
        } else {
1729
            scan_table = zigzag_direct;
1730
        }
1731
    } else {
1732
        i = 0;
1733
        if (!coded) {
1734
            s->block_last_index[n] = i - 1;
1735
            return 0;
1736
        }
1737
        rl = &rl_inter;
1738
        scan_table = zigzag_direct;
1739
    }
1740

    
1741
    for(;;) {
1742
        code = get_vlc(&s->gb, &rl->vlc);
1743
        if (code < 0)
1744
            return -1;
1745
        if (code == rl->n) {
1746
            /* escape */
1747
            if (get_bits1(&s->gb) != 0) {
1748
                if (get_bits1(&s->gb) != 0) {
1749
                    /* third escape */
1750
                    last = get_bits1(&s->gb);
1751
                    run = get_bits(&s->gb, 6);
1752
                    get_bits1(&s->gb); /* marker */
1753
                    level = get_bits(&s->gb, 12);
1754
                    level = (level << 20) >> 20; /* sign extend */
1755
                    skip_bits1(&s->gb); /* marker */
1756
                } else {
1757
                    /* second escape */
1758
                    code = get_vlc(&s->gb, &rl->vlc);
1759
                    if (code < 0 || code >= rl->n)
1760
                        return -1;
1761
                    run = rl->table_run[code];
1762
                    level = rl->table_level[code];
1763
                    last = code >= rl->last;
1764
                    run += rl->max_run[last][level] + 1;
1765
                    if (get_bits1(&s->gb))
1766
                        level = -level;
1767
                }
1768
            } else {
1769
                /* first escape */
1770
                code = get_vlc(&s->gb, &rl->vlc);
1771
                if (code < 0 || code >= rl->n)
1772
                    return -1;
1773
                run = rl->table_run[code];
1774
                level = rl->table_level[code];
1775
                last = code >= rl->last;
1776
                level += rl->max_level[last][run];
1777
                if (get_bits1(&s->gb))
1778
                    level = -level;
1779
            }
1780
        } else {
1781
            run = rl->table_run[code];
1782
            level = rl->table_level[code];
1783
            last = code >= rl->last;
1784
            if (get_bits1(&s->gb))
1785
                level = -level;
1786
        }
1787
        i += run;
1788
        if (i >= 64)
1789
            return -1;
1790
        j = scan_table[i];
1791
        block[j] = level;
1792
        i++;
1793
        if (last)
1794
            break;
1795
    }
1796
 not_coded:
1797
    if (s->mb_intra) {
1798
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
1799
        if (s->ac_pred) {
1800
            i = 64; /* XXX: not optimal */
1801
        }
1802
    }
1803
    s->block_last_index[n] = i - 1;
1804
    return 0;
1805
}
1806

    
1807
/* most is hardcoded. should extend to handle all h263 streams */
1808
int h263_decode_picture_header(MpegEncContext *s)
1809
{
1810
    int format, width, height;
1811

    
1812
    /* picture header */
1813
    if (get_bits(&s->gb, 22) != 0x20)
1814
        return -1;
1815
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
1816
    
1817
    if (get_bits1(&s->gb) != 1)
1818
        return -1;        /* marker */
1819
    if (get_bits1(&s->gb) != 0)
1820
        return -1;        /* h263 id */
1821
    skip_bits1(&s->gb);        /* split screen off */
1822
    skip_bits1(&s->gb);        /* camera  off */
1823
    skip_bits1(&s->gb);        /* freeze picture release off */
1824

    
1825
    /* Reset GOB number */
1826
    s->gob_number = 0;
1827
        
1828
    format = get_bits(&s->gb, 3);
1829

    
1830
    if (format != 7 && format != 6) {
1831
        s->h263_plus = 0;
1832
        /* H.263v1 */
1833
        width = h263_format[format][0];
1834
        height = h263_format[format][1];
1835
        if (!width)
1836
            return -1;
1837
        
1838
        s->width = width;
1839
        s->height = height;
1840
        s->pict_type = I_TYPE + get_bits1(&s->gb);
1841

    
1842
        s->unrestricted_mv = get_bits1(&s->gb); 
1843
        s->h263_long_vectors = s->unrestricted_mv;
1844

    
1845
        if (get_bits1(&s->gb) != 0)
1846
            return -1;        /* SAC: off */
1847
        if (get_bits1(&s->gb) != 0) {
1848
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1849
        }   
1850
        
1851
        if (get_bits1(&s->gb) != 0)
1852
            return -1;        /* not PB frame */
1853

    
1854
        s->qscale = get_bits(&s->gb, 5);
1855
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
1856
    } else {
1857
        int ufep;
1858
        
1859
        /* H.263v2 */
1860
        s->h263_plus = 1;
1861
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
1862
        
1863
        if (ufep == 1) {
1864
            /* OPPTYPE */       
1865
            format = get_bits(&s->gb, 3);
1866
            skip_bits(&s->gb,1); /* Custom PCF */
1867
            s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
1868
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
1869
            if (get_bits1(&s->gb) != 0) {
1870
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1871
            }
1872
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
1873
                s->h263_aic = 1;
1874
            }
1875
            skip_bits(&s->gb, 7);
1876
            skip_bits(&s->gb, 3); /* Reserved */
1877
        } else if (ufep != 0)
1878
            return -1;
1879
            
1880
        /* MPPTYPE */
1881
        s->pict_type = get_bits(&s->gb, 3) + 1;
1882
        if (s->pict_type != I_TYPE &&
1883
            s->pict_type != P_TYPE)
1884
            return -1;
1885
        skip_bits(&s->gb, 2);
1886
        s->no_rounding = get_bits1(&s->gb);
1887
        //fprintf(stderr, "\nRTYPE: %d", s->no_rounding);
1888
        skip_bits(&s->gb, 4);
1889
        
1890
        /* Get the picture dimensions */
1891
        if (ufep) {
1892
            if (format == 6) {
1893
                /* Custom Picture Format (CPFMT) */
1894
                skip_bits(&s->gb, 4); /* aspect ratio */
1895
                width = (get_bits(&s->gb, 9) + 1) * 4;
1896
                skip_bits1(&s->gb);
1897
                height = get_bits(&s->gb, 9) * 4;
1898
#ifdef DEBUG 
1899
                fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);
1900
#endif            
1901
            }
1902
            else {
1903
                width = h263_format[format][0];
1904
                height = h263_format[format][1];
1905
            }
1906
            if ((width == 0) || (height == 0))
1907
                return -1;
1908
            s->width = width;
1909
            s->height = height;
1910
            if (s->umvplus_dec) {
1911
                skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1912
            }
1913
        }
1914
            
1915
        s->qscale = get_bits(&s->gb, 5);
1916
    }
1917
    /* PEI */
1918
    while (get_bits1(&s->gb) != 0) {
1919
        skip_bits(&s->gb, 8);
1920
    }
1921
    s->f_code = 1;
1922
    return 0;
1923
}
1924

    
1925
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
1926
{
1927
    int i;
1928
    int a= 2<<s->sprite_warping_accuracy;
1929
    int rho= 3-s->sprite_warping_accuracy;
1930
    int r=16/a;
1931
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
1932
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
1933
    int sprite_ref[4][2];
1934
    int virtual_ref[2][2];
1935
    int w2, h2;
1936
    int alpha=0, beta=0;
1937
    int w= s->width;
1938
    int h= s->height;
1939
//printf("SP %d\n", s->sprite_warping_accuracy);
1940
    for(i=0; i<s->num_sprite_warping_points; i++){
1941
        int length;
1942
        int x=0, y=0;
1943

    
1944
        length= get_vlc(&s->gb, &sprite_trajectory);
1945
        if(length){
1946
            x= get_bits(&s->gb, length);
1947
//printf("lx %d %d\n", length, x);
1948
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
1949
                x = - (x ^ ((1 << length) - 1));
1950
        }
1951
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
1952
        
1953
        length= get_vlc(&s->gb, &sprite_trajectory);
1954
        if(length){
1955
            y=get_bits(&s->gb, length);
1956
//printf("ly %d %d\n", length, y);
1957
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
1958
                y = - (y ^ ((1 << length) - 1));
1959
        }
1960
        skip_bits1(&s->gb); /* marker bit */
1961
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
1962
//if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
1963
//x=y=0;
1964
        d[i][0]= x;
1965
        d[i][1]= y;
1966
    }
1967

    
1968
    while((1<<alpha)<w) alpha++;
1969
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
1970
    w2= 1<<alpha;
1971
    h2= 1<<beta;
1972

    
1973
// Note, the 4th point isnt used for GMC
1974
    if(s->divx_version==500 && s->divx_build==413){
1975
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
1976
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
1977
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
1978
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
1979
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
1980
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
1981
    } else {
1982
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
1983
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
1984
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
1985
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
1986
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
1987
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
1988
    }
1989
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
1990
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
1991
    
1992
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
1993
// perhaps it should be reordered to be more readable ...
1994
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
1995
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
1996
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
1997
        + RDIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
1998
    virtual_ref[0][1]= 16*vop_ref[0][1] 
1999
        + RDIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
2000
    virtual_ref[1][0]= 16*vop_ref[0][0] 
2001
        + RDIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
2002
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
2003
        + RDIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
2004

    
2005
    switch(s->num_sprite_warping_points)
2006
    {
2007
        case 0:
2008
            s->sprite_offset[0][0]= 0;
2009
            s->sprite_offset[0][1]= 0;
2010
            s->sprite_offset[1][0]= 0;
2011
            s->sprite_offset[1][1]= 0;
2012
            s->sprite_delta[0][0][0]= a;
2013
            s->sprite_delta[0][0][1]= 0;
2014
            s->sprite_delta[0][1][0]= 0;
2015
            s->sprite_delta[0][1][1]= a;
2016
            s->sprite_delta[1][0][0]= a;
2017
            s->sprite_delta[1][0][1]= 0;
2018
            s->sprite_delta[1][1][0]= 0;
2019
            s->sprite_delta[1][1][1]= a;
2020
            s->sprite_shift[0][0]= 0;
2021
            s->sprite_shift[0][1]= 0;
2022
            s->sprite_shift[1][0]= 0;
2023
            s->sprite_shift[1][1]= 0;
2024
            break;
2025
        case 1: //GMC only
2026
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
2027
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
2028
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
2029
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
2030
            s->sprite_delta[0][0][0]= a;
2031
            s->sprite_delta[0][0][1]= 0;
2032
            s->sprite_delta[0][1][0]= 0;
2033
            s->sprite_delta[0][1][1]= a;
2034
            s->sprite_delta[1][0][0]= a;
2035
            s->sprite_delta[1][0][1]= 0;
2036
            s->sprite_delta[1][1][0]= 0;
2037
            s->sprite_delta[1][1][1]= a;
2038
            s->sprite_shift[0][0]= 0;
2039
            s->sprite_shift[0][1]= 0;
2040
            s->sprite_shift[1][0]= 0;
2041
            s->sprite_shift[1][1]= 0;
2042
            break;
2043
        case 2:
2044
        case 3: //FIXME
2045
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
2046
                                                  + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
2047
                                                    +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
2048
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
2049
                                                  + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
2050
                                                    +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
2051
            s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
2052
                                 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
2053
                                 +2*w2*r*sprite_ref[0][0] - 16*w2);
2054
            s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
2055
                                 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
2056
                                 +2*w2*r*sprite_ref[0][1] - 16*w2);
2057
            s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2058
            s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);
2059
            s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
2060
            s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2061
            s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2062
            s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
2063
            s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
2064
            s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2065
            s->sprite_shift[0][0]= alpha+rho;
2066
            s->sprite_shift[0][1]= alpha+rho;
2067
            s->sprite_shift[1][0]= alpha+rho+2;
2068
            s->sprite_shift[1][1]= alpha+rho+2;
2069
            break;
2070
//        case 3:
2071
            break;
2072
    }
2073
/*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
2074
printf("%d %d\n", s->sprite_delta[0][0][1], 0);
2075
printf("%d %d\n", s->sprite_delta[0][1][0], 0);
2076
printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
2077
printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
2078
printf("%d %d\n", s->sprite_delta[1][0][1], 0);
2079
printf("%d %d\n", s->sprite_delta[1][1][0], 0);
2080
printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
2081
    /* try to simplify the situation */ 
2082
    if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
2083
       && s->sprite_delta[0][0][1] == 0
2084
       && s->sprite_delta[0][1][0] == 0
2085
       && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
2086
       && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
2087
       && s->sprite_delta[1][0][1] == 0
2088
       && s->sprite_delta[1][1][0] == 0
2089
       && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
2090
    {
2091
        s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
2092
        s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
2093
        s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
2094
        s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
2095
        s->sprite_delta[0][0][0]= a;
2096
        s->sprite_delta[0][0][1]= 0;
2097
        s->sprite_delta[0][1][0]= 0;
2098
        s->sprite_delta[0][1][1]= a;
2099
        s->sprite_delta[1][0][0]= a;
2100
        s->sprite_delta[1][0][1]= 0;
2101
        s->sprite_delta[1][1][0]= 0;
2102
        s->sprite_delta[1][1][1]= a;
2103
        s->sprite_shift[0][0]= 0;
2104
        s->sprite_shift[0][1]= 0;
2105
        s->sprite_shift[1][0]= 0;
2106
        s->sprite_shift[1][1]= 0;
2107
        s->real_sprite_warping_points=1;
2108
    }
2109
    else
2110
        s->real_sprite_warping_points= s->num_sprite_warping_points;
2111

    
2112
}
2113

    
2114
/* decode mpeg4 VOP header */
2115
int mpeg4_decode_picture_header(MpegEncContext * s)
2116
{
2117
    int time_incr, startcode, state, v;
2118

    
2119
 redo:
2120
    /* search next start code */
2121
    align_get_bits(&s->gb);
2122
    state = 0xff;
2123
    for(;;) {
2124
        v = get_bits(&s->gb, 8);
2125
        if (state == 0x000001) {
2126
            state = ((state << 8) | v) & 0xffffff;
2127
            startcode = state;
2128
            break;
2129
        }
2130
        state = ((state << 8) | v) & 0xffffff;
2131
        if( get_bits_count(&s->gb) > s->gb.size*8-32){
2132
            printf("no VOP startcode found\n");
2133
            return -1;
2134
        }
2135
    }
2136
//printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
2137
    if (startcode == 0x120) { // Video Object Layer
2138
        int width, height, vo_ver_id;
2139

    
2140
        /* vol header */
2141
        skip_bits(&s->gb, 1); /* random access */
2142
        skip_bits(&s->gb, 8); /* vo_type */
2143
        if (get_bits1(&s->gb) != 0) { /* is_ol_id */
2144
            vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
2145
            skip_bits(&s->gb, 3); /* vo_priority */
2146
        } else {
2147
            vo_ver_id = 1;
2148
        }
2149
        
2150
        s->aspect_ratio_info= get_bits(&s->gb, 4);
2151
        if(s->aspect_ratio_info == EXTENDET_PAR){
2152
            skip_bits(&s->gb, 8); //par_width
2153
            skip_bits(&s->gb, 8); // par_height
2154
        }
2155

    
2156
        if(get_bits1(&s->gb)){ /* vol control parameter */
2157
            printf("vol control parameter not supported\n");
2158
            return -1;   
2159
        }
2160
        s->shape = get_bits(&s->gb, 2); /* vol shape */
2161
        if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
2162
        if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
2163
            printf("Gray shape not supported\n");
2164
            skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
2165
        }
2166

    
2167
        skip_bits1(&s->gb);   /* marker */
2168
        
2169
        s->time_increment_resolution = get_bits(&s->gb, 16);
2170
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
2171
        if (s->time_increment_bits < 1)
2172
            s->time_increment_bits = 1;
2173
        skip_bits1(&s->gb);   /* marker */
2174

    
2175
        if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
2176
            skip_bits(&s->gb, s->time_increment_bits);
2177
        }
2178

    
2179
        if (s->shape != BIN_ONLY_SHAPE) {
2180
            if (s->shape == RECT_SHAPE) {
2181
                skip_bits1(&s->gb);   /* marker */
2182
                width = get_bits(&s->gb, 13);
2183
                skip_bits1(&s->gb);   /* marker */
2184
                height = get_bits(&s->gb, 13);
2185
                skip_bits1(&s->gb);   /* marker */
2186
                if(width && height){ /* they should be non zero but who knows ... */
2187
                    s->width = width;
2188
                    s->height = height;
2189
//                    printf("%d %d\n", width, height);
2190
                }
2191
            }
2192
            
2193
            if(get_bits1(&s->gb)) printf("interlaced not supported\n");   /* interlaced */
2194
            if(!get_bits1(&s->gb)) printf("OBMC not supported\n");   /* OBMC Disable */
2195
            if (vo_ver_id == 1) {
2196
                s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
2197
            } else {
2198
                s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
2199
            }
2200
            if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
2201
            if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
2202
                if(s->vol_sprite_usage==STATIC_SPRITE){
2203
                    s->sprite_width = get_bits(&s->gb, 13);
2204
                    skip_bits1(&s->gb); /* marker */
2205
                    s->sprite_height= get_bits(&s->gb, 13);
2206
                    skip_bits1(&s->gb); /* marker */
2207
                    s->sprite_left  = get_bits(&s->gb, 13);
2208
                    skip_bits1(&s->gb); /* marker */
2209
                    s->sprite_top   = get_bits(&s->gb, 13);
2210
                    skip_bits1(&s->gb); /* marker */
2211
                }
2212
                s->num_sprite_warping_points= get_bits(&s->gb, 6);
2213
                s->sprite_warping_accuracy = get_bits(&s->gb, 2);
2214
                s->sprite_brightness_change= get_bits1(&s->gb);
2215
                if(s->vol_sprite_usage==STATIC_SPRITE)
2216
                    s->low_latency_sprite= get_bits1(&s->gb);            
2217
            }
2218
            // FIXME sadct disable bit if verid!=1 && shape not rect
2219
            
2220
            if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
2221
                s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
2222
                if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
2223
            } else {
2224
                s->quant_precision = 5;
2225
            }
2226
            
2227
            // FIXME a bunch of grayscale shape things
2228
            if(get_bits1(&s->gb)) printf("Quant-Type not supported\n");  /* vol_quant_type */ //FIXME
2229
            if(vo_ver_id != 1)
2230
                 s->quarter_sample= get_bits1(&s->gb);
2231
            else s->quarter_sample=0;
2232

    
2233
            if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
2234
#if 0
2235
            if(get_bits1(&s->gb)) printf("resync disable\n");
2236
#else
2237
            skip_bits1(&s->gb);   /* resync_marker_disabled */
2238
#endif
2239
            s->data_partioning= get_bits1(&s->gb);
2240
            if(s->data_partioning){
2241
                printf("data partitioning not supported\n");
2242
                skip_bits1(&s->gb); // reversible vlc
2243
            }
2244
            
2245
            if(vo_ver_id != 1) {
2246
                s->new_pred= get_bits1(&s->gb);
2247
                if(s->new_pred){
2248
                    printf("new pred not supported\n");
2249
                    skip_bits(&s->gb, 2); /* requested upstream message type */
2250
                    skip_bits1(&s->gb); /* newpred segment type */
2251
                }
2252
                s->reduced_res_vop= get_bits1(&s->gb);
2253
                if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
2254
            }
2255
            else{
2256
                s->new_pred=0;
2257
                s->reduced_res_vop= 0;
2258
            }
2259

    
2260
            s->scalability= get_bits1(&s->gb);
2261
            if (s->scalability) {
2262
                printf("bad scalability!!!\n");
2263
                return -1;
2264
            }
2265
        }
2266
//printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
2267
        goto redo;
2268
    } else if (startcode == 0x1b2) { //userdata
2269
        char buf[256];
2270
        int i;
2271
        int e;
2272
        int ver, build;
2273

    
2274
//printf("user Data %X\n", show_bits(&s->gb, 32));
2275
        buf[0]= show_bits(&s->gb, 8);
2276
        for(i=1; i<256; i++){
2277
            buf[i]= show_bits(&s->gb, 16)&0xFF;
2278
            if(buf[i]==0) break;
2279
            skip_bits(&s->gb, 8);
2280
        }
2281
        buf[255]=0;
2282
        e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
2283
        if(e==2){
2284
            s->divx_version= ver;
2285
            s->divx_build= build;
2286
            if(s->picture_number==0){
2287
                printf("This file was encoded with DivX%d Build%d\n", ver, build);
2288
                if(ver==500 && build==413){ //most likely all version are indeed totally buggy but i dunno for sure ...
2289
                    printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
2290
                }else{
2291
                    printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
2292
                           "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
2293
                }
2294
            }
2295
        }
2296
//printf("User Data: %s\n", buf);
2297
        goto redo;
2298
    } else if (startcode != 0x1b6) { //VOP
2299
        goto redo;
2300
    }
2301

    
2302
    s->pict_type = get_bits(&s->gb, 2) + 1;        /* pict type: I = 0 , P = 1 */
2303
//printf("pic: %d\n", s->pict_type); 
2304
    time_incr=0;
2305
    while (get_bits1(&s->gb) != 0) 
2306
        time_incr++;
2307

    
2308
    check_marker(&s->gb, "before time_increment");
2309
    s->time_increment= get_bits(&s->gb, s->time_increment_bits);
2310
    if(s->pict_type!=B_TYPE){
2311
        s->time_base+= time_incr;
2312
        s->last_non_b_time[1]= s->last_non_b_time[0];
2313
        s->last_non_b_time[0]= s->time_base*s->time_increment_resolution + s->time_increment;
2314
    }else{
2315
        s->time= (s->last_non_b_time[1]/s->time_increment_resolution + time_incr)*s->time_increment_resolution;
2316
        s->time+= s->time_increment;
2317
    }
2318

    
2319
    if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
2320
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
2321
        for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
2322
            if(get_bits1(&s->gb)) break;
2323
        }
2324
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
2325
    }
2326
    /* vop coded */
2327
    if (get_bits1(&s->gb) != 1)
2328
        goto redo;
2329
//printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
2330
//s->time, s->last_non_b_time[0], s->last_non_b_time[1]);  
2331
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
2332
                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
2333
        /* rounding type for motion estimation */
2334
        s->no_rounding = get_bits1(&s->gb);
2335
    } else {
2336
        s->no_rounding = 0;
2337
    }
2338
//FIXME reduced res stuff
2339

    
2340
     if (s->shape != RECT_SHAPE) {
2341
         if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
2342
             int width, height, hor_spat_ref, ver_spat_ref;
2343
 
2344
             width = get_bits(&s->gb, 13);
2345
             skip_bits1(&s->gb);   /* marker */
2346
             height = get_bits(&s->gb, 13);
2347
             skip_bits1(&s->gb);   /* marker */
2348
             hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
2349
             skip_bits1(&s->gb);   /* marker */
2350
             ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
2351
         }
2352
         skip_bits1(&s->gb); /* change_CR_disable */
2353
 
2354
         if (get_bits1(&s->gb) != 0) {
2355
             skip_bits(&s->gb, 8); /* constant_alpha_value */
2356
         }
2357
     }
2358
//FIXME complexity estimation stuff
2359
     
2360
     if (s->shape != BIN_ONLY_SHAPE) {
2361
         skip_bits(&s->gb, 3); /* intra dc VLC threshold */
2362
         //FIXME interlaced specific bits
2363
     }
2364

    
2365
     if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
2366
         if(s->num_sprite_warping_points){
2367
             mpeg4_decode_sprite_trajectory(s);
2368
         }
2369
         if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
2370
         if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
2371
     }
2372

    
2373
     if (s->shape != BIN_ONLY_SHAPE) {
2374
         /* note: we do not use quant_precision to avoid problem if no
2375
            MPEG4 vol header as it is found on some old opendivx
2376
            movies */
2377
         s->qscale = get_bits(&s->gb, 5);
2378
         if(s->qscale==0){
2379
             printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
2380
             return -1; // makes no sense to continue, as there is nothing left from the image then
2381
         }
2382
  
2383
         if (s->pict_type != I_TYPE) {
2384
             s->f_code = get_bits(&s->gb, 3);        /* fcode_for */
2385
             if(s->f_code==0){
2386
                 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
2387
                 return -1; // makes no sense to continue, as the MV decoding will break very quickly
2388
             }
2389
         }
2390
         if (s->pict_type == B_TYPE) {
2391
             s->b_code = get_bits(&s->gb, 3);
2392
//printf("b-code %d\n", s->b_code);
2393
         }
2394
//printf("quant:%d fcode:%d\n", s->qscale, s->f_code);
2395
         if(!s->scalability){
2396
             if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
2397
                 skip_bits1(&s->gb); // vop shape coding type
2398
             }
2399
         }
2400
     }
2401
     s->picture_number++; // better than pic number==0 allways ;)
2402
     return 0;
2403
}
2404

    
2405
/* don't understand why they choose a different header ! */
2406
int intel_h263_decode_picture_header(MpegEncContext *s)
2407
{
2408
    int format;
2409

    
2410
    /* picture header */
2411
    if (get_bits(&s->gb, 22) != 0x20)
2412
        return -1;
2413
    skip_bits(&s->gb, 8); /* picture timestamp */
2414

    
2415
    if (get_bits1(&s->gb) != 1)
2416
        return -1;        /* marker */
2417
    if (get_bits1(&s->gb) != 0)
2418
        return -1;        /* h263 id */
2419
    skip_bits1(&s->gb);        /* split screen off */
2420
    skip_bits1(&s->gb);        /* camera  off */
2421
    skip_bits1(&s->gb);        /* freeze picture release off */
2422

    
2423
    format = get_bits(&s->gb, 3);
2424
    if (format != 7)
2425
        return -1;
2426

    
2427
    s->h263_plus = 0;
2428

    
2429
    s->pict_type = I_TYPE + get_bits1(&s->gb);
2430
    
2431
    s->unrestricted_mv = get_bits1(&s->gb); 
2432
    s->h263_long_vectors = s->unrestricted_mv;
2433

    
2434
    if (get_bits1(&s->gb) != 0)
2435
        return -1;        /* SAC: off */
2436
    if (get_bits1(&s->gb) != 0)
2437
        return -1;        /* advanced prediction mode: off */
2438
    if (get_bits1(&s->gb) != 0)
2439
        return -1;        /* not PB frame */
2440

    
2441
    /* skip unknown header garbage */
2442
    skip_bits(&s->gb, 41);
2443

    
2444
    s->qscale = get_bits(&s->gb, 5);
2445
    skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
2446

    
2447
    /* PEI */
2448
    while (get_bits1(&s->gb) != 0) {
2449
        skip_bits(&s->gb, 8);
2450
    }
2451
    s->f_code = 1;
2452
    return 0;
2453
}
2454