Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ f94985d0

History | View | Annotate | Download (99.5 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 & b-frame support 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
#define MAX(a,b) ((a) > (b) ? (a) : (b))
35
#define MIN(a,b) ((a) < (b) ? (a) : (b))
36

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

    
54
extern UINT32 inverse[256];
55

    
56
static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
57
static UINT8 fcode_tab[MAX_MV*2+1];
58
static UINT8 umv_fcode_tab[MAX_MV*2+1];
59

    
60
static UINT16 uni_DCtab_lum  [512][2];
61
static UINT16 uni_DCtab_chrom[512][2];
62

    
63
int h263_get_picture_format(int width, int height)
64
{
65
    int format;
66

    
67
    if (width == 128 && height == 96)
68
        format = 1;
69
    else if (width == 176 && height == 144)
70
        format = 2;
71
    else if (width == 352 && height == 288)
72
        format = 3;
73
    else if (width == 704 && height == 576)
74
        format = 4;
75
    else if (width == 1408 && height == 1152)
76
        format = 5;
77
    else
78
        format = 7;
79
    return format;
80
}
81

    
82
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
83
{
84
    int format;
85

    
86
    align_put_bits(&s->pb);
87

    
88
    /* Update the pointer to last GOB */
89
    s->ptr_lastgob = pbBufPtr(&s->pb);
90
    s->gob_number = 0;
91

    
92
    put_bits(&s->pb, 22, 0x20); /* PSC */
93
    put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / 
94
                         s->frame_rate) & 0xff);
95

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

    
167
    put_bits(&s->pb, 1, 0);        /* no PEI */
168
}
169

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

    
217
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
218
{
219
    int score0=0, score1=0;
220
    int i, n;
221

    
222
    for(n=0; n<6; n++){
223
        INT16 *ac_val, *ac_val1;
224

    
225
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
226
        ac_val1= ac_val;
227
        if(dir[n]){
228
            ac_val-= s->block_wrap[n]*16;
229
            for(i=1; i<8; i++){
230
                const int level= block[n][block_permute_op(i   )];
231
                score0+= ABS(level);
232
                score1+= ABS(level - ac_val[i+8]);
233
                ac_val1[i  ]=    block[n][block_permute_op(i<<3)];
234
                ac_val1[i+8]= level;
235
            }
236
        }else{
237
            ac_val-= 16;
238
            for(i=1; i<8; i++){
239
                const int level= block[n][block_permute_op(i<<3)];
240
                score0+= ABS(level);
241
                score1+= ABS(level - ac_val[i]);
242
                ac_val1[i  ]= level;
243
                ac_val1[i+8]=    block[n][block_permute_op(i   )];
244
            }
245
        }
246
    }
247

    
248
    return score0 > score1 ? 1 : 0;    
249
}
250

    
251
void mpeg4_encode_mb(MpegEncContext * s,
252
                    DCTELEM block[6][64],
253
                    int motion_x, int motion_y)
254
{
255
    int cbpc, cbpy, i, pred_x, pred_y;
256
    int bits;
257
    
258
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
259
    if (!s->mb_intra) {
260
        /* compute cbp */
261
        int cbp = 0;
262
        for (i = 0; i < 6; i++) {
263
            if (s->block_last_index[i] >= 0)
264
                cbp |= 1 << (5 - i);
265
        }
266

    
267
        if(s->pict_type==B_TYPE){
268
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
269
            int mb_type=  mb_type_table[s->mv_dir];
270
            
271
            if(s->mb_x==0){
272
                s->last_mv[0][0][0]= 
273
                s->last_mv[0][0][1]= 
274
                s->last_mv[1][0][0]= 
275
                s->last_mv[1][0][1]= 0;
276
            }
277

    
278
            /* nothing to do if this MB was skiped in the next P Frame */
279
            if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){
280
                s->skip_count++;
281
                s->mv[0][0][0]= 
282
                s->mv[0][0][1]= 
283
                s->mv[1][0][0]= 
284
                s->mv[1][0][1]= 0;
285
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
286
                return;
287
            }
288

    
289
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
290
                /* direct MB with MV={0,0} */
291
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
292
                s->misc_bits++;
293
                s->last_bits++;
294
                s->skip_count++;
295
                return;
296
            }
297
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
298
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
299
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
300
            if(cbp) put_bits(&s->pb, 6, cbp);
301
            
302
            if(cbp && mb_type)
303
                put_bits(&s->pb, 1, 0); /* no q-scale change */
304

    
305
            bits= get_bit_count(&s->pb);
306
            s->misc_bits+= bits - s->last_bits;
307
            s->last_bits=bits;
308

    
309
            switch(mb_type)
310
            {
311
            case 0: /* direct */
312
                h263_encode_motion(s, motion_x, 1);
313
                h263_encode_motion(s, motion_y, 1);                
314
                break;
315
            case 1: /* bidir */
316
                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
317
                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
318
                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
319
                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
320
                s->last_mv[0][0][0]= s->mv[0][0][0];
321
                s->last_mv[0][0][1]= s->mv[0][0][1];
322
                s->last_mv[1][0][0]= s->mv[1][0][0];
323
                s->last_mv[1][0][1]= s->mv[1][0][1];
324
                break;
325
            case 2: /* backward */
326
                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
327
                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
328
                s->last_mv[1][0][0]= motion_x;
329
                s->last_mv[1][0][1]= motion_y;
330
                break;
331
            case 3: /* forward */
332
                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
333
                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
334
                s->last_mv[0][0][0]= motion_x;
335
                s->last_mv[0][0][1]= motion_y;
336
                break;
337
            default:
338
                printf("unknown mb type\n");
339
                return;
340
            }
341
            bits= get_bit_count(&s->pb);
342
            s->mv_bits+= bits - s->last_bits;
343
            s->last_bits=bits;
344

    
345
            /* encode each block */
346
            for (i = 0; i < 6; i++) {
347
                mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);
348
            }
349
            bits= get_bit_count(&s->pb);
350
            s->p_tex_bits+= bits - s->last_bits;
351
            s->last_bits=bits;
352
        }else{ /* s->pict_type==B_TYPE */
353
            if ((cbp | motion_x | motion_y) == 0 && s->mv_type==MV_TYPE_16X16) {
354
                /* check if the B frames can skip it too, as we must skip it if we skip here 
355
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
356
                if(s->max_b_frames>0){
357
                    int i;
358
                    const int offset= (s->mb_x + s->mb_y*s->linesize)*16;
359
                    uint8_t *p_pic= s->new_picture[0] + offset;
360
                    s->mb_skiped=1;
361
                    for(i=0; i<s->max_b_frames; i++){
362
                        uint8_t *b_pic;
363
                        int diff;
364

    
365
                        if(s->coded_order[i+1].pict_type!=B_TYPE) break;
366

    
367
                        b_pic= s->coded_order[i+1].picture[0] + offset;
368
                        diff= pix_abs16x16(p_pic, b_pic, s->linesize);
369
                        if(diff>s->qscale*70){
370
                            s->mb_skiped=0;
371
                            break;
372
                        }
373
                    }
374
                }else
375
                    s->mb_skiped=1; 
376

    
377
                if(s->mb_skiped==1){
378
                    /* skip macroblock */
379
                    put_bits(&s->pb, 1, 1);
380
                    s->misc_bits++;
381
                    s->last_bits++;
382
                    s->skip_count++;
383
                    return;
384
                }
385
            }
386
            put_bits(&s->pb, 1, 0);        /* mb coded */
387
            if(s->mv_type==MV_TYPE_16X16){
388
                cbpc = cbp & 3;
389
                put_bits(&s->pb,
390
                        inter_MCBPC_bits[cbpc],
391
                        inter_MCBPC_code[cbpc]);
392
                cbpy = cbp >> 2;
393
                cbpy ^= 0xf;
394
                put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
395
                    
396
                bits= get_bit_count(&s->pb);
397
                s->misc_bits+= bits - s->last_bits;
398
                s->last_bits=bits;
399

    
400
                /* motion vectors: 16x16 mode */
401
                h263_pred_motion(s, 0, &pred_x, &pred_y);
402
            
403
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
404
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
405
            }else{
406
                cbpc = (cbp & 3)+16;
407
                put_bits(&s->pb,
408
                        inter_MCBPC_bits[cbpc],
409
                        inter_MCBPC_code[cbpc]);
410
                cbpy = cbp >> 2;
411
                cbpy ^= 0xf;
412
                put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
413

    
414
                bits= get_bit_count(&s->pb);
415
                s->misc_bits+= bits - s->last_bits;
416
                s->last_bits=bits;
417

    
418
                for(i=0; i<4; i++){
419
                    /* motion vectors: 8x8 mode*/
420
                    h263_pred_motion(s, i, &pred_x, &pred_y);
421

    
422
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
423
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
424
                }
425
            }
426
            bits= get_bit_count(&s->pb);
427
            s->mv_bits+= bits - s->last_bits;
428
            s->last_bits=bits;
429

    
430
            /* encode each block */
431
            for (i = 0; i < 6; i++) {
432
                mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);
433
            }
434
            bits= get_bit_count(&s->pb);
435
            s->p_tex_bits+= bits - s->last_bits;
436
            s->last_bits=bits;
437
            s->p_count++;
438
        }
439
    } else {
440
        int cbp;
441
        int dc_diff[6];   //dc values with the dc prediction subtracted 
442
        int dir[6];  //prediction direction
443
        int zigzag_last_index[6];
444
        UINT8 *scan_table[6];
445

    
446
        for(i=0; i<6; i++){
447
            const int level= block[i][0];
448
            UINT16 *dc_ptr;
449

    
450
            dc_diff[i]= level - mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
451
            if (i < 4) {
452
                *dc_ptr = level * s->y_dc_scale;
453
            } else {
454
                *dc_ptr = level * s->c_dc_scale;
455
            }
456
        }
457

    
458
        s->ac_pred= decide_ac_pred(s, block, dir);
459

    
460
        if(s->ac_pred){
461
            for(i=0; i<6; i++){
462
                UINT8 *st;
463
                int last_index;
464

    
465
                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
466
                if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
467
                else           st = ff_alternate_horizontal_scan; /* top */
468

    
469
                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
470
                    if(block[i][st[last_index]]) break;
471
                zigzag_last_index[i]= s->block_last_index[i];
472
                s->block_last_index[i]= last_index;
473
                scan_table[i]= st;
474
            }
475
        }else{
476
            for(i=0; i<6; i++)
477
                scan_table[i]= zigzag_direct;
478
        }
479

    
480
        /* compute cbp */
481
        cbp = 0;
482
        for (i = 0; i < 6; i++) {
483
            if (s->block_last_index[i] >= 1)
484
                cbp |= 1 << (5 - i);
485
        }
486

    
487
        cbpc = cbp & 3;
488
        if (s->pict_type == I_TYPE) {
489
            put_bits(&s->pb,
490
                intra_MCBPC_bits[cbpc],
491
                intra_MCBPC_code[cbpc]);
492
        } else {
493
            put_bits(&s->pb, 1, 0);        /* mb coded */
494
            put_bits(&s->pb,
495
                inter_MCBPC_bits[cbpc + 4],
496
                inter_MCBPC_code[cbpc + 4]);
497
        }
498
        put_bits(&s->pb, 1, s->ac_pred);
499
        cbpy = cbp >> 2;
500
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
501

    
502
        bits= get_bit_count(&s->pb);
503
        s->misc_bits+= bits - s->last_bits;
504
        s->last_bits=bits;
505

    
506
        /* encode each block */
507
        for (i = 0; i < 6; i++) {
508
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i]);
509
        }
510

    
511
        bits= get_bit_count(&s->pb);
512
        s->i_tex_bits+= bits - s->last_bits;
513
        s->last_bits=bits;
514
        s->i_count++;
515

    
516
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
517
        if(s->ac_pred){
518
            for(i=0; i<6; i++){
519
                int j;    
520
                INT16 *ac_val;
521

    
522
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
523

    
524
                if(dir[i]){
525
                    for(j=1; j<8; j++) 
526
                        block[i][block_permute_op(j   )]= ac_val[j+8];
527
                }else{
528
                    for(j=1; j<8; j++) 
529
                        block[i][block_permute_op(j<<3)]= ac_val[j  ];
530
                }
531
                s->block_last_index[i]= zigzag_last_index[i];
532
            }
533
        }
534
    }
535
}
536

    
537
void h263_encode_mb(MpegEncContext * s,
538
                    DCTELEM block[6][64],
539
                    int motion_x, int motion_y)
540
{
541
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
542
   
543
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
544
    if (!s->mb_intra) {
545
           /* compute cbp */
546
        cbp = 0;
547
        for (i = 0; i < 6; i++) {
548
            if (s->block_last_index[i] >= 0)
549
                cbp |= 1 << (5 - i);
550
        }
551
        if ((cbp | motion_x | motion_y) == 0) {
552
            /* skip macroblock */
553
            put_bits(&s->pb, 1, 1);
554
            return;
555
        }
556
        put_bits(&s->pb, 1, 0);    /* mb coded */
557
        cbpc = cbp & 3;
558
        put_bits(&s->pb,
559
                 inter_MCBPC_bits[cbpc],
560
                 inter_MCBPC_code[cbpc]);
561
        cbpy = cbp >> 2;
562
        cbpy ^= 0xf;
563
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
564

    
565
       /* motion vectors: 16x16 mode only now */
566
        h263_pred_motion(s, 0, &pred_x, &pred_y);
567
      
568
        if (!s->umvplus) {  
569
            h263_encode_motion(s, motion_x - pred_x, s->f_code);
570
            h263_encode_motion(s, motion_y - pred_y, s->f_code);
571
        }
572
        else {
573
            h263p_encode_umotion(s, motion_x - pred_x);
574
            h263p_encode_umotion(s, motion_y - pred_y);
575
            if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
576
            /* To prevent Start Code emulation */
577
                put_bits(&s->pb,1,1);
578
        }
579
   } else {
580
        /* compute cbp */
581
        cbp = 0;
582
        for (i = 0; i < 6; i++) {
583
            if (s->block_last_index[i] >= 1)
584
                cbp |= 1 << (5 - i);
585
        }
586

    
587
        cbpc = cbp & 3;
588
        if (s->pict_type == I_TYPE) {
589
            put_bits(&s->pb,
590
                     intra_MCBPC_bits[cbpc],
591
                     intra_MCBPC_code[cbpc]);
592
        } else {
593
            put_bits(&s->pb, 1, 0);        /* mb coded */
594
            put_bits(&s->pb,
595
                     inter_MCBPC_bits[cbpc + 4],
596
                     inter_MCBPC_code[cbpc + 4]);
597
        }
598
        if (s->h263_pred) {
599
            /* XXX: currently, we do not try to use ac prediction */
600
            put_bits(&s->pb, 1, 0);        /* no ac prediction */
601
        }
602
        cbpy = cbp >> 2;
603
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
604
    }
605

    
606
    /* encode each block */
607
    for (i = 0; i < 6; i++) {
608
        h263_encode_block(s, block[i], i);
609
    }
610
}
611

    
612
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
613
{
614
    int x, y, wrap, a, c, pred_dc, scale, i;
615
    INT16 *dc_val, *ac_val, *ac_val1;
616

    
617
    /* find prediction */
618
    if (n < 4) {
619
        x = 2 * s->mb_x + 1 + (n & 1);
620
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
621
        wrap = s->mb_width * 2 + 2;
622
        dc_val = s->dc_val[0];
623
        ac_val = s->ac_val[0][0];
624
        scale = s->y_dc_scale;
625
    } else {
626
        x = s->mb_x + 1;
627
        y = s->mb_y + 1;
628
        wrap = s->mb_width + 2;
629
        dc_val = s->dc_val[n - 4 + 1];
630
        ac_val = s->ac_val[n - 4 + 1][0];
631
        scale = s->c_dc_scale;
632
    }
633
    
634
    ac_val += ((y) * wrap + (x)) * 16;
635
    ac_val1 = ac_val;
636
    
637
    /* B C
638
     * A X 
639
     */
640
    a = dc_val[(x - 1) + (y) * wrap];
641
    c = dc_val[(x) + (y - 1) * wrap];
642
    
643
    pred_dc = 1024;
644
    if (s->ac_pred) {
645
        if (s->h263_aic_dir) {
646
            /* left prediction */
647
            if (a != 1024) {
648
                ac_val -= 16;
649
                for(i=1;i<8;i++) {
650
                    block[block_permute_op(i*8)] += ac_val[i];
651
                }
652
                pred_dc = a;
653
            }
654
        } else {
655
            /* top prediction */
656
            if (c != 1024) {
657
                ac_val -= 16 * wrap;
658
                for(i=1;i<8;i++) {
659
                    block[block_permute_op(i)] += ac_val[i + 8];
660
                }
661
                pred_dc = c;
662
            }
663
        }
664
    } else {
665
        /* just DC prediction */
666
        if (a != 1024 && c != 1024)
667
            pred_dc = (a + c) >> 1;
668
        else if (a != 1024)
669
            pred_dc = a;
670
        else
671
            pred_dc = c;
672
    }
673
    
674
    /* we assume pred is positive */
675
    block[0]=block[0]*scale + pred_dc;
676
    
677
    if (block[0] < 0)
678
        block[0] = 0;
679
    else if (!(block[0] & 1))
680
        block[0]++;
681
    
682
    /* Update AC/DC tables */
683
    dc_val[(x) + (y) * wrap] = block[0];
684
    
685
    /* left copy */
686
    for(i=1;i<8;i++)
687
        ac_val1[i] = block[block_permute_op(i * 8)];
688
    /* top copy */
689
    for(i=1;i<8;i++)
690
        ac_val1[8 + i] = block[block_permute_op(i)];
691
}
692

    
693
INT16 *h263_pred_motion(MpegEncContext * s, int block, 
694
                        int *px, int *py)
695
{
696
    int xy, wrap;
697
    INT16 *A, *B, *C, *mot_val;
698
    static const int off[4]= {2, 1, 1, -1};
699

    
700
    wrap = s->block_wrap[0];
701
    xy = s->block_index[block];
702

    
703
    mot_val = s->motion_val[xy];
704

    
705
    /* special case for first line */
706
    if ((s->mb_y == 0 || s->first_slice_line || s->first_gob_line) && block<2) {
707
        A = s->motion_val[xy - 1];
708
        *px = A[0];
709
        *py = A[1];
710
    } else {
711
        A = s->motion_val[xy - 1];
712
        B = s->motion_val[xy - wrap];
713
        C = s->motion_val[xy + off[block] - wrap];
714
        *px = mid_pred(A[0], B[0], C[0]);
715
        *py = mid_pred(A[1], B[1], C[1]);
716
    }
717
    return mot_val;
718
}
719

    
720
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
721
{
722
    int range, l, m, bit_size, sign, code, bits;
723

    
724
    if (val == 0) {
725
        /* zero vector */
726
        code = 0;
727
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
728
    } else {
729
        bit_size = f_code - 1;
730
        range = 1 << bit_size;
731
        /* modulo encoding */
732
        l = range * 32;
733
        m = 2 * l;
734
        if (val < -l) {
735
            val += m;
736
        } else if (val >= l) {
737
            val -= m;
738
        }
739

    
740
        if (val >= 0) {
741
            sign = 0;
742
        } else {
743
            val = -val;
744
            sign = 1;
745
        }
746
        val--;
747
        code = (val >> bit_size) + 1;
748
        bits = val & (range - 1);
749

    
750
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
751
        if (bit_size > 0) {
752
            put_bits(&s->pb, bit_size, bits);
753
        }
754
    }
755
}
756

    
757
/* Encode MV differences on H.263+ with Unrestricted MV mode */
758
static void h263p_encode_umotion(MpegEncContext * s, int val)
759
{
760
    short sval = 0; 
761
    short i = 0;
762
    short n_bits = 0;
763
    short temp_val;
764
    int code = 0;
765
    int tcode;
766
    
767
    if ( val == 0)
768
        put_bits(&s->pb, 1, 1);
769
    else if (val == 1)
770
        put_bits(&s->pb, 3, 0);
771
    else if (val == -1)
772
        put_bits(&s->pb, 3, 2);
773
    else {
774
        
775
        sval = ((val < 0) ? (short)(-val):(short)val);
776
        temp_val = sval;
777
        
778
        while (temp_val != 0) {
779
            temp_val = temp_val >> 1;
780
            n_bits++;
781
        }
782
        
783
        i = n_bits - 1;
784
        while (i > 0) {
785
            tcode = (sval & (1 << (i-1))) >> (i-1);
786
            tcode = (tcode << 1) | 1;
787
            code = (code << 2) | tcode;
788
            i--;
789
        }
790
        code = ((code << 1) | (val < 0)) << 1;
791
        put_bits(&s->pb, (2*n_bits)+1, code);
792
        //printf("\nVal = %d\tCode = %d", sval, code);
793
    }
794
}
795

    
796
static void init_mv_penalty_and_fcode(MpegEncContext *s)
797
{
798
    int f_code;
799
    int mv;
800
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
801
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
802
            int len;
803

    
804
            if(mv==0) len= mvtab[0][1];
805
            else{
806
                int val, bit_size, range, code;
807

    
808
                bit_size = s->f_code - 1;
809
                range = 1 << bit_size;
810

    
811
                val=mv;
812
                if (val < 0) 
813
                    val = -val;
814
                val--;
815
                code = (val >> bit_size) + 1;
816
                if(code<33){
817
                    len= mvtab[code][1] + 1 + bit_size;
818
                }else{
819
                    len= mvtab[32][1] + 2 + bit_size;
820
                }
821
            }
822

    
823
            mv_penalty[f_code][mv+MAX_MV]= len;
824
        }
825
    }
826

    
827
    for(f_code=MAX_FCODE; f_code>0; f_code--){
828
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
829
            fcode_tab[mv+MAX_MV]= f_code;
830
        }
831
    }
832

    
833
    for(mv=0; mv<MAX_MV*2+1; mv++){
834
        umv_fcode_tab[mv]= 1;
835
    }
836
}
837

    
838
static void init_uni_dc_tab()
839
{
840
    int level, uni_code, uni_len;
841

    
842
    for(level=-256; level<256; level++){
843
        int size, v, l;
844
        /* find number of bits */
845
        size = 0;
846
        v = abs(level);
847
        while (v) {
848
            v >>= 1;
849
            size++;
850
        }
851

    
852
        if (level < 0)
853
            l= (-level) ^ ((1 << size) - 1);
854
        else
855
            l= level;
856

    
857
        /* luminance */
858
        uni_code= DCtab_lum[size][0];
859
        uni_len = DCtab_lum[size][1];
860

    
861
        if (size > 0) {
862
            uni_code<<=size; uni_code|=l;
863
            uni_len+=size;
864
            if (size > 8){
865
                uni_code<<=1; uni_code|=1;
866
                uni_len++;
867
            }
868
        }
869
        uni_DCtab_lum[level+256][0]= uni_code;
870
        uni_DCtab_lum[level+256][1]= uni_len;
871

    
872
        /* chrominance */
873
        uni_code= DCtab_chrom[size][0];
874
        uni_len = DCtab_chrom[size][1];
875
        
876
        if (size > 0) {
877
            uni_code<<=size; uni_code|=l;
878
            uni_len+=size;
879
            if (size > 8){
880
                uni_code<<=1; uni_code|=1;
881
                uni_len++;
882
            }
883
        }
884
        uni_DCtab_chrom[level+256][0]= uni_code;
885
        uni_DCtab_chrom[level+256][1]= uni_len;
886

    
887
    }
888
}
889

    
890
void h263_encode_init(MpegEncContext *s)
891
{
892
    static int done = 0;
893

    
894
    if (!done) {
895
        done = 1;
896

    
897
        init_uni_dc_tab();
898

    
899
        init_rl(&rl_inter);
900
        init_rl(&rl_intra);
901

    
902
        init_mv_penalty_and_fcode(s);
903
    }
904
    s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
905
    
906
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
907
    switch(s->codec_id){
908
    case CODEC_ID_MPEG4:
909
        s->fcode_tab= fcode_tab;
910
        s->min_qcoeff= -2048;
911
        s->max_qcoeff=  2047;
912
        break;
913
    case CODEC_ID_H263P:
914
        s->fcode_tab= umv_fcode_tab;
915
        s->min_qcoeff= -128;
916
        s->max_qcoeff=  127;
917
        break;
918
    default: //nothing needed default table allready set in mpegvideo.c
919
        s->min_qcoeff= -128;
920
        s->max_qcoeff=  127;
921
    }
922

    
923
    /* h263 type bias */
924
    //FIXME mpeg4 mpeg quantizer    
925
    s->intra_quant_bias=0;
926
    s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
927
}
928

    
929
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
930
{
931
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
932
    int code;
933
    RLTable *rl = &rl_inter;
934

    
935
    if (s->mb_intra) {
936
        /* DC coef */
937
            level = block[0];
938
        /* 255 cannot be represented, so we clamp */
939
        if (level > 254) {
940
            level = 254;
941
            block[0] = 254;
942
        }
943
        /* 0 cannot be represented also */
944
        else if (!level) {
945
            level = 1;
946
            block[0] = 1;
947
        }
948
            if (level == 128)
949
                put_bits(&s->pb, 8, 0xff);
950
            else
951
                put_bits(&s->pb, 8, level & 0xff);
952
            i = 1;
953
    } else {
954
            i = 0;
955
    }
956

    
957
    /* AC coefs */
958
    last_index = s->block_last_index[n];
959
    last_non_zero = i - 1;
960
    for (; i <= last_index; i++) {
961
        j = zigzag_direct[i];
962
        level = block[j];
963
        if (level) {
964
            run = i - last_non_zero - 1;
965
            last = (i == last_index);
966
            sign = 0;
967
            slevel = level;
968
            if (level < 0) {
969
                sign = 1;
970
                level = -level;
971
            }
972
            code = get_rl_index(rl, last, run, level);
973
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
974
            if (code == rl->n) {
975
                put_bits(&s->pb, 1, last);
976
                put_bits(&s->pb, 6, run);
977
                put_bits(&s->pb, 8, slevel & 0xff);
978
            } else {
979
                put_bits(&s->pb, 1, sign);
980
            }
981
            last_non_zero = i;
982
        }
983
    }
984
}
985

    
986
/***************************************************/
987

    
988
static void mpeg4_stuffing(PutBitContext * pbc)
989
{
990
    int length;
991
    put_bits(pbc, 1, 0);
992
    length= (-get_bit_count(pbc))&7;
993
    put_bits(pbc, length, (1<<length)-1);
994
}
995

    
996
static void put_string(PutBitContext * pbc, char *s)
997
{
998
    while(*s){
999
        put_bits(pbc, 8, *s);
1000
        s++;
1001
    }
1002
    put_bits(pbc, 8, 0);
1003
}
1004

    
1005
/* must be called before writing the header */
1006
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1007
    int time_div, time_mod;
1008

    
1009
    if(s->pict_type==I_TYPE){ //we will encode a vol header
1010
        s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1011
        if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1012

    
1013
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1014
    }
1015

    
1016
    s->time= picture_number*(int64_t)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1017
    time_div= s->time/s->time_increment_resolution;
1018
    time_mod= s->time%s->time_increment_resolution;
1019

    
1020
    if(s->pict_type==B_TYPE){
1021
        s->bp_time= s->last_non_b_time - s->time;
1022
    }else{
1023
        s->last_time_base= s->time_base;
1024
        s->time_base= time_div;
1025
        s->pp_time= s->time - s->last_non_b_time;
1026
        s->last_non_b_time= s->time;
1027
    }
1028
}
1029

    
1030
static void mpeg4_encode_vol_header(MpegEncContext * s)
1031
{
1032
    int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1033
    char buf[255];
1034

    
1035
    s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
1036

    
1037
    if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
1038
    put_bits(&s->pb, 16, 0);
1039
    put_bits(&s->pb, 16, 0x100);        /* video obj */
1040
    put_bits(&s->pb, 16, 0);
1041
    put_bits(&s->pb, 16, 0x120);        /* video obj layer */
1042

    
1043
    put_bits(&s->pb, 1, 0);                /* random access vol */
1044
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1045
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1046
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1047
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1048
    if(s->aspect_ratio_info) 
1049
        put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1050
    else
1051
        put_bits(&s->pb, 4, 1);                /* aspect ratio info= sqare pixel */
1052

    
1053
    if(s->low_delay){
1054
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1055
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1056
        put_bits(&s->pb, 1, s->low_delay);
1057
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1058
    }else{
1059
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1060
    }
1061

    
1062
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1063
    put_bits(&s->pb, 1, 1);                /* marker bit */
1064
    
1065
    put_bits(&s->pb, 16, s->time_increment_resolution);
1066
    if (s->time_increment_bits < 1)
1067
        s->time_increment_bits = 1;
1068
    put_bits(&s->pb, 1, 1);                /* marker bit */
1069
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1070
    put_bits(&s->pb, 1, 1);                /* marker bit */
1071
    put_bits(&s->pb, 13, s->width);        /* vol width */
1072
    put_bits(&s->pb, 1, 1);                /* marker bit */
1073
    put_bits(&s->pb, 13, s->height);        /* vol height */
1074
    put_bits(&s->pb, 1, 1);                /* marker bit */
1075
    put_bits(&s->pb, 1, 0);                /* interlace */
1076
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1077
    if (vo_ver_id == 1) {
1078
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1079
    }else{ /* vo_ver_id == 2 */
1080
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1081
    }
1082
    put_bits(&s->pb, 1, 0);                /* not 8 bit */
1083
    put_bits(&s->pb, 1, 0);                /* quant type= h263 style*/
1084
    if (vo_ver_id != 1)
1085
        put_bits(&s->pb, 1, s->quarter_sample=0);
1086
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1087
    put_bits(&s->pb, 1, 1);                /* resync marker disable */
1088
    put_bits(&s->pb, 1, 0);                /* data partitioned */
1089
    if (vo_ver_id != 1){
1090
        put_bits(&s->pb, 1, 0);                /* newpred */
1091
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1092
    }
1093
    put_bits(&s->pb, 1, 0);                /* scalability */
1094

    
1095
    mpeg4_stuffing(&s->pb);
1096
    put_bits(&s->pb, 16, 0);
1097
    put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1098
    sprintf(buf, "FFmpeg v%s / libavcodec build: %s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1099
    put_string(&s->pb, buf);
1100

    
1101
    s->no_rounding = 0;
1102
}
1103

    
1104
/* write mpeg4 VOP header */
1105
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1106
{
1107
    int time_incr;
1108
    int time_div, time_mod;
1109
    
1110
    if(s->pict_type==I_TYPE) mpeg4_encode_vol_header(s);
1111
    
1112
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1113
    
1114
    if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
1115
    put_bits(&s->pb, 16, 0);                /* vop header */
1116
    put_bits(&s->pb, 16, 0x1B6);        /* vop header */
1117
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1118

    
1119
    time_div= s->time/s->time_increment_resolution;
1120
    time_mod= s->time%s->time_increment_resolution;
1121
    time_incr= time_div - s->last_time_base;
1122
    while(time_incr--)
1123
        put_bits(&s->pb, 1, 1);
1124
        
1125
    put_bits(&s->pb, 1, 0);
1126

    
1127
    put_bits(&s->pb, 1, 1);        /* marker */
1128
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1129
    put_bits(&s->pb, 1, 1);        /* marker */
1130
    put_bits(&s->pb, 1, 1);        /* vop coded */
1131
    if (    s->pict_type == P_TYPE 
1132
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1133
        s->no_rounding ^= 1;
1134
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1135
    }
1136
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1137
    //FIXME sprite stuff
1138

    
1139
    put_bits(&s->pb, 5, s->qscale);
1140

    
1141
    if (s->pict_type != I_TYPE)
1142
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1143
    if (s->pict_type == B_TYPE)
1144
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1145
    //    printf("****frame %d\n", picture_number);
1146
}
1147

    
1148
void h263_dc_scale(MpegEncContext * s)
1149
{
1150
#if 1
1151
    const static UINT8 y_tab[32]={
1152
    //  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
1153
        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
1154
    };
1155
    const static UINT8 c_tab[32]={
1156
    //  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
1157
        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
1158
    };
1159
    s->y_dc_scale = y_tab[s->qscale];
1160
    s->c_dc_scale = c_tab[s->qscale];
1161
#else
1162
    int quant;
1163
    quant = s->qscale;
1164
    /* luminance */
1165
    if (quant < 5)
1166
        s->y_dc_scale = 8;
1167
    else if (quant > 4 && quant < 9)
1168
        s->y_dc_scale = (2 * quant);
1169
    else if (quant > 8 && quant < 25)
1170
        s->y_dc_scale = (quant + 8);
1171
    else
1172
        s->y_dc_scale = (2 * quant - 16);
1173
    /* chrominance */
1174
    if (quant < 5)
1175
        s->c_dc_scale = 8;
1176
    else if (quant > 4 && quant < 25)
1177
        s->c_dc_scale = ((quant + 13) / 2);
1178
    else
1179
        s->c_dc_scale = (quant - 6);
1180
#endif
1181
}
1182

    
1183
static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1184
{
1185
    int a, b, c, wrap, pred, scale;
1186
    UINT16 *dc_val;
1187
    int dummy;
1188

    
1189
    /* find prediction */
1190
    if (n < 4) {
1191
        scale = s->y_dc_scale;
1192
    } else {
1193
        scale = s->c_dc_scale;
1194
    }
1195
    wrap= s->block_wrap[n];
1196
    dc_val = s->dc_val[0] + s->block_index[n];
1197

    
1198
    /* B C
1199
     * A X 
1200
     */
1201
    a = dc_val[ - 1];
1202
    b = dc_val[ - 1 - wrap];
1203
    c = dc_val[ - wrap];
1204

    
1205
    if (abs(a - b) < abs(b - c)) {
1206
        pred = c;
1207
        *dir_ptr = 1; /* top */
1208
    } else {
1209
        pred = a;
1210
        *dir_ptr = 0; /* left */
1211
    }
1212
    /* we assume pred is positive */
1213
#ifdef ARCH_X86
1214
        asm volatile (
1215
                "xorl %%edx, %%edx        \n\t"
1216
                "mul %%ecx                \n\t"
1217
                : "=d" (pred), "=a"(dummy)
1218
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1219
        );
1220
#else
1221
    pred = (pred + (scale >> 1)) / scale;
1222
#endif
1223

    
1224
    /* prepare address for prediction update */
1225
    *dc_val_ptr = &dc_val[0];
1226

    
1227
    return pred;
1228
}
1229

    
1230
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1231
                   int dir)
1232
{
1233
    int i;
1234
    INT16 *ac_val, *ac_val1;
1235

    
1236
    /* find prediction */
1237
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1238
    ac_val1 = ac_val;
1239
    if (s->ac_pred) {
1240
        if (dir == 0) {
1241
            /* left prediction */
1242
            ac_val -= 16;
1243
            for(i=1;i<8;i++) {
1244
                block[block_permute_op(i*8)] += ac_val[i];
1245
            }
1246
        } else {
1247
            /* top prediction */
1248
            ac_val -= 16 * s->block_wrap[n];
1249
            for(i=1;i<8;i++) {
1250
                block[block_permute_op(i)] += ac_val[i + 8];
1251
            }
1252
        }
1253
    }
1254
    /* left copy */
1255
    for(i=1;i<8;i++)
1256
        ac_val1[i] = block[block_permute_op(i * 8)];
1257
    /* top copy */
1258
    for(i=1;i<8;i++)
1259
        ac_val1[8 + i] = block[block_permute_op(i)];
1260
}
1261

    
1262
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1263
                              int dir)
1264
{
1265
    int i;
1266
    INT16 *ac_val;
1267

    
1268
    /* find prediction */
1269
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1270
 
1271
    if (dir == 0) {
1272
        /* left prediction */
1273
        ac_val -= 16;
1274
        for(i=1;i<8;i++) {
1275
            block[block_permute_op(i*8)] -= ac_val[i];
1276
        }
1277
    } else {
1278
        /* top prediction */
1279
        ac_val -= 16 * s->block_wrap[n];
1280
        for(i=1;i<8;i++) {
1281
            block[block_permute_op(i)] -= ac_val[i + 8];
1282
        }
1283
    }
1284
}
1285

    
1286
static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)
1287
{
1288
#if 1
1289
    level+=256;
1290
    if (n < 4) {
1291
        /* luminance */
1292
        put_bits(&s->pb, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1293
    } else {
1294
        /* chrominance */
1295
        put_bits(&s->pb, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1296
    }
1297
#else
1298
    int size, v;
1299
    /* find number of bits */
1300
    size = 0;
1301
    v = abs(level);
1302
    while (v) {
1303
        v >>= 1;
1304
        size++;
1305
    }
1306

    
1307
    if (n < 4) {
1308
        /* luminance */
1309
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1310
    } else {
1311
        /* chrominance */
1312
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1313
    }
1314

    
1315
    /* encode remaining bits */
1316
    if (size > 0) {
1317
        if (level < 0)
1318
            level = (-level) ^ ((1 << size) - 1);
1319
        put_bits(&s->pb, size, level);
1320
        if (size > 8)
1321
            put_bits(&s->pb, 1, 1);
1322
    }
1323
#endif
1324
}
1325

    
1326
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table)
1327
{
1328
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
1329
    int code;
1330
    const RLTable *rl;
1331

    
1332
    if (s->mb_intra) {
1333
        /* mpeg4 based DC predictor */
1334
        mpeg4_encode_dc(s, intra_dc, n);
1335
        i = 1;
1336
        rl = &rl_intra;
1337
    } else {
1338
        i = 0;
1339
        rl = &rl_inter;
1340
    }
1341

    
1342
    /* AC coefs */
1343
    last_index = s->block_last_index[n];
1344
    last_non_zero = i - 1;
1345
    for (; i <= last_index; i++) {
1346
        j = scan_table[i];
1347
        level = block[j];
1348
        if (level) {
1349
            run = i - last_non_zero - 1;
1350
            last = (i == last_index);
1351
            sign = 0;
1352
            slevel = level;
1353
            if (level < 0) {
1354
                sign = 1;
1355
                level = -level;
1356
            }
1357
            code = get_rl_index(rl, last, run, level);
1358
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1359
            if (code == rl->n) {
1360
                int level1, run1;
1361
                level1 = level - rl->max_level[last][run];
1362
                if (level1 < 1) 
1363
                    goto esc2;
1364
                code = get_rl_index(rl, last, run, level1);
1365
                if (code == rl->n) {
1366
                esc2:
1367
                    put_bits(&s->pb, 1, 1);
1368
                    if (level > MAX_LEVEL)
1369
                        goto esc3;
1370
                    run1 = run - rl->max_run[last][level] - 1;
1371
                    if (run1 < 0)
1372
                        goto esc3;
1373
                    code = get_rl_index(rl, last, run1, level);
1374
                    if (code == rl->n) {
1375
                    esc3:
1376
                        /* third escape */
1377
                        put_bits(&s->pb, 1, 1);
1378
                        put_bits(&s->pb, 1, last);
1379
                        put_bits(&s->pb, 6, run);
1380
                        put_bits(&s->pb, 1, 1);
1381
                        put_bits(&s->pb, 12, slevel & 0xfff);
1382
                        put_bits(&s->pb, 1, 1);
1383
                    } else {
1384
                        /* second escape */
1385
                        put_bits(&s->pb, 1, 0);
1386
                        put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1387
                        put_bits(&s->pb, 1, sign);
1388
                    }
1389
                } else {
1390
                    /* first escape */
1391
                    put_bits(&s->pb, 1, 0);
1392
                    put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1393
                    put_bits(&s->pb, 1, sign);
1394
                }
1395
            } else {
1396
                put_bits(&s->pb, 1, sign);
1397
            }
1398
            last_non_zero = i;
1399
        }
1400
    }
1401
}
1402

    
1403

    
1404

    
1405
/***********************************************/
1406
/* decoding */
1407

    
1408
static VLC intra_MCBPC_vlc;
1409
static VLC inter_MCBPC_vlc;
1410
static VLC cbpy_vlc;
1411
static VLC mv_vlc;
1412
static VLC dc_lum, dc_chrom;
1413
static VLC sprite_trajectory;
1414
static VLC mb_type_b_vlc;
1415

    
1416
void init_rl(RLTable *rl)
1417
{
1418
    INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1419
    UINT8 index_run[MAX_RUN+1];
1420
    int last, run, level, start, end, i;
1421

    
1422
    /* compute max_level[], max_run[] and index_run[] */
1423
    for(last=0;last<2;last++) {
1424
        if (last == 0) {
1425
            start = 0;
1426
            end = rl->last;
1427
        } else {
1428
            start = rl->last;
1429
            end = rl->n;
1430
        }
1431

    
1432
        memset(max_level, 0, MAX_RUN + 1);
1433
        memset(max_run, 0, MAX_LEVEL + 1);
1434
        memset(index_run, rl->n, MAX_RUN + 1);
1435
        for(i=start;i<end;i++) {
1436
            run = rl->table_run[i];
1437
            level = rl->table_level[i];
1438
            if (index_run[run] == rl->n)
1439
                index_run[run] = i;
1440
            if (level > max_level[run])
1441
                max_level[run] = level;
1442
            if (run > max_run[level])
1443
                max_run[level] = run;
1444
        }
1445
        rl->max_level[last] = malloc(MAX_RUN + 1);
1446
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1447
        rl->max_run[last] = malloc(MAX_LEVEL + 1);
1448
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1449
        rl->index_run[last] = malloc(MAX_RUN + 1);
1450
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1451
    }
1452
}
1453

    
1454
void init_vlc_rl(RLTable *rl)
1455
{
1456
    init_vlc(&rl->vlc, 9, rl->n + 1, 
1457
             &rl->table_vlc[0][1], 4, 2,
1458
             &rl->table_vlc[0][0], 4, 2);
1459
}
1460

    
1461
/* init vlcs */
1462

    
1463
/* XXX: find a better solution to handle static init */
1464
void h263_decode_init_vlc(MpegEncContext *s)
1465
{
1466
    static int done = 0;
1467

    
1468
    if (!done) {
1469
        done = 1;
1470

    
1471
        init_vlc(&intra_MCBPC_vlc, 6, 8, 
1472
                 intra_MCBPC_bits, 1, 1,
1473
                 intra_MCBPC_code, 1, 1);
1474
        init_vlc(&inter_MCBPC_vlc, 9, 25, 
1475
                 inter_MCBPC_bits, 1, 1,
1476
                 inter_MCBPC_code, 1, 1);
1477
        init_vlc(&cbpy_vlc, 6, 16,
1478
                 &cbpy_tab[0][1], 2, 1,
1479
                 &cbpy_tab[0][0], 2, 1);
1480
        init_vlc(&mv_vlc, 9, 33,
1481
                 &mvtab[0][1], 2, 1,
1482
                 &mvtab[0][0], 2, 1);
1483
        init_rl(&rl_inter);
1484
        init_rl(&rl_intra);
1485
        init_rl(&rl_intra_aic);
1486
        init_vlc_rl(&rl_inter);
1487
        init_vlc_rl(&rl_intra);
1488
        init_vlc_rl(&rl_intra_aic);
1489
        init_vlc(&dc_lum, 9, 13,
1490
                 &DCtab_lum[0][1], 2, 1,
1491
                 &DCtab_lum[0][0], 2, 1);
1492
        init_vlc(&dc_chrom, 9, 13,
1493
                 &DCtab_chrom[0][1], 2, 1,
1494
                 &DCtab_chrom[0][0], 2, 1);
1495
        init_vlc(&sprite_trajectory, 9, 15,
1496
                 &sprite_trajectory_tab[0][1], 4, 2,
1497
                 &sprite_trajectory_tab[0][0], 4, 2);
1498
        init_vlc(&mb_type_b_vlc, 4, 4,
1499
                 &mb_type_b_tab[0][1], 2, 1,
1500
                 &mb_type_b_tab[0][0], 2, 1);
1501
    }
1502
}
1503

    
1504
int h263_decode_gob_header(MpegEncContext *s)
1505
{
1506
    unsigned int val, gfid;
1507
    
1508
    /* Check for GOB Start Code */
1509
    val = show_bits(&s->gb, 16);
1510
    if (val == 0) {
1511
        /* We have a GBSC probably with GSTUFF */
1512
        skip_bits(&s->gb, 16); /* Drop the zeros */
1513
        while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1514
#ifdef DEBUG
1515
        fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1516
#endif
1517
        s->gob_number = get_bits(&s->gb, 5); /* GN */
1518
        gfid = get_bits(&s->gb, 2); /* GFID */
1519
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1520
#ifdef DEBUG
1521
        fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1522
#endif
1523
        return 1;
1524
    }
1525
    return 0;
1526
            
1527
}
1528

    
1529
static inline void memsetw(short *tab, int val, int n)
1530
{
1531
    int i;
1532
    for(i=0;i<n;i++)
1533
        tab[i] = val;
1534
}
1535

    
1536
static int mpeg4_resync(MpegEncContext *s)
1537
{
1538
    int state, v, bits;
1539
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1540
    int header_extension=0, mb_num;
1541
    int c_wrap, c_xy, l_wrap, l_xy;
1542
    int time_increment;
1543
//printf("resync at %d %d\n", s->mb_x, s->mb_y);
1544
//printf("%X\n", show_bits(&s->gb, 24));
1545

    
1546
    if( get_bits_count(&s->gb) > s->gb.size*8-32)
1547
        return 0;
1548

    
1549
    align_get_bits(&s->gb);
1550
    state = 0xff;
1551
    for(;;) {
1552
        v = get_bits(&s->gb, 8);
1553
//printf("%X ", v);
1554
        state = ((state << 8) | v) & 0xffff;
1555
        if (state == 0) break;
1556
        if( get_bits_count(&s->gb) > s->gb.size*8-32){
1557
            printf("resync failed\n");
1558
            return -1;
1559
        }
1560
    }
1561
//printf("%X\n", show_bits(&s->gb, 24));
1562
    bits=0;
1563
    while(!get_bits1(&s->gb) && bits<30) bits++;
1564
    if(s->pict_type == P_TYPE && bits != s->f_code-1)
1565
        printf("marker does not match f_code\n");
1566
    //FIXME check bits for B-framess
1567
//printf("%X\n", show_bits(&s->gb, 24));
1568

    
1569
    if(s->shape != RECT_SHAPE){
1570
        header_extension= get_bits1(&s->gb);
1571
        //FIXME more stuff here
1572
    }
1573

    
1574
    mb_num= get_bits(&s->gb, mb_num_bits);
1575
    if(mb_num != s->mb_x + s->mb_y*s->mb_width){
1576
        printf("MB-num change not supported %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width);
1577
//        s->mb_x= mb_num % s->mb_width;
1578
//        s->mb_y= mb_num / s->mb_width;
1579
        //FIXME many vars are wrong now
1580
    } 
1581

    
1582
    if(s->shape != BIN_ONLY_SHAPE){
1583
        s->qscale= get_bits(&s->gb, 5);
1584
        h263_dc_scale(s);
1585
    }
1586

    
1587
    if(s->shape == RECT_SHAPE){
1588
        header_extension= get_bits1(&s->gb);
1589
    }
1590
    if(header_extension){
1591
        int time_incr=0;
1592
        printf("header extension not really supported\n");
1593
        while (get_bits1(&s->gb) != 0) 
1594
            time_incr++;
1595

    
1596
        check_marker(&s->gb, "before time_increment in video packed header");
1597
        time_increment= get_bits(&s->gb, s->time_increment_bits);
1598
        if(s->pict_type!=B_TYPE){
1599
            s->last_time_base= s->time_base;
1600
            s->time_base+= time_incr;
1601
            s->time= s->time_base*s->time_increment_resolution + time_increment;
1602
            s->pp_time= s->time - s->last_non_b_time;
1603
            s->last_non_b_time= s->time;
1604
        }else{
1605
            s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
1606
            s->bp_time= s->last_non_b_time - s->time;
1607
        }
1608
        check_marker(&s->gb, "before vop_coding_type in video packed header");
1609
        
1610
        skip_bits(&s->gb, 2); /* vop coding type */
1611
        //FIXME not rect stuff here
1612

    
1613
        if(s->shape != BIN_ONLY_SHAPE){
1614
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
1615

    
1616
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){
1617
                mpeg4_decode_sprite_trajectory(s);
1618
            }
1619

    
1620
            //FIXME reduced res stuff here
1621
            
1622
            if (s->pict_type != I_TYPE) {
1623
                s->f_code = get_bits(&s->gb, 3);        /* fcode_for */
1624
                if(s->f_code==0){
1625
                    printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n");
1626
                    return -1; // makes no sense to continue, as the MV decoding will break very quickly
1627
                }
1628
            }
1629
            if (s->pict_type == B_TYPE) {
1630
                s->b_code = get_bits(&s->gb, 3);
1631
            }       
1632
        }
1633

    
1634
    }
1635
    //FIXME new-pred stuff
1636

    
1637
    l_wrap= s->block_wrap[0];
1638
    l_xy= s->mb_y*l_wrap*2;
1639
    c_wrap= s->block_wrap[4];
1640
    c_xy= s->mb_y*c_wrap;
1641

    
1642
    /* clean DC */
1643
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*3);
1644
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap*2);
1645
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap*2);
1646

    
1647
    /* clean AC */
1648
    memset(s->ac_val[0] + l_xy, 0, l_wrap*3*16*sizeof(INT16));
1649
    memset(s->ac_val[1] + c_xy, 0, c_wrap*2*16*sizeof(INT16));
1650
    memset(s->ac_val[2] + c_xy, 0, c_wrap*2*16*sizeof(INT16));
1651

    
1652
    /* clean MV */
1653
    memset(s->motion_val + l_xy, 0, l_wrap*3*2*sizeof(INT16));
1654
//    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
1655
    s->resync_x_pos= s->mb_x;
1656
    s->first_slice_line=1;
1657

    
1658
    return 0;
1659
}
1660

    
1661
int h263_decode_mb(MpegEncContext *s,
1662
                   DCTELEM block[6][64])
1663
{
1664
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1665
    INT16 *mot_val;
1666
    static INT8 quant_tab[4] = { -1, -2, 1, 2 };
1667

    
1668
    if(s->resync_marker){
1669
        if(   s->resync_x_pos == s->mb_x+1
1670
           || s->resync_x_pos == s->mb_x){
1671
            /* f*ck mpeg4
1672
               this is here so we dont need to slowdown h263_pred_motion with it */
1673
            if(s->resync_x_pos == s->mb_x+1 && s->mb_x==0){
1674
                int xy= s->block_index[0] - s->block_wrap[0];
1675
                s->motion_val[xy][0]= s->motion_val[xy+2][0];
1676
                s->motion_val[xy][1]= s->motion_val[xy+2][1];
1677
            }
1678

    
1679
            s->first_slice_line=0; 
1680
            s->resync_x_pos=0; // isnt needed but for cleanness sake ;)
1681
        }
1682

    
1683
        if(show_aligned_bits(&s->gb, 1, 16) == 0){
1684
            if( mpeg4_resync(s) < 0 ) return -1;
1685
            
1686
        }
1687
    }
1688

    
1689
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
1690
        if (get_bits1(&s->gb)) {
1691
            /* skip mb */
1692
            s->mb_intra = 0;
1693
            for(i=0;i<6;i++)
1694
                s->block_last_index[i] = -1;
1695
            s->mv_dir = MV_DIR_FORWARD;
1696
            s->mv_type = MV_TYPE_16X16;
1697
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
1698
                const int a= s->sprite_warping_accuracy;
1699
//                int l = (1 << (s->f_code - 1)) * 32;
1700

    
1701
                s->mcsel=1;
1702
                if(s->divx_version==500 && s->divx_build==413){
1703
                    s->mv[0][0][0] = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
1704
                    s->mv[0][0][1] = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
1705
                }else{
1706
                    s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1707
                    s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1708
                }
1709
/*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
1710
                else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
1711
                if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
1712
                else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
1713

    
1714
                s->mb_skiped = 0;
1715
            }else{
1716
                s->mcsel=0;
1717
                s->mv[0][0][0] = 0;
1718
                s->mv[0][0][1] = 0;
1719
                s->mb_skiped = 1;
1720
            }
1721
            return 0;
1722
        }
1723
        cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
1724
        //fprintf(stderr, "\tCBPC: %d", cbpc);
1725
        if (cbpc < 0)
1726
            return -1;
1727
        if (cbpc > 20)
1728
            cbpc+=3;
1729
        else if (cbpc == 20)
1730
            fprintf(stderr, "Stuffing !");
1731
        
1732
        dquant = cbpc & 8;
1733
        s->mb_intra = ((cbpc & 4) != 0);
1734
        if (s->mb_intra) goto intra;
1735
        
1736
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
1737
            s->mcsel= get_bits1(&s->gb);
1738
        else s->mcsel= 0;
1739
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
1740
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
1741
        if (dquant) {
1742
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
1743
            if (s->qscale < 1)
1744
                s->qscale = 1;
1745
            else if (s->qscale > 31)
1746
                s->qscale = 31;
1747
            h263_dc_scale(s);
1748
        }
1749
        s->mv_dir = MV_DIR_FORWARD;
1750
        if ((cbpc & 16) == 0) {
1751
            /* 16x16 motion prediction */
1752
            s->mv_type = MV_TYPE_16X16;
1753
            h263_pred_motion(s, 0, &pred_x, &pred_y);
1754
            if (s->umvplus_dec)
1755
               mx = h263p_decode_umotion(s, pred_x);
1756
            else if(!s->mcsel)
1757
               mx = h263_decode_motion(s, pred_x, s->f_code);
1758
            else {
1759
               const int a= s->sprite_warping_accuracy;
1760
//        int l = (1 << (s->f_code - 1)) * 32;
1761
                if(s->divx_version==500 && s->divx_build==413){
1762
                    mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
1763
                }else{
1764
                    mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1765
                }
1766
//        if (mx < -l) mx= -l, printf("C");
1767
//        else if (mx >= l) mx= l-1, printf("C");
1768
            }
1769
            if (mx >= 0xffff)
1770
                return -1;
1771
            
1772
            if (s->umvplus_dec)
1773
               my = h263p_decode_umotion(s, pred_y);
1774
            else if(!s->mcsel)
1775
               my = h263_decode_motion(s, pred_y, s->f_code);
1776
            else{
1777
               const int a= s->sprite_warping_accuracy;
1778
//       int l = (1 << (s->f_code - 1)) * 32;
1779
                if(s->divx_version==500 && s->divx_build==413){
1780
                    my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
1781
                }else{
1782
                    my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1783
                }
1784
//       if (my < -l) my= -l, printf("C");
1785
//       else if (my >= l) my= l-1, printf("C");
1786
            }
1787
            if (my >= 0xffff)
1788
                return -1;
1789
            s->mv[0][0][0] = mx;
1790
            s->mv[0][0][1] = my;
1791
            /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
1792
            fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
1793
            fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
1794
            if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1795
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1796
                           
1797
        } else {
1798
            s->mv_type = MV_TYPE_8X8;
1799
            for(i=0;i<4;i++) {
1800
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1801
                if (s->umvplus_dec)
1802
                  mx = h263p_decode_umotion(s, pred_x);
1803
                else
1804
                  mx = h263_decode_motion(s, pred_x, s->f_code);
1805
                if (mx >= 0xffff)
1806
                    return -1;
1807
                
1808
                if (s->umvplus_dec)
1809
                  my = h263p_decode_umotion(s, pred_y);
1810
                else    
1811
                  my = h263_decode_motion(s, pred_y, s->f_code);
1812
                if (my >= 0xffff)
1813
                    return -1;
1814
                s->mv[0][i][0] = mx;
1815
                s->mv[0][i][1] = my;
1816
                if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1817
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1818
                mot_val[0] = mx;
1819
                mot_val[1] = my;
1820
            }
1821
        }
1822
    } else if(s->pict_type==B_TYPE) {
1823
        int modb1; // first bit of modb
1824
        int modb2; // second bit of modb
1825
        int mb_type;
1826
        uint16_t time_pp;
1827
        uint16_t time_pb;
1828
        int xy;
1829

    
1830
        s->mb_intra = 0; //B-frames never contain intra blocks
1831
        s->mcsel=0;      //     ...               true gmc blocks
1832

    
1833
        if(s->mb_x==0){
1834
            s->last_mv[0][0][0]= 
1835
            s->last_mv[0][0][1]= 
1836
            s->last_mv[1][0][0]= 
1837
            s->last_mv[1][0][1]= 0;
1838
//            printf("\n");
1839
        }
1840

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

    
1844
        if(s->mb_skiped){
1845
                /* skip mb */
1846
            for(i=0;i<6;i++)
1847
                s->block_last_index[i] = -1;
1848

    
1849
            s->mv_dir = MV_DIR_FORWARD;
1850
            s->mv_type = MV_TYPE_16X16;
1851
            s->mv[0][0][0] = 0;
1852
            s->mv[0][0][1] = 0;
1853
            s->mv[1][0][0] = 0;
1854
            s->mv[1][0][1] = 0;
1855
//FIXME is this correct?
1856
/*            s->last_mv[0][0][0]=
1857
            s->last_mv[0][0][1]=0;*/
1858
//            printf("S");
1859
            return 0;
1860
        }
1861

    
1862
        modb1= get_bits1(&s->gb);
1863
        if(modb1==0){
1864
            modb2= get_bits1(&s->gb);
1865
            mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
1866
            if(modb2==0) cbp= get_bits(&s->gb, 6);
1867
            else cbp=0;
1868
            if (mb_type && cbp) {
1869
                if(get_bits1(&s->gb)){
1870
                    s->qscale +=get_bits1(&s->gb)*4 - 2;
1871
                    if (s->qscale < 1)
1872
                        s->qscale = 1;
1873
                    else if (s->qscale > 31)
1874
                        s->qscale = 31;
1875
                    h263_dc_scale(s);
1876
                }
1877
            }
1878
        }else{
1879
            mb_type=4; //like 0 but no vectors coded
1880
            cbp=0;
1881
        }
1882
        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
1883
        mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
1884
        switch(mb_type)
1885
        {
1886
        case 0: /* direct */
1887
            mx = h263_decode_motion(s, 0, 1);
1888
            my = h263_decode_motion(s, 0, 1);
1889
        case 4: /* direct with mx=my=0 */
1890
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1891
            xy= s->block_index[0];
1892
            time_pp= s->pp_time;
1893
            time_pb= time_pp - s->bp_time;
1894
//if(time_pp>3000 )printf("%d %d  ", time_pp, time_pb);
1895
            //FIXME 4MV
1896
            //FIXME avoid divides
1897
            s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
1898
            s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
1899
            s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
1900
                                : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
1901
            s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
1902
                                : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
1903
/*            s->mv[0][0][0] = 
1904
            s->mv[0][0][1] = 
1905
            s->mv[1][0][0] = 
1906
            s->mv[1][0][1] = 1000;*/
1907
//            printf("D");
1908
            break;
1909
        case 1: 
1910
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
1911
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1912
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1913
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1914
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1915

    
1916
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1917
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1918
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1919
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1920
//            printf("I");
1921
            break;
1922
        case 2: 
1923
            s->mv_dir = MV_DIR_BACKWARD;
1924
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1925
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1926
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1927
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1928
//            printf("B");
1929
            break;
1930
        case 3:
1931
            s->mv_dir = MV_DIR_FORWARD;
1932
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1933
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1934
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1935
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1936
//            printf("F");
1937
            break;
1938
        default: return -1;
1939
        }
1940
    } else { /* I-Frame */
1941
        cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
1942
        if (cbpc < 0)
1943
            return -1;
1944
        dquant = cbpc & 4;
1945
        s->mb_intra = 1;
1946
intra:
1947
        s->ac_pred = 0;
1948
        if (s->h263_pred || s->h263_aic) {
1949
            s->ac_pred = get_bits1(&s->gb);
1950
            if (s->ac_pred && s->h263_aic)
1951
                s->h263_aic_dir = get_bits1(&s->gb);
1952
        }
1953
        if (s->h263_aic) {
1954
            s->y_dc_scale = 2 * s->qscale;
1955
            s->c_dc_scale = 2 * s->qscale;
1956
        }
1957
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
1958
        cbp = (cbpc & 3) | (cbpy << 2);
1959
        if (dquant) {
1960
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
1961
            if (s->qscale < 1)
1962
                s->qscale = 1;
1963
            else if (s->qscale > 31)
1964
                s->qscale = 31;
1965
            h263_dc_scale(s);
1966
        }
1967
    }
1968

    
1969
    /* decode each block */
1970
    if (s->h263_pred) {
1971
        for (i = 0; i < 6; i++) {
1972
            if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1973
                return -1;
1974
        }
1975
    } else {
1976
        for (i = 0; i < 6; i++) {
1977
            if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1978
                return -1;
1979
        }
1980
    }
1981
    return 0;
1982
}
1983

    
1984
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
1985
{
1986
    int code, val, sign, shift, l, m;
1987

    
1988
    code = get_vlc(&s->gb, &mv_vlc);
1989
    if (code < 0)
1990
        return 0xffff;
1991

    
1992
    if (code == 0)
1993
        return pred;
1994
    sign = get_bits1(&s->gb);
1995
    shift = f_code - 1;
1996
    val = (code - 1) << shift;
1997
    if (shift > 0)
1998
        val |= get_bits(&s->gb, shift);
1999
    val++;
2000
    if (sign)
2001
        val = -val;
2002
    val += pred;
2003
    
2004
    /* modulo decoding */
2005
    if (!s->h263_long_vectors) {
2006
        l = (1 << (f_code - 1)) * 32;
2007
        m = 2 * l;
2008
        if (val < -l) {
2009
            val += m;
2010
        } else if (val >= l) {
2011
            val -= m;
2012
        }
2013
    } else {
2014
        /* horrible h263 long vector mode */
2015
        if (pred < -31 && val < -63)
2016
            val += 64;
2017
        if (pred > 32 && val > 63)
2018
            val -= 64;
2019
        
2020
    }
2021
    return val;
2022
}
2023

    
2024
/* Decodes RVLC of H.263+ UMV */
2025
static int h263p_decode_umotion(MpegEncContext * s, int pred)
2026
{
2027
   int code = 0, sign;
2028
   
2029
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
2030
      return pred;
2031
   
2032
   code = 2 + get_bits1(&s->gb);
2033
   
2034
   while (get_bits1(&s->gb))
2035
   {
2036
      code <<= 1;
2037
      code += get_bits1(&s->gb);
2038
   }
2039
   sign = code & 1;
2040
   code >>= 1;
2041
   
2042
   code = (sign) ? (pred - code) : (pred + code);
2043
#ifdef DEBUG
2044
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
2045
#endif
2046
   return code;   
2047

    
2048
}
2049

    
2050
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
2051
                             int n, int coded)
2052
{
2053
    int code, level, i, j, last, run;
2054
    RLTable *rl = &rl_inter;
2055
    const UINT8 *scan_table;
2056

    
2057
    scan_table = zigzag_direct;
2058
    if (s->h263_aic && s->mb_intra) {
2059
        rl = &rl_intra_aic;
2060
        i = 0;
2061
        if (s->ac_pred) {
2062
            if (s->h263_aic_dir) 
2063
                scan_table = ff_alternate_vertical_scan; /* left */
2064
            else
2065
                scan_table = ff_alternate_horizontal_scan; /* top */
2066
        }
2067
    } else if (s->mb_intra) {
2068
        /* DC coef */
2069
        if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
2070
            int component, diff;
2071
            component = (n <= 3 ? 0 : n - 4 + 1);
2072
            level = s->last_dc[component];
2073
            if (s->rv10_first_dc_coded[component]) {
2074
                diff = rv_decode_dc(s, n);
2075
                if (diff == 0xffff)
2076
                    return -1;
2077
                level += diff;
2078
                level = level & 0xff; /* handle wrap round */
2079
                s->last_dc[component] = level;
2080
            } else {
2081
                s->rv10_first_dc_coded[component] = 1;
2082
            }
2083
        } else {
2084
            level = get_bits(&s->gb, 8);
2085
            if (level == 255)
2086
                level = 128;
2087
        }
2088
        block[0] = level;
2089
        i = 1;
2090
    } else {
2091
        i = 0;
2092
    }
2093
    if (!coded) {
2094
        if (s->mb_intra && s->h263_aic)
2095
            goto not_coded;
2096
        s->block_last_index[n] = i - 1;
2097
        return 0;
2098
    }
2099

    
2100
    for(;;) {
2101
        code = get_vlc(&s->gb, &rl->vlc);
2102
        if (code < 0)
2103
            return -1;
2104
        if (code == rl->n) {
2105
            /* escape */
2106
            last = get_bits1(&s->gb);
2107
            run = get_bits(&s->gb, 6);
2108
            level = (INT8)get_bits(&s->gb, 8);
2109
            if (s->h263_rv10 && level == -128) {
2110
                /* XXX: should patch encoder too */
2111
                level = get_bits(&s->gb, 12);
2112
                level = (level << 20) >> 20;
2113
            }
2114
        } else {
2115
            run = rl->table_run[code];
2116
            level = rl->table_level[code];
2117
            last = code >= rl->last;
2118
            if (get_bits1(&s->gb))
2119
                level = -level;
2120
        }
2121
        i += run;
2122
        if (i >= 64)
2123
            return -1;
2124
        j = scan_table[i];
2125
        block[j] = level;
2126
        if (last)
2127
            break;
2128
        i++;
2129
    }
2130
not_coded:    
2131
    if (s->mb_intra && s->h263_aic) {
2132
        h263_pred_acdc(s, block, n);
2133
        i = 63;
2134
    }
2135
    s->block_last_index[n] = i;
2136
    return 0;
2137
}
2138

    
2139
static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
2140
{
2141
    int level, pred, code;
2142
    UINT16 *dc_val;
2143

    
2144
    if (n < 4) 
2145
        code = get_vlc(&s->gb, &dc_lum);
2146
    else 
2147
        code = get_vlc(&s->gb, &dc_chrom);
2148
    if (code < 0)
2149
        return -1;
2150
    if (code == 0) {
2151
        level = 0;
2152
    } else {
2153
        level = get_bits(&s->gb, code);
2154
        if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
2155
            level = - (level ^ ((1 << code) - 1));
2156
        if (code > 8)
2157
            skip_bits1(&s->gb); /* marker */
2158
    }
2159

    
2160
    pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
2161
    level += pred;
2162
    if (level < 0)
2163
        level = 0;
2164
    if (n < 4) {
2165
        *dc_val = level * s->y_dc_scale;
2166
    } else {
2167
        *dc_val = level * s->c_dc_scale;
2168
    }
2169
    return level;
2170
}
2171

    
2172
static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
2173
                              int n, int coded)
2174
{
2175
    int code, level, i, j, last, run;
2176
    int dc_pred_dir;
2177
    RLTable *rl;
2178
    const UINT8 *scan_table;
2179

    
2180
    if (s->mb_intra) {
2181
        /* DC coef */
2182
        level = mpeg4_decode_dc(s, n, &dc_pred_dir);
2183
        if (level < 0)
2184
            return -1;
2185
        block[0] = level;
2186
        i = 1;
2187
        if (!coded) 
2188
            goto not_coded;
2189
        rl = &rl_intra;
2190
        if (s->ac_pred) {
2191
            if (dc_pred_dir == 0) 
2192
                scan_table = ff_alternate_vertical_scan; /* left */
2193
            else
2194
                scan_table = ff_alternate_horizontal_scan; /* top */
2195
        } else {
2196
            scan_table = zigzag_direct;
2197
        }
2198
    } else {
2199
        i = 0;
2200
        if (!coded) {
2201
            s->block_last_index[n] = i - 1;
2202
            return 0;
2203
        }
2204
        rl = &rl_inter;
2205
        scan_table = zigzag_direct;
2206
    }
2207

    
2208
    for(;;) {
2209
        code = get_vlc(&s->gb, &rl->vlc);
2210
        if (code < 0)
2211
            return -1;
2212
        if (code == rl->n) {
2213
            /* escape */
2214
            if (get_bits1(&s->gb) != 0) {
2215
                if (get_bits1(&s->gb) != 0) {
2216
                    /* third escape */
2217
                    last = get_bits1(&s->gb);
2218
                    run = get_bits(&s->gb, 6);
2219
                    get_bits1(&s->gb); /* marker */
2220
                    level = get_bits(&s->gb, 12);
2221
                    level = (level << 20) >> 20; /* sign extend */
2222
                    skip_bits1(&s->gb); /* marker */
2223
                } else {
2224
                    /* second escape */
2225
                    code = get_vlc(&s->gb, &rl->vlc);
2226
                    if (code < 0 || code >= rl->n)
2227
                        return -1;
2228
                    run = rl->table_run[code];
2229
                    level = rl->table_level[code];
2230
                    last = code >= rl->last;
2231
                    run += rl->max_run[last][level] + 1;
2232
                    if (get_bits1(&s->gb))
2233
                        level = -level;
2234
                }
2235
            } else {
2236
                /* first escape */
2237
                code = get_vlc(&s->gb, &rl->vlc);
2238
                if (code < 0 || code >= rl->n)
2239
                    return -1;
2240
                run = rl->table_run[code];
2241
                level = rl->table_level[code];
2242
                last = code >= rl->last;
2243
                level += rl->max_level[last][run];
2244
                if (get_bits1(&s->gb))
2245
                    level = -level;
2246
            }
2247
        } else {
2248
            run = rl->table_run[code];
2249
            level = rl->table_level[code];
2250
            last = code >= rl->last;
2251
            if (get_bits1(&s->gb))
2252
                level = -level;
2253
        }
2254
        i += run;
2255
        if (i >= 64)
2256
            return -1;
2257
        j = scan_table[i];
2258
        block[j] = level;
2259
        i++;
2260
        if (last)
2261
            break;
2262
    }
2263
 not_coded:
2264
    if (s->mb_intra) {
2265
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
2266
        if (s->ac_pred) {
2267
            i = 64; /* XXX: not optimal */
2268
        }
2269
    }
2270
    s->block_last_index[n] = i - 1;
2271
    return 0;
2272
}
2273

    
2274
/* most is hardcoded. should extend to handle all h263 streams */
2275
int h263_decode_picture_header(MpegEncContext *s)
2276
{
2277
    int format, width, height;
2278

    
2279
    /* picture header */
2280
    if (get_bits(&s->gb, 22) != 0x20)
2281
        return -1;
2282
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
2283
    
2284
    if (get_bits1(&s->gb) != 1)
2285
        return -1;        /* marker */
2286
    if (get_bits1(&s->gb) != 0)
2287
        return -1;        /* h263 id */
2288
    skip_bits1(&s->gb);        /* split screen off */
2289
    skip_bits1(&s->gb);        /* camera  off */
2290
    skip_bits1(&s->gb);        /* freeze picture release off */
2291

    
2292
    /* Reset GOB number */
2293
    s->gob_number = 0;
2294
        
2295
    format = get_bits(&s->gb, 3);
2296

    
2297
    if (format != 7 && format != 6) {
2298
        s->h263_plus = 0;
2299
        /* H.263v1 */
2300
        width = h263_format[format][0];
2301
        height = h263_format[format][1];
2302
        if (!width)
2303
            return -1;
2304
        
2305
        s->width = width;
2306
        s->height = height;
2307
        s->pict_type = I_TYPE + get_bits1(&s->gb);
2308

    
2309
        s->unrestricted_mv = get_bits1(&s->gb); 
2310
        s->h263_long_vectors = s->unrestricted_mv;
2311

    
2312
        if (get_bits1(&s->gb) != 0)
2313
            return -1;        /* SAC: off */
2314
        if (get_bits1(&s->gb) != 0) {
2315
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
2316
        }   
2317
        
2318
        if (get_bits1(&s->gb) != 0)
2319
            return -1;        /* not PB frame */
2320

    
2321
        s->qscale = get_bits(&s->gb, 5);
2322
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
2323
    } else {
2324
        int ufep;
2325
        
2326
        /* H.263v2 */
2327
        s->h263_plus = 1;
2328
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
2329
        
2330
        if (ufep == 1) {
2331
            /* OPPTYPE */       
2332
            format = get_bits(&s->gb, 3);
2333
            skip_bits(&s->gb,1); /* Custom PCF */
2334
            s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
2335
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
2336
            if (get_bits1(&s->gb) != 0) {
2337
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
2338
            }
2339
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
2340
                s->h263_aic = 1;
2341
            }
2342
            skip_bits(&s->gb, 7);
2343
            skip_bits(&s->gb, 3); /* Reserved */
2344
        } else if (ufep != 0)
2345
            return -1;
2346
            
2347
        /* MPPTYPE */
2348
        s->pict_type = get_bits(&s->gb, 3) + 1;
2349
        if (s->pict_type != I_TYPE &&
2350
            s->pict_type != P_TYPE)
2351
            return -1;
2352
        skip_bits(&s->gb, 2);
2353
        s->no_rounding = get_bits1(&s->gb);
2354
        //fprintf(stderr, "\nRTYPE: %d", s->no_rounding);
2355
        skip_bits(&s->gb, 4);
2356
        
2357
        /* Get the picture dimensions */
2358
        if (ufep) {
2359
            if (format == 6) {
2360
                /* Custom Picture Format (CPFMT) */
2361
                skip_bits(&s->gb, 4); /* aspect ratio */
2362
                width = (get_bits(&s->gb, 9) + 1) * 4;
2363
                skip_bits1(&s->gb);
2364
                height = get_bits(&s->gb, 9) * 4;
2365
#ifdef DEBUG 
2366
                fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);
2367
#endif            
2368
            }
2369
            else {
2370
                width = h263_format[format][0];
2371
                height = h263_format[format][1];
2372
            }
2373
            if ((width == 0) || (height == 0))
2374
                return -1;
2375
            s->width = width;
2376
            s->height = height;
2377
            if (s->umvplus_dec) {
2378
                skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
2379
            }
2380
        }
2381
            
2382
        s->qscale = get_bits(&s->gb, 5);
2383
    }
2384
    /* PEI */
2385
    while (get_bits1(&s->gb) != 0) {
2386
        skip_bits(&s->gb, 8);
2387
    }
2388
    s->f_code = 1;
2389
    return 0;
2390
}
2391

    
2392
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
2393
{
2394
    int i;
2395
    int a= 2<<s->sprite_warping_accuracy;
2396
    int rho= 3-s->sprite_warping_accuracy;
2397
    int r=16/a;
2398
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
2399
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
2400
    int sprite_ref[4][2];
2401
    int virtual_ref[2][2];
2402
    int w2, h2;
2403
    int alpha=0, beta=0;
2404
    int w= s->width;
2405
    int h= s->height;
2406
//printf("SP %d\n", s->sprite_warping_accuracy);
2407
    for(i=0; i<s->num_sprite_warping_points; i++){
2408
        int length;
2409
        int x=0, y=0;
2410

    
2411
        length= get_vlc(&s->gb, &sprite_trajectory);
2412
        if(length){
2413
            x= get_bits(&s->gb, length);
2414
//printf("lx %d %d\n", length, x);
2415
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
2416
                x = - (x ^ ((1 << length) - 1));
2417
        }
2418
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
2419
        
2420
        length= get_vlc(&s->gb, &sprite_trajectory);
2421
        if(length){
2422
            y=get_bits(&s->gb, length);
2423
//printf("ly %d %d\n", length, y);
2424
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
2425
                y = - (y ^ ((1 << length) - 1));
2426
        }
2427
        skip_bits1(&s->gb); /* marker bit */
2428
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
2429
//if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
2430
//x=y=0;
2431
        d[i][0]= x;
2432
        d[i][1]= y;
2433
    }
2434

    
2435
    while((1<<alpha)<w) alpha++;
2436
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
2437
    w2= 1<<alpha;
2438
    h2= 1<<beta;
2439

    
2440
// Note, the 4th point isnt used for GMC
2441
    if(s->divx_version==500 && s->divx_build==413){
2442
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
2443
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
2444
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
2445
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
2446
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
2447
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
2448
    } else {
2449
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
2450
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
2451
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
2452
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
2453
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
2454
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
2455
    }
2456
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
2457
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
2458
    
2459
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
2460
// perhaps it should be reordered to be more readable ...
2461
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
2462
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
2463
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
2464
        + 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);
2465
    virtual_ref[0][1]= 16*vop_ref[0][1] 
2466
        + 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);
2467
    virtual_ref[1][0]= 16*vop_ref[0][0] 
2468
        + 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);
2469
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
2470
        + 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);
2471

    
2472
    switch(s->num_sprite_warping_points)
2473
    {
2474
        case 0:
2475
            s->sprite_offset[0][0]= 0;
2476
            s->sprite_offset[0][1]= 0;
2477
            s->sprite_offset[1][0]= 0;
2478
            s->sprite_offset[1][1]= 0;
2479
            s->sprite_delta[0][0][0]= a;
2480
            s->sprite_delta[0][0][1]= 0;
2481
            s->sprite_delta[0][1][0]= 0;
2482
            s->sprite_delta[0][1][1]= a;
2483
            s->sprite_delta[1][0][0]= a;
2484
            s->sprite_delta[1][0][1]= 0;
2485
            s->sprite_delta[1][1][0]= 0;
2486
            s->sprite_delta[1][1][1]= a;
2487
            s->sprite_shift[0][0]= 0;
2488
            s->sprite_shift[0][1]= 0;
2489
            s->sprite_shift[1][0]= 0;
2490
            s->sprite_shift[1][1]= 0;
2491
            break;
2492
        case 1: //GMC only
2493
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
2494
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
2495
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
2496
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
2497
            s->sprite_delta[0][0][0]= a;
2498
            s->sprite_delta[0][0][1]= 0;
2499
            s->sprite_delta[0][1][0]= 0;
2500
            s->sprite_delta[0][1][1]= a;
2501
            s->sprite_delta[1][0][0]= a;
2502
            s->sprite_delta[1][0][1]= 0;
2503
            s->sprite_delta[1][1][0]= 0;
2504
            s->sprite_delta[1][1][1]= a;
2505
            s->sprite_shift[0][0]= 0;
2506
            s->sprite_shift[0][1]= 0;
2507
            s->sprite_shift[1][0]= 0;
2508
            s->sprite_shift[1][1]= 0;
2509
            break;
2510
        case 2:
2511
        case 3: //FIXME
2512
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
2513
                                                  + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
2514
                                                    +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
2515
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
2516
                                                  + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
2517
                                                    +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
2518
            s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
2519
                                 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
2520
                                 +2*w2*r*sprite_ref[0][0] - 16*w2);
2521
            s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
2522
                                 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
2523
                                 +2*w2*r*sprite_ref[0][1] - 16*w2);
2524
            s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2525
            s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);
2526
            s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
2527
            s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2528
            s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2529
            s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
2530
            s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
2531
            s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2532
            s->sprite_shift[0][0]= alpha+rho;
2533
            s->sprite_shift[0][1]= alpha+rho;
2534
            s->sprite_shift[1][0]= alpha+rho+2;
2535
            s->sprite_shift[1][1]= alpha+rho+2;
2536
            break;
2537
//        case 3:
2538
            break;
2539
    }
2540
/*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
2541
printf("%d %d\n", s->sprite_delta[0][0][1], 0);
2542
printf("%d %d\n", s->sprite_delta[0][1][0], 0);
2543
printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
2544
printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
2545
printf("%d %d\n", s->sprite_delta[1][0][1], 0);
2546
printf("%d %d\n", s->sprite_delta[1][1][0], 0);
2547
printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
2548
    /* try to simplify the situation */ 
2549
    if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
2550
       && s->sprite_delta[0][0][1] == 0
2551
       && s->sprite_delta[0][1][0] == 0
2552
       && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
2553
       && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
2554
       && s->sprite_delta[1][0][1] == 0
2555
       && s->sprite_delta[1][1][0] == 0
2556
       && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
2557
    {
2558
        s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
2559
        s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
2560
        s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
2561
        s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
2562
        s->sprite_delta[0][0][0]= a;
2563
        s->sprite_delta[0][0][1]= 0;
2564
        s->sprite_delta[0][1][0]= 0;
2565
        s->sprite_delta[0][1][1]= a;
2566
        s->sprite_delta[1][0][0]= a;
2567
        s->sprite_delta[1][0][1]= 0;
2568
        s->sprite_delta[1][1][0]= 0;
2569
        s->sprite_delta[1][1][1]= a;
2570
        s->sprite_shift[0][0]= 0;
2571
        s->sprite_shift[0][1]= 0;
2572
        s->sprite_shift[1][0]= 0;
2573
        s->sprite_shift[1][1]= 0;
2574
        s->real_sprite_warping_points=1;
2575
    }
2576
    else
2577
        s->real_sprite_warping_points= s->num_sprite_warping_points;
2578

    
2579
//printf("%d %d %d %d\n", d[0][0], d[0][1], s->sprite_offset[0][0], s->sprite_offset[0][1]);
2580
}
2581

    
2582
/* decode mpeg4 VOP header */
2583
int mpeg4_decode_picture_header(MpegEncContext * s)
2584
{
2585
    int time_incr, startcode, state, v;
2586
    int time_increment;
2587
    int vol_control=-1;
2588

    
2589
 redo:
2590
    /* search next start code */
2591
    align_get_bits(&s->gb);
2592
    state = 0xff;
2593
    for(;;) {
2594
        v = get_bits(&s->gb, 8);
2595
        if (state == 0x000001) {
2596
            state = ((state << 8) | v) & 0xffffff;
2597
            startcode = state;
2598
            break;
2599
        }
2600
        state = ((state << 8) | v) & 0xffffff;
2601
        if( get_bits_count(&s->gb) > s->gb.size*8-32){
2602
            if(s->gb.size>50){
2603
                printf("no VOP startcode found, frame size was=%d\n", s->gb.size);
2604
                return -1;
2605
            }else{
2606
                printf("frame skip\n");
2607
                return FRAME_SKIPED;
2608
            }
2609
        }
2610
    }
2611
//printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
2612
    if (startcode == 0x120) { // Video Object Layer
2613
        int width, height, vo_ver_id;
2614

    
2615
        /* vol header */
2616
        skip_bits(&s->gb, 1); /* random access */
2617
        s->vo_type= get_bits(&s->gb, 8);
2618
        if (get_bits1(&s->gb) != 0) { /* is_ol_id */
2619
            vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
2620
            skip_bits(&s->gb, 3); /* vo_priority */
2621
        } else {
2622
            vo_ver_id = 1;
2623
        }
2624
//printf("vo type:%d\n",s->vo_type);
2625
        s->aspect_ratio_info= get_bits(&s->gb, 4);
2626
        if(s->aspect_ratio_info == EXTENDET_PAR){
2627
            skip_bits(&s->gb, 8); //par_width
2628
            skip_bits(&s->gb, 8); // par_height
2629
        }
2630

    
2631
        if(vol_control=get_bits1(&s->gb)){ /* vol control parameter */
2632
            int chroma_format= get_bits(&s->gb, 2);
2633
            if(chroma_format!=1){
2634
                printf("illegal chroma format\n");
2635
            }
2636
            s->low_delay= get_bits1(&s->gb);
2637
            if(get_bits1(&s->gb)){ /* vbv parameters */
2638
                printf("vbv parameters not supported\n");
2639
                return -1;
2640
            }
2641
        }else{
2642
            s->low_delay=0;
2643
        }
2644

    
2645
        s->shape = get_bits(&s->gb, 2); /* vol shape */
2646
        if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
2647
        if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
2648
            printf("Gray shape not supported\n");
2649
            skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
2650
        }
2651

    
2652
        skip_bits1(&s->gb);   /* marker */
2653
        
2654
        s->time_increment_resolution = get_bits(&s->gb, 16);
2655
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
2656
        if (s->time_increment_bits < 1)
2657
            s->time_increment_bits = 1;
2658
        skip_bits1(&s->gb);   /* marker */
2659

    
2660
        if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
2661
            skip_bits(&s->gb, s->time_increment_bits);
2662
        }
2663

    
2664
        if (s->shape != BIN_ONLY_SHAPE) {
2665
            if (s->shape == RECT_SHAPE) {
2666
                skip_bits1(&s->gb);   /* marker */
2667
                width = get_bits(&s->gb, 13);
2668
                skip_bits1(&s->gb);   /* marker */
2669
                height = get_bits(&s->gb, 13);
2670
                skip_bits1(&s->gb);   /* marker */
2671
                if(width && height){ /* they should be non zero but who knows ... */
2672
                    s->width = width;
2673
                    s->height = height;
2674
//                    printf("width/height: %d %d\n", width, height);
2675
                }
2676
            }
2677
            
2678
            if(get_bits1(&s->gb)) printf("interlaced not supported\n");   /* interlaced */
2679
            if(!get_bits1(&s->gb)) printf("OBMC not supported\n");   /* OBMC Disable */
2680
            if (vo_ver_id == 1) {
2681
                s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
2682
            } else {
2683
                s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
2684
            }
2685
            if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
2686
            if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
2687
                if(s->vol_sprite_usage==STATIC_SPRITE){
2688
                    s->sprite_width = get_bits(&s->gb, 13);
2689
                    skip_bits1(&s->gb); /* marker */
2690
                    s->sprite_height= get_bits(&s->gb, 13);
2691
                    skip_bits1(&s->gb); /* marker */
2692
                    s->sprite_left  = get_bits(&s->gb, 13);
2693
                    skip_bits1(&s->gb); /* marker */
2694
                    s->sprite_top   = get_bits(&s->gb, 13);
2695
                    skip_bits1(&s->gb); /* marker */
2696
                }
2697
                s->num_sprite_warping_points= get_bits(&s->gb, 6);
2698
                s->sprite_warping_accuracy = get_bits(&s->gb, 2);
2699
                s->sprite_brightness_change= get_bits1(&s->gb);
2700
                if(s->vol_sprite_usage==STATIC_SPRITE)
2701
                    s->low_latency_sprite= get_bits1(&s->gb);            
2702
            }
2703
            // FIXME sadct disable bit if verid!=1 && shape not rect
2704
            
2705
            if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
2706
                s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
2707
                if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
2708
                if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
2709
            } else {
2710
                s->quant_precision = 5;
2711
            }
2712
            
2713
            // FIXME a bunch of grayscale shape things
2714

    
2715
            if(get_bits1(&s->gb)){ /* vol_quant_type */
2716
                int i, j, v;
2717
                /* load default matrixes */
2718
                for(i=0; i<64; i++){
2719
                    v= ff_mpeg4_default_intra_matrix[i];
2720
                    s->intra_matrix[i]= v;
2721
                    s->chroma_intra_matrix[i]= v;
2722
                    
2723
                    v= ff_mpeg4_default_non_intra_matrix[i];
2724
                    s->inter_matrix[i]= v;
2725
                    s->chroma_inter_matrix[i]= v;
2726
                }
2727

    
2728
                /* load custom intra matrix */
2729
                if(get_bits1(&s->gb)){
2730
                    for(i=0; i<64; i++){
2731
                        v= get_bits(&s->gb, 8);
2732
                        if(v==0) break;
2733

    
2734
                        j= zigzag_direct[i];
2735
                        s->intra_matrix[j]= v;
2736
                        s->chroma_intra_matrix[j]= v;
2737
                    }
2738
                }
2739

    
2740
                /* load custom non intra matrix */
2741
                if(get_bits1(&s->gb)){
2742
                    for(i=0; i<64; i++){
2743
                        v= get_bits(&s->gb, 8);
2744
                        if(v==0) break;
2745

    
2746
                        j= zigzag_direct[i];
2747
                        s->inter_matrix[j]= v;
2748
                        s->chroma_inter_matrix[j]= v;
2749
                    }
2750

    
2751
                    /* replicate last value */
2752
                    for(; i<64; i++){
2753
                        j= zigzag_direct[i];
2754
                        s->inter_matrix[j]= v;
2755
                        s->chroma_inter_matrix[j]= v;
2756
                    }
2757
                }
2758

    
2759
                s->dct_unquantize= s->dct_unquantize_mpeg2;
2760

    
2761
                // FIXME a bunch of grayscale shape things
2762
            }else
2763
                s->dct_unquantize= s->dct_unquantize_h263;
2764

    
2765
            if(vo_ver_id != 1)
2766
                 s->quarter_sample= get_bits1(&s->gb);
2767
            else s->quarter_sample=0;
2768

    
2769
            if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
2770

    
2771
            s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */
2772

    
2773
            s->data_partioning= get_bits1(&s->gb);
2774
            if(s->data_partioning){
2775
                printf("data partitioning not supported\n");
2776
                skip_bits1(&s->gb); // reversible vlc
2777
            }
2778
            
2779
            if(vo_ver_id != 1) {
2780
                s->new_pred= get_bits1(&s->gb);
2781
                if(s->new_pred){
2782
                    printf("new pred not supported\n");
2783
                    skip_bits(&s->gb, 2); /* requested upstream message type */
2784
                    skip_bits1(&s->gb); /* newpred segment type */
2785
                }
2786
                s->reduced_res_vop= get_bits1(&s->gb);
2787
                if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
2788
            }
2789
            else{
2790
                s->new_pred=0;
2791
                s->reduced_res_vop= 0;
2792
            }
2793

    
2794
            s->scalability= get_bits1(&s->gb);
2795
            if (s->scalability) {
2796
                printf("scalability not supported\n");
2797
            }
2798
        }
2799
//printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
2800
        goto redo;
2801
    } else if (startcode == 0x1b2) { //userdata
2802
        char buf[256];
2803
        int i;
2804
        int e;
2805
        int ver, build;
2806

    
2807
//printf("user Data %X\n", show_bits(&s->gb, 32));
2808
        buf[0]= show_bits(&s->gb, 8);
2809
        for(i=1; i<256; i++){
2810
            buf[i]= show_bits(&s->gb, 16)&0xFF;
2811
            if(buf[i]==0) break;
2812
            skip_bits(&s->gb, 8);
2813
        }
2814
        buf[255]=0;
2815
        e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
2816
        if(e!=2)
2817
            e=sscanf(buf, "DivX%db%d", &ver, &build);
2818
        if(e==2){
2819
            s->divx_version= ver;
2820
            s->divx_build= build;
2821
            if(s->picture_number==0){
2822
                printf("This file was encoded with DivX%d Build%d\n", ver, build);
2823
                if(ver==500 && build==413){
2824
                    printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
2825
#if 0
2826
                }else{
2827
                    printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
2828
                           "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
2829
#endif 
2830
                }
2831
            }
2832
        }
2833
//printf("User Data: %s\n", buf);
2834
        goto redo;
2835
    } else if (startcode != 0x1b6) { //VOP
2836
        goto redo;
2837
    }
2838

    
2839
    s->pict_type = get_bits(&s->gb, 2) + 1;        /* pict type: I = 0 , P = 1 */
2840
// printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample); 
2841
    time_incr=0;
2842
    while (get_bits1(&s->gb) != 0) 
2843
        time_incr++;
2844

    
2845
    check_marker(&s->gb, "before time_increment");
2846
    time_increment= get_bits(&s->gb, s->time_increment_bits);
2847
//printf(" type:%d incr:%d increment:%d\n", s->pict_type, time_incr, time_increment);
2848
    if(s->pict_type!=B_TYPE){
2849
        s->last_time_base= s->time_base;
2850
        s->time_base+= time_incr;
2851
        s->time= s->time_base*s->time_increment_resolution + time_increment;
2852
        s->pp_time= s->time - s->last_non_b_time;
2853
        s->last_non_b_time= s->time;
2854
    }else{
2855
        s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
2856
        s->bp_time= s->last_non_b_time - s->time;
2857
        if(s->pp_time <=s->bp_time){
2858
//            printf("messed up order, seeking?, skiping current b frame\n");
2859
            return FRAME_SKIPED;
2860
        }
2861
    }
2862

    
2863
    if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
2864
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
2865
        for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
2866
            if(get_bits1(&s->gb)) break;
2867
        }
2868
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
2869
    }
2870
    /* vop coded */
2871
    if (get_bits1(&s->gb) != 1)
2872
        goto redo;
2873
//printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
2874
//s->time, s->last_non_b_time[0], s->last_non_b_time[1]);  
2875
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
2876
                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
2877
        /* rounding type for motion estimation */
2878
        s->no_rounding = get_bits1(&s->gb);
2879
    } else {
2880
        s->no_rounding = 0;
2881
    }
2882
//FIXME reduced res stuff
2883

    
2884
     if (s->shape != RECT_SHAPE) {
2885
         if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
2886
             int width, height, hor_spat_ref, ver_spat_ref;
2887
 
2888
             width = get_bits(&s->gb, 13);
2889
             skip_bits1(&s->gb);   /* marker */
2890
             height = get_bits(&s->gb, 13);
2891
             skip_bits1(&s->gb);   /* marker */
2892
             hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
2893
             skip_bits1(&s->gb);   /* marker */
2894
             ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
2895
         }
2896
         skip_bits1(&s->gb); /* change_CR_disable */
2897
 
2898
         if (get_bits1(&s->gb) != 0) {
2899
             skip_bits(&s->gb, 8); /* constant_alpha_value */
2900
         }
2901
     }
2902
//FIXME complexity estimation stuff
2903
     
2904
     if (s->shape != BIN_ONLY_SHAPE) {
2905
         int t;
2906
         t=get_bits(&s->gb, 3); /* intra dc VLC threshold */
2907
//printf("threshold %d\n", t);
2908
         //FIXME interlaced specific bits
2909
     }
2910

    
2911
     if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
2912
         if(s->num_sprite_warping_points){
2913
             mpeg4_decode_sprite_trajectory(s);
2914
         }
2915
         if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
2916
         if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
2917
     }
2918

    
2919
     if (s->shape != BIN_ONLY_SHAPE) {
2920
         /* note: we do not use quant_precision to avoid problem if no
2921
            MPEG4 vol header as it is found on some old opendivx
2922
            movies */
2923
         s->qscale = get_bits(&s->gb, 5);
2924
         if(s->qscale==0){
2925
             printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
2926
             return -1; // makes no sense to continue, as there is nothing left from the image then
2927
         }
2928
  
2929
         if (s->pict_type != I_TYPE) {
2930
             s->f_code = get_bits(&s->gb, 3);        /* fcode_for */
2931
             if(s->f_code==0){
2932
                 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
2933
                 return -1; // makes no sense to continue, as the MV decoding will break very quickly
2934
             }
2935
         }
2936
         if (s->pict_type == B_TYPE) {
2937
             s->b_code = get_bits(&s->gb, 3);
2938
//printf("b-code %d\n", s->b_code);
2939
         }
2940
//printf("quant:%d fcode:%d bcode:%d type:%d\n", s->qscale, s->f_code, s->b_code, s->pict_type);
2941
         if(!s->scalability){
2942
             if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
2943
                 skip_bits1(&s->gb); // vop shape coding type
2944
             }
2945
         }
2946
     }
2947
     /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
2948
     // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
2949
     if(s->vo_type==0 && vol_control==0 && s->divx_version==0){
2950
         if(s->picture_number==0)
2951
             printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
2952
         s->low_delay=1;
2953
     }
2954

    
2955
     s->picture_number++; // better than pic number==0 allways ;)
2956
//printf("done\n");
2957

    
2958
     return 0;
2959
}
2960

    
2961
/* don't understand why they choose a different header ! */
2962
int intel_h263_decode_picture_header(MpegEncContext *s)
2963
{
2964
    int format;
2965

    
2966
    /* picture header */
2967
    if (get_bits(&s->gb, 22) != 0x20)
2968
        return -1;
2969
    skip_bits(&s->gb, 8); /* picture timestamp */
2970

    
2971
    if (get_bits1(&s->gb) != 1)
2972
        return -1;        /* marker */
2973
    if (get_bits1(&s->gb) != 0)
2974
        return -1;        /* h263 id */
2975
    skip_bits1(&s->gb);        /* split screen off */
2976
    skip_bits1(&s->gb);        /* camera  off */
2977
    skip_bits1(&s->gb);        /* freeze picture release off */
2978

    
2979
    format = get_bits(&s->gb, 3);
2980
    if (format != 7)
2981
        return -1;
2982

    
2983
    s->h263_plus = 0;
2984

    
2985
    s->pict_type = I_TYPE + get_bits1(&s->gb);
2986
    
2987
    s->unrestricted_mv = get_bits1(&s->gb); 
2988
    s->h263_long_vectors = s->unrestricted_mv;
2989

    
2990
    if (get_bits1(&s->gb) != 0)
2991
        return -1;        /* SAC: off */
2992
    if (get_bits1(&s->gb) != 0)
2993
        return -1;        /* advanced prediction mode: off */
2994
    if (get_bits1(&s->gb) != 0)
2995
        return -1;        /* not PB frame */
2996

    
2997
    /* skip unknown header garbage */
2998
    skip_bits(&s->gb, 41);
2999

    
3000
    s->qscale = get_bits(&s->gb, 5);
3001
    skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
3002

    
3003
    /* PEI */
3004
    while (get_bits1(&s->gb) != 0) {
3005
        skip_bits(&s->gb, 8);
3006
    }
3007
    s->f_code = 1;
3008
    return 0;
3009
}
3010