Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ eec1c6b9

History | View | Annotate | Download (97.7 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= s->coded_order[i+1].picture[0] + offset;
363
                        int diff= pix_abs16x16(p_pic, b_pic, s->linesize);
364
                        if(diff>s->qscale*70){
365
                            s->mb_skiped=0;
366
                            break;
367
                        }
368
                    }
369
                }else
370
                    s->mb_skiped=1; 
371

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

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

    
409
                bits= get_bit_count(&s->pb);
410
                s->misc_bits+= bits - s->last_bits;
411
                s->last_bits=bits;
412

    
413
                for(i=0; i<4; i++){
414
                    /* motion vectors: 8x8 mode*/
415
                    h263_pred_motion(s, i, &pred_x, &pred_y);
416

    
417
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
418
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
419
                }
420
            }
421
            bits= get_bit_count(&s->pb);
422
            s->mv_bits+= bits - s->last_bits;
423
            s->last_bits=bits;
424

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

    
441
        for(i=0; i<6; i++){
442
            const int level= block[i][0];
443
            UINT16 *dc_ptr;
444

    
445
            dc_diff[i]= level - mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
446
            if (i < 4) {
447
                *dc_ptr = level * s->y_dc_scale;
448
            } else {
449
                *dc_ptr = level * s->c_dc_scale;
450
            }
451
        }
452

    
453
        s->ac_pred= decide_ac_pred(s, block, dir);
454

    
455
        if(s->ac_pred){
456
            for(i=0; i<6; i++){
457
                UINT8 *st;
458
                int last_index;
459

    
460
                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
461
                if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
462
                else           st = ff_alternate_horizontal_scan; /* top */
463

    
464
                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
465
                    if(block[i][st[last_index]]) break;
466
                zigzag_last_index[i]= s->block_last_index[i];
467
                s->block_last_index[i]= last_index;
468
                scan_table[i]= st;
469
            }
470
        }else{
471
            for(i=0; i<6; i++)
472
                scan_table[i]= zigzag_direct;
473
        }
474

    
475
        /* compute cbp */
476
        cbp = 0;
477
        for (i = 0; i < 6; i++) {
478
            if (s->block_last_index[i] >= 1)
479
                cbp |= 1 << (5 - i);
480
        }
481

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

    
497
        bits= get_bit_count(&s->pb);
498
        s->misc_bits+= bits - s->last_bits;
499
        s->last_bits=bits;
500

    
501
        /* encode each block */
502
        for (i = 0; i < 6; i++) {
503
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i]);
504
        }
505

    
506
        bits= get_bit_count(&s->pb);
507
        s->i_tex_bits+= bits - s->last_bits;
508
        s->last_bits=bits;
509
        s->i_count++;
510

    
511
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
512
        if(s->ac_pred){
513
            for(i=0; i<6; i++){
514
                int j;    
515
                INT16 *ac_val;
516

    
517
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
518

    
519
                if(dir[i]){
520
                    for(j=1; j<8; j++) 
521
                        block[i][block_permute_op(j   )]= ac_val[j+8];
522
                }else{
523
                    for(j=1; j<8; j++) 
524
                        block[i][block_permute_op(j<<3)]= ac_val[j  ];
525
                }
526
                s->block_last_index[i]= zigzag_last_index[i];
527
            }
528
        }
529
    }
530
}
531

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

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

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

    
601
    /* encode each block */
602
    for (i = 0; i < 6; i++) {
603
        h263_encode_block(s, block[i], i);
604
    }
605
}
606

    
607
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
608
{
609
    int x, y, wrap, a, c, pred_dc, scale, i;
610
    INT16 *dc_val, *ac_val, *ac_val1;
611

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

    
688
INT16 *h263_pred_motion(MpegEncContext * s, int block, 
689
                        int *px, int *py)
690
{
691
    int xy, wrap;
692
    INT16 *A, *B, *C, *mot_val;
693
    static const int off[4]= {2, 1, 1, -1};
694

    
695
    wrap = s->block_wrap[0];
696
    xy = s->block_index[block];
697

    
698
    mot_val = s->motion_val[xy];
699

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

    
715
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
716
{
717
    int range, l, m, bit_size, sign, code, bits;
718

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

    
735
        if (val >= 0) {
736
            sign = 0;
737
        } else {
738
            val = -val;
739
            sign = 1;
740
        }
741
        val--;
742
        code = (val >> bit_size) + 1;
743
        bits = val & (range - 1);
744

    
745
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
746
        if (bit_size > 0) {
747
            put_bits(&s->pb, bit_size, bits);
748
        }
749
    }
750
}
751

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

    
791
static void init_mv_penalty_and_fcode(MpegEncContext *s)
792
{
793
    int f_code;
794
    int mv;
795
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
796
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
797
            int len;
798

    
799
            if(mv==0) len= mvtab[0][1];
800
            else{
801
                int val, bit_size, range, code;
802

    
803
                bit_size = s->f_code - 1;
804
                range = 1 << bit_size;
805

    
806
                val=mv;
807
                if (val < 0) 
808
                    val = -val;
809
                val--;
810
                code = (val >> bit_size) + 1;
811
                if(code<33){
812
                    len= mvtab[code][1] + 1 + bit_size;
813
                }else{
814
                    len= mvtab[32][1] + 2 + bit_size;
815
                }
816
            }
817

    
818
            mv_penalty[f_code][mv+MAX_MV]= len;
819
        }
820
    }
821

    
822
    for(f_code=MAX_FCODE; f_code>0; f_code--){
823
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
824
            fcode_tab[mv+MAX_MV]= f_code;
825
        }
826
    }
827

    
828
    for(mv=0; mv<MAX_MV*2+1; mv++){
829
        umv_fcode_tab[mv]= 1;
830
    }
831
}
832

    
833
static void init_uni_dc_tab()
834
{
835
    int level, uni_code, uni_len;
836

    
837
    for(level=-256; level<256; level++){
838
        int size, v, l;
839
        /* find number of bits */
840
        size = 0;
841
        v = abs(level);
842
        while (v) {
843
            v >>= 1;
844
            size++;
845
        }
846

    
847
        if (level < 0)
848
            l= (-level) ^ ((1 << size) - 1);
849
        else
850
            l= level;
851

    
852
        /* luminance */
853
        uni_code= DCtab_lum[size][0];
854
        uni_len = DCtab_lum[size][1];
855

    
856
        if (size > 0) {
857
            uni_code<<=size; uni_code|=l;
858
            uni_len+=size;
859
            if (size > 8){
860
                uni_code<<=1; uni_code|=1;
861
                uni_len++;
862
            }
863
        }
864
        uni_DCtab_lum[level+256][0]= uni_code;
865
        uni_DCtab_lum[level+256][1]= uni_len;
866

    
867
        /* chrominance */
868
        uni_code= DCtab_chrom[size][0];
869
        uni_len = DCtab_chrom[size][1];
870
        
871
        if (size > 0) {
872
            uni_code<<=size; uni_code|=l;
873
            uni_len+=size;
874
            if (size > 8){
875
                uni_code<<=1; uni_code|=1;
876
                uni_len++;
877
            }
878
        }
879
        uni_DCtab_chrom[level+256][0]= uni_code;
880
        uni_DCtab_chrom[level+256][1]= uni_len;
881

    
882
    }
883
}
884

    
885
void h263_encode_init(MpegEncContext *s)
886
{
887
    static int done = 0;
888

    
889
    if (!done) {
890
        done = 1;
891

    
892
        init_uni_dc_tab();
893

    
894
        init_rl(&rl_inter);
895
        init_rl(&rl_intra);
896

    
897
        init_mv_penalty_and_fcode(s);
898
    }
899
    s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
900
    
901
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
902
    if(s->h263_plus) s->fcode_tab= umv_fcode_tab;
903
    else if(s->h263_pred && !s->h263_msmpeg4) s->fcode_tab= fcode_tab;
904
}
905

    
906
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
907
{
908
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
909
    int code;
910
    RLTable *rl = &rl_inter;
911

    
912
    if (s->mb_intra) {
913
        /* DC coef */
914
            level = block[0];
915
        /* 255 cannot be represented, so we clamp */
916
        if (level > 254) {
917
            level = 254;
918
            block[0] = 254;
919
        }
920
        /* 0 cannot be represented also */
921
        else if (!level) {
922
            level = 1;
923
            block[0] = 1;
924
        }
925
            if (level == 128)
926
                put_bits(&s->pb, 8, 0xff);
927
            else
928
                put_bits(&s->pb, 8, level & 0xff);
929
            i = 1;
930
    } else {
931
            i = 0;
932
    }
933

    
934
    /* AC coefs */
935
    last_index = s->block_last_index[n];
936
    last_non_zero = i - 1;
937
    for (; i <= last_index; i++) {
938
        j = zigzag_direct[i];
939
        level = block[j];
940
        if (level) {
941
            run = i - last_non_zero - 1;
942
            last = (i == last_index);
943
            sign = 0;
944
            slevel = level;
945
            if (level < 0) {
946
                sign = 1;
947
                level = -level;
948
            }
949
            code = get_rl_index(rl, last, run, level);
950
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
951
            if (code == rl->n) {
952
                put_bits(&s->pb, 1, last);
953
                put_bits(&s->pb, 6, run);
954
                put_bits(&s->pb, 8, slevel & 0xff);
955
            } else {
956
                put_bits(&s->pb, 1, sign);
957
            }
958
            last_non_zero = i;
959
        }
960
    }
961
}
962

    
963
/***************************************************/
964

    
965
static void mpeg4_stuffing(PutBitContext * pbc)
966
{
967
    int length;
968
    put_bits(pbc, 1, 0);
969
    length= (-get_bit_count(pbc))&7;
970
    put_bits(pbc, length, (1<<length)-1);
971
}
972

    
973
static void put_string(PutBitContext * pbc, char *s)
974
{
975
    while(*s){
976
        put_bits(pbc, 8, *s);
977
        s++;
978
    }
979
    put_bits(pbc, 8, 0);
980
}
981

    
982
/* must be called before writing the header */
983
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
984
    int time_div, time_mod;
985

    
986
    if(s->pict_type==I_TYPE){ //we will encode a vol header
987
        s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
988
        if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
989

    
990
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
991
    }
992

    
993
    s->time= picture_number*(int64_t)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
994
    time_div= s->time/s->time_increment_resolution;
995
    time_mod= s->time%s->time_increment_resolution;
996

    
997
    if(s->pict_type==B_TYPE){
998
        s->bp_time= s->last_non_b_time - s->time;
999
    }else{
1000
        s->last_time_base= s->time_base;
1001
        s->time_base= time_div;
1002
        s->pp_time= s->time - s->last_non_b_time;
1003
        s->last_non_b_time= s->time;
1004
    }
1005
}
1006

    
1007
static void mpeg4_encode_vol_header(MpegEncContext * s)
1008
{
1009
    int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1010
    char buf[255];
1011
    
1012
    if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
1013
    put_bits(&s->pb, 16, 0);
1014
    put_bits(&s->pb, 16, 0x100);        /* video obj */
1015
    put_bits(&s->pb, 16, 0);
1016
    put_bits(&s->pb, 16, 0x120);        /* video obj layer */
1017

    
1018
    put_bits(&s->pb, 1, 0);                /* random access vol */
1019
    put_bits(&s->pb, 8, 1);                /* video obj type indication= simple obj */
1020
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1021
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1022
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1023
    if(s->aspect_ratio_info) 
1024
        put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1025
    else
1026
        put_bits(&s->pb, 4, 1);                /* aspect ratio info= sqare pixel */
1027
    put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1028
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1029
    put_bits(&s->pb, 1, 1);                /* marker bit */
1030
    
1031
    put_bits(&s->pb, 16, s->time_increment_resolution);
1032
    if (s->time_increment_bits < 1)
1033
        s->time_increment_bits = 1;
1034
    put_bits(&s->pb, 1, 1);                /* marker bit */
1035
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1036
    put_bits(&s->pb, 1, 1);                /* marker bit */
1037
    put_bits(&s->pb, 13, s->width);        /* vol width */
1038
    put_bits(&s->pb, 1, 1);                /* marker bit */
1039
    put_bits(&s->pb, 13, s->height);        /* vol height */
1040
    put_bits(&s->pb, 1, 1);                /* marker bit */
1041
    put_bits(&s->pb, 1, 0);                /* interlace */
1042
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1043
    if (vo_ver_id == 1) {
1044
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1045
    }else{ /* vo_ver_id == 2 */
1046
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1047
    }
1048
    put_bits(&s->pb, 1, 0);                /* not 8 bit */
1049
    put_bits(&s->pb, 1, 0);                /* quant type= h263 style*/
1050
    if (vo_ver_id != 1)
1051
        put_bits(&s->pb, 1, s->quarter_sample=0);
1052
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1053
    put_bits(&s->pb, 1, 1);                /* resync marker disable */
1054
    put_bits(&s->pb, 1, 0);                /* data partitioned */
1055
    if (vo_ver_id != 1){
1056
        put_bits(&s->pb, 1, 0);                /* newpred */
1057
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1058
    }
1059
    put_bits(&s->pb, 1, 0);                /* scalability */
1060

    
1061
    mpeg4_stuffing(&s->pb);
1062
    put_bits(&s->pb, 16, 0);
1063
    put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1064
    sprintf(buf, "FFmpeg v%s / libavcodec build: %s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1065
    put_string(&s->pb, buf);
1066

    
1067
    s->no_rounding = 0;
1068
}
1069

    
1070
/* write mpeg4 VOP header */
1071
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1072
{
1073
    int time_incr;
1074
    int time_div, time_mod;
1075
    
1076
    if(s->pict_type==I_TYPE) mpeg4_encode_vol_header(s);
1077
    
1078
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1079
    
1080
    if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
1081
    put_bits(&s->pb, 16, 0);                /* vop header */
1082
    put_bits(&s->pb, 16, 0x1B6);        /* vop header */
1083
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1084

    
1085
    time_div= s->time/s->time_increment_resolution;
1086
    time_mod= s->time%s->time_increment_resolution;
1087
    time_incr= time_div - s->last_time_base;
1088
    while(time_incr--)
1089
        put_bits(&s->pb, 1, 1);
1090
        
1091
    put_bits(&s->pb, 1, 0);
1092

    
1093
    put_bits(&s->pb, 1, 1);        /* marker */
1094
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1095
    put_bits(&s->pb, 1, 1);        /* marker */
1096
    put_bits(&s->pb, 1, 1);        /* vop coded */
1097
    if (    s->pict_type == P_TYPE 
1098
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1099
        s->no_rounding ^= 1;
1100
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1101
    }
1102
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1103
    //FIXME sprite stuff
1104

    
1105
    put_bits(&s->pb, 5, s->qscale);
1106

    
1107
    if (s->pict_type != I_TYPE)
1108
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1109
    if (s->pict_type == B_TYPE)
1110
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1111
    //    printf("****frame %d\n", picture_number);
1112
}
1113

    
1114
void h263_dc_scale(MpegEncContext * s)
1115
{
1116
#if 1
1117
    const static UINT8 y_tab[32]={
1118
    //  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
1119
        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
1120
    };
1121
    const static UINT8 c_tab[32]={
1122
    //  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
1123
        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
1124
    };
1125
    s->y_dc_scale = y_tab[s->qscale];
1126
    s->c_dc_scale = c_tab[s->qscale];
1127
#else
1128
    int quant;
1129
    quant = s->qscale;
1130
    /* luminance */
1131
    if (quant < 5)
1132
        s->y_dc_scale = 8;
1133
    else if (quant > 4 && quant < 9)
1134
        s->y_dc_scale = (2 * quant);
1135
    else if (quant > 8 && quant < 25)
1136
        s->y_dc_scale = (quant + 8);
1137
    else
1138
        s->y_dc_scale = (2 * quant - 16);
1139
    /* chrominance */
1140
    if (quant < 5)
1141
        s->c_dc_scale = 8;
1142
    else if (quant > 4 && quant < 25)
1143
        s->c_dc_scale = ((quant + 13) / 2);
1144
    else
1145
        s->c_dc_scale = (quant - 6);
1146
#endif
1147
}
1148

    
1149
static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1150
{
1151
    int a, b, c, wrap, pred, scale;
1152
    UINT16 *dc_val;
1153
    int dummy;
1154

    
1155
    /* find prediction */
1156
    if (n < 4) {
1157
        scale = s->y_dc_scale;
1158
    } else {
1159
        scale = s->c_dc_scale;
1160
    }
1161
    wrap= s->block_wrap[n];
1162
    dc_val = s->dc_val[0] + s->block_index[n];
1163

    
1164
    /* B C
1165
     * A X 
1166
     */
1167
    a = dc_val[ - 1];
1168
    b = dc_val[ - 1 - wrap];
1169
    c = dc_val[ - wrap];
1170

    
1171
    if (abs(a - b) < abs(b - c)) {
1172
        pred = c;
1173
        *dir_ptr = 1; /* top */
1174
    } else {
1175
        pred = a;
1176
        *dir_ptr = 0; /* left */
1177
    }
1178
    /* we assume pred is positive */
1179
#ifdef ARCH_X86
1180
        asm volatile (
1181
                "xorl %%edx, %%edx        \n\t"
1182
                "mul %%ecx                \n\t"
1183
                : "=d" (pred), "=a"(dummy)
1184
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1185
        );
1186
#else
1187
    pred = (pred + (scale >> 1)) / scale;
1188
#endif
1189

    
1190
    /* prepare address for prediction update */
1191
    *dc_val_ptr = &dc_val[0];
1192

    
1193
    return pred;
1194
}
1195

    
1196
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1197
                   int dir)
1198
{
1199
    int i;
1200
    INT16 *ac_val, *ac_val1;
1201

    
1202
    /* find prediction */
1203
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1204
    ac_val1 = ac_val;
1205
    if (s->ac_pred) {
1206
        if (dir == 0) {
1207
            /* left prediction */
1208
            ac_val -= 16;
1209
            for(i=1;i<8;i++) {
1210
                block[block_permute_op(i*8)] += ac_val[i];
1211
            }
1212
        } else {
1213
            /* top prediction */
1214
            ac_val -= 16 * s->block_wrap[n];
1215
            for(i=1;i<8;i++) {
1216
                block[block_permute_op(i)] += ac_val[i + 8];
1217
            }
1218
        }
1219
    }
1220
    /* left copy */
1221
    for(i=1;i<8;i++)
1222
        ac_val1[i] = block[block_permute_op(i * 8)];
1223
    /* top copy */
1224
    for(i=1;i<8;i++)
1225
        ac_val1[8 + i] = block[block_permute_op(i)];
1226
}
1227

    
1228
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1229
                              int dir)
1230
{
1231
    int i;
1232
    INT16 *ac_val;
1233

    
1234
    /* find prediction */
1235
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1236
 
1237
    if (dir == 0) {
1238
        /* left prediction */
1239
        ac_val -= 16;
1240
        for(i=1;i<8;i++) {
1241
            block[block_permute_op(i*8)] -= ac_val[i];
1242
        }
1243
    } else {
1244
        /* top prediction */
1245
        ac_val -= 16 * s->block_wrap[n];
1246
        for(i=1;i<8;i++) {
1247
            block[block_permute_op(i)] -= ac_val[i + 8];
1248
        }
1249
    }
1250
}
1251

    
1252
static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)
1253
{
1254
#if 1
1255
    level+=256;
1256
    if (n < 4) {
1257
        /* luminance */
1258
        put_bits(&s->pb, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1259
    } else {
1260
        /* chrominance */
1261
        put_bits(&s->pb, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1262
    }
1263
#else
1264
    int size, v;
1265
    /* find number of bits */
1266
    size = 0;
1267
    v = abs(level);
1268
    while (v) {
1269
        v >>= 1;
1270
        size++;
1271
    }
1272

    
1273
    if (n < 4) {
1274
        /* luminance */
1275
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1276
    } else {
1277
        /* chrominance */
1278
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1279
    }
1280

    
1281
    /* encode remaining bits */
1282
    if (size > 0) {
1283
        if (level < 0)
1284
            level = (-level) ^ ((1 << size) - 1);
1285
        put_bits(&s->pb, size, level);
1286
        if (size > 8)
1287
            put_bits(&s->pb, 1, 1);
1288
    }
1289
#endif
1290
}
1291

    
1292
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table)
1293
{
1294
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
1295
    int code;
1296
    const RLTable *rl;
1297

    
1298
    if (s->mb_intra) {
1299
        /* mpeg4 based DC predictor */
1300
        mpeg4_encode_dc(s, intra_dc, n);
1301
        i = 1;
1302
        rl = &rl_intra;
1303
    } else {
1304
        i = 0;
1305
        rl = &rl_inter;
1306
    }
1307

    
1308
    /* AC coefs */
1309
    last_index = s->block_last_index[n];
1310
    last_non_zero = i - 1;
1311
    for (; i <= last_index; i++) {
1312
        j = scan_table[i];
1313
        level = block[j];
1314
        if (level) {
1315
            run = i - last_non_zero - 1;
1316
            last = (i == last_index);
1317
            sign = 0;
1318
            slevel = level;
1319
            if (level < 0) {
1320
                sign = 1;
1321
                level = -level;
1322
            }
1323
            code = get_rl_index(rl, last, run, level);
1324
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1325
            if (code == rl->n) {
1326
                int level1, run1;
1327
                level1 = level - rl->max_level[last][run];
1328
                if (level1 < 1) 
1329
                    goto esc2;
1330
                code = get_rl_index(rl, last, run, level1);
1331
                if (code == rl->n) {
1332
                esc2:
1333
                    put_bits(&s->pb, 1, 1);
1334
                    if (level > MAX_LEVEL)
1335
                        goto esc3;
1336
                    run1 = run - rl->max_run[last][level] - 1;
1337
                    if (run1 < 0)
1338
                        goto esc3;
1339
                    code = get_rl_index(rl, last, run1, level);
1340
                    if (code == rl->n) {
1341
                    esc3:
1342
                        /* third escape */
1343
                        put_bits(&s->pb, 1, 1);
1344
                        put_bits(&s->pb, 1, last);
1345
                        put_bits(&s->pb, 6, run);
1346
                        put_bits(&s->pb, 1, 1);
1347
                        put_bits(&s->pb, 12, slevel & 0xfff);
1348
                        put_bits(&s->pb, 1, 1);
1349
                    } else {
1350
                        /* second escape */
1351
                        put_bits(&s->pb, 1, 0);
1352
                        put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1353
                        put_bits(&s->pb, 1, sign);
1354
                    }
1355
                } else {
1356
                    /* first escape */
1357
                    put_bits(&s->pb, 1, 0);
1358
                    put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1359
                    put_bits(&s->pb, 1, sign);
1360
                }
1361
            } else {
1362
                put_bits(&s->pb, 1, sign);
1363
            }
1364
            last_non_zero = i;
1365
        }
1366
    }
1367
}
1368

    
1369

    
1370

    
1371
/***********************************************/
1372
/* decoding */
1373

    
1374
static VLC intra_MCBPC_vlc;
1375
static VLC inter_MCBPC_vlc;
1376
static VLC cbpy_vlc;
1377
static VLC mv_vlc;
1378
static VLC dc_lum, dc_chrom;
1379
static VLC sprite_trajectory;
1380
static VLC mb_type_b_vlc;
1381

    
1382
void init_rl(RLTable *rl)
1383
{
1384
    INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1385
    UINT8 index_run[MAX_RUN+1];
1386
    int last, run, level, start, end, i;
1387

    
1388
    /* compute max_level[], max_run[] and index_run[] */
1389
    for(last=0;last<2;last++) {
1390
        if (last == 0) {
1391
            start = 0;
1392
            end = rl->last;
1393
        } else {
1394
            start = rl->last;
1395
            end = rl->n;
1396
        }
1397

    
1398
        memset(max_level, 0, MAX_RUN + 1);
1399
        memset(max_run, 0, MAX_LEVEL + 1);
1400
        memset(index_run, rl->n, MAX_RUN + 1);
1401
        for(i=start;i<end;i++) {
1402
            run = rl->table_run[i];
1403
            level = rl->table_level[i];
1404
            if (index_run[run] == rl->n)
1405
                index_run[run] = i;
1406
            if (level > max_level[run])
1407
                max_level[run] = level;
1408
            if (run > max_run[level])
1409
                max_run[level] = run;
1410
        }
1411
        rl->max_level[last] = malloc(MAX_RUN + 1);
1412
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1413
        rl->max_run[last] = malloc(MAX_LEVEL + 1);
1414
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1415
        rl->index_run[last] = malloc(MAX_RUN + 1);
1416
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1417
    }
1418
}
1419

    
1420
void init_vlc_rl(RLTable *rl)
1421
{
1422
    init_vlc(&rl->vlc, 9, rl->n + 1, 
1423
             &rl->table_vlc[0][1], 4, 2,
1424
             &rl->table_vlc[0][0], 4, 2);
1425
}
1426

    
1427
/* init vlcs */
1428

    
1429
/* XXX: find a better solution to handle static init */
1430
void h263_decode_init_vlc(MpegEncContext *s)
1431
{
1432
    static int done = 0;
1433

    
1434
    if (!done) {
1435
        done = 1;
1436

    
1437
        init_vlc(&intra_MCBPC_vlc, 6, 8, 
1438
                 intra_MCBPC_bits, 1, 1,
1439
                 intra_MCBPC_code, 1, 1);
1440
        init_vlc(&inter_MCBPC_vlc, 9, 25, 
1441
                 inter_MCBPC_bits, 1, 1,
1442
                 inter_MCBPC_code, 1, 1);
1443
        init_vlc(&cbpy_vlc, 6, 16,
1444
                 &cbpy_tab[0][1], 2, 1,
1445
                 &cbpy_tab[0][0], 2, 1);
1446
        init_vlc(&mv_vlc, 9, 33,
1447
                 &mvtab[0][1], 2, 1,
1448
                 &mvtab[0][0], 2, 1);
1449
        init_rl(&rl_inter);
1450
        init_rl(&rl_intra);
1451
        init_rl(&rl_intra_aic);
1452
        init_vlc_rl(&rl_inter);
1453
        init_vlc_rl(&rl_intra);
1454
        init_vlc_rl(&rl_intra_aic);
1455
        init_vlc(&dc_lum, 9, 13,
1456
                 &DCtab_lum[0][1], 2, 1,
1457
                 &DCtab_lum[0][0], 2, 1);
1458
        init_vlc(&dc_chrom, 9, 13,
1459
                 &DCtab_chrom[0][1], 2, 1,
1460
                 &DCtab_chrom[0][0], 2, 1);
1461
        init_vlc(&sprite_trajectory, 9, 15,
1462
                 &sprite_trajectory_tab[0][1], 4, 2,
1463
                 &sprite_trajectory_tab[0][0], 4, 2);
1464
        init_vlc(&mb_type_b_vlc, 4, 4,
1465
                 &mb_type_b_tab[0][1], 2, 1,
1466
                 &mb_type_b_tab[0][0], 2, 1);
1467
    }
1468
}
1469

    
1470
int h263_decode_gob_header(MpegEncContext *s)
1471
{
1472
    unsigned int val, gfid;
1473
    
1474
    /* Check for GOB Start Code */
1475
    val = show_bits(&s->gb, 16);
1476
    if (val == 0) {
1477
        /* We have a GBSC probably with GSTUFF */
1478
        skip_bits(&s->gb, 16); /* Drop the zeros */
1479
        while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1480
#ifdef DEBUG
1481
        fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1482
#endif
1483
        s->gob_number = get_bits(&s->gb, 5); /* GN */
1484
        gfid = get_bits(&s->gb, 2); /* GFID */
1485
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1486
#ifdef DEBUG
1487
        fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1488
#endif
1489
        return 1;
1490
    }
1491
    return 0;
1492
            
1493
}
1494

    
1495
static inline void memsetw(short *tab, int val, int n)
1496
{
1497
    int i;
1498
    for(i=0;i<n;i++)
1499
        tab[i] = val;
1500
}
1501

    
1502
static int mpeg4_resync(MpegEncContext *s)
1503
{
1504
    int state, v, bits;
1505
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1506
    int header_extension=0, mb_num;
1507
    int c_wrap, c_xy, l_wrap, l_xy;
1508
    int time_increment;
1509
//printf("resync at %d %d\n", s->mb_x, s->mb_y);
1510
//printf("%X\n", show_bits(&s->gb, 24));
1511

    
1512
    if( get_bits_count(&s->gb) > s->gb.size*8-32)
1513
        return 0;
1514

    
1515
    align_get_bits(&s->gb);
1516
    state = 0xff;
1517
    for(;;) {
1518
        v = get_bits(&s->gb, 8);
1519
//printf("%X ", v);
1520
        state = ((state << 8) | v) & 0xffff;
1521
        if (state == 0) break;
1522
        if( get_bits_count(&s->gb) > s->gb.size*8-32){
1523
            printf("resync failed\n");
1524
            return -1;
1525
        }
1526
    }
1527
//printf("%X\n", show_bits(&s->gb, 24));
1528
    bits=0;
1529
    while(!get_bits1(&s->gb) && bits<30) bits++;
1530
    if(s->pict_type == P_TYPE && bits != s->f_code-1)
1531
        printf("marker does not match f_code\n");
1532
    //FIXME check bits for B-framess
1533
//printf("%X\n", show_bits(&s->gb, 24));
1534

    
1535
    if(s->shape != RECT_SHAPE){
1536
        header_extension= get_bits1(&s->gb);
1537
        //FIXME more stuff here
1538
    }
1539

    
1540
    mb_num= get_bits(&s->gb, mb_num_bits);
1541
    if(mb_num != s->mb_x + s->mb_y*s->mb_width){
1542
        printf("MB-num change not supported %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width);
1543
//        s->mb_x= mb_num % s->mb_width;
1544
//        s->mb_y= mb_num / s->mb_width;
1545
        //FIXME many vars are wrong now
1546
    } 
1547

    
1548
    if(s->shape != BIN_ONLY_SHAPE){
1549
        s->qscale= get_bits(&s->gb, 5);
1550
        h263_dc_scale(s);
1551
    }
1552

    
1553
    if(s->shape == RECT_SHAPE){
1554
        header_extension= get_bits1(&s->gb);
1555
    }
1556
    if(header_extension){
1557
        int time_incr=0;
1558
        printf("header extension not really supported\n");
1559
        while (get_bits1(&s->gb) != 0) 
1560
            time_incr++;
1561

    
1562
        check_marker(&s->gb, "before time_increment in video packed header");
1563
        time_increment= get_bits(&s->gb, s->time_increment_bits);
1564
        if(s->pict_type!=B_TYPE){
1565
            s->last_time_base= s->time_base;
1566
            s->time_base+= time_incr;
1567
            s->time= s->time_base*s->time_increment_resolution + time_increment;
1568
            s->pp_time= s->time - s->last_non_b_time;
1569
            s->last_non_b_time= s->time;
1570
        }else{
1571
            s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
1572
            s->bp_time= s->last_non_b_time - s->time;
1573
        }
1574
        check_marker(&s->gb, "before vop_coding_type in video packed header");
1575
        
1576
        skip_bits(&s->gb, 2); /* vop coding type */
1577
        //FIXME not rect stuff here
1578

    
1579
        if(s->shape != BIN_ONLY_SHAPE){
1580
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
1581

    
1582
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){
1583
                mpeg4_decode_sprite_trajectory(s);
1584
            }
1585

    
1586
            //FIXME reduced res stuff here
1587
            
1588
            if (s->pict_type != I_TYPE) {
1589
                s->f_code = get_bits(&s->gb, 3);        /* fcode_for */
1590
                if(s->f_code==0){
1591
                    printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n");
1592
                    return -1; // makes no sense to continue, as the MV decoding will break very quickly
1593
                }
1594
            }
1595
            if (s->pict_type == B_TYPE) {
1596
                s->b_code = get_bits(&s->gb, 3);
1597
            }       
1598
        }
1599

    
1600
    }
1601
    //FIXME new-pred stuff
1602

    
1603
    l_wrap= s->block_wrap[0];
1604
    l_xy= s->mb_y*l_wrap*2;
1605
    c_wrap= s->block_wrap[4];
1606
    c_xy= s->mb_y*c_wrap;
1607

    
1608
    /* clean DC */
1609
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*3);
1610
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap*2);
1611
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap*2);
1612

    
1613
    /* clean AC */
1614
    memset(s->ac_val[0] + l_xy, 0, l_wrap*3*16*sizeof(INT16));
1615
    memset(s->ac_val[1] + c_xy, 0, c_wrap*2*16*sizeof(INT16));
1616
    memset(s->ac_val[2] + c_xy, 0, c_wrap*2*16*sizeof(INT16));
1617

    
1618
    /* clean MV */
1619
    memset(s->motion_val + l_xy, 0, l_wrap*3*2*sizeof(INT16));
1620
//    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
1621
    s->resync_x_pos= s->mb_x;
1622
    s->first_slice_line=1;
1623

    
1624
    return 0;
1625
}
1626

    
1627
int h263_decode_mb(MpegEncContext *s,
1628
                   DCTELEM block[6][64])
1629
{
1630
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1631
    INT16 *mot_val;
1632
    static INT8 quant_tab[4] = { -1, -2, 1, 2 };
1633

    
1634
    if(s->resync_marker){
1635
        if(   s->resync_x_pos == s->mb_x+1
1636
           || s->resync_x_pos == s->mb_x){
1637
            /* f*ck mpeg4
1638
               this is here so we dont need to slowdown h263_pred_motion with it */
1639
            if(s->resync_x_pos == s->mb_x+1 && s->mb_x==0){
1640
                int xy= s->block_index[0] - s->block_wrap[0];
1641
                s->motion_val[xy][0]= s->motion_val[xy+2][0];
1642
                s->motion_val[xy][1]= s->motion_val[xy+2][1];
1643
            }
1644

    
1645
            s->first_slice_line=0; 
1646
            s->resync_x_pos=0; // isnt needed but for cleanness sake ;)
1647
        }
1648

    
1649
        if(show_aligned_bits(&s->gb, 1, 16) == 0){
1650
            if( mpeg4_resync(s) < 0 ) return -1;
1651
            
1652
        }
1653
    }
1654

    
1655
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
1656
        if (get_bits1(&s->gb)) {
1657
            /* skip mb */
1658
            s->mb_intra = 0;
1659
            for(i=0;i<6;i++)
1660
                s->block_last_index[i] = -1;
1661
            s->mv_dir = MV_DIR_FORWARD;
1662
            s->mv_type = MV_TYPE_16X16;
1663
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
1664
                const int a= s->sprite_warping_accuracy;
1665
//                int l = (1 << (s->f_code - 1)) * 32;
1666

    
1667
                s->mcsel=1;
1668
                if(s->divx_version==500 && s->divx_build==413){
1669
                    s->mv[0][0][0] = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
1670
                    s->mv[0][0][1] = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
1671
                }else{
1672
                    s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1673
                    s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1674
                }
1675
/*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
1676
                else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
1677
                if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
1678
                else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
1679

    
1680
                s->mb_skiped = 0;
1681
            }else{
1682
                s->mcsel=0;
1683
                s->mv[0][0][0] = 0;
1684
                s->mv[0][0][1] = 0;
1685
                s->mb_skiped = 1;
1686
            }
1687
            return 0;
1688
        }
1689
        cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
1690
        //fprintf(stderr, "\tCBPC: %d", cbpc);
1691
        if (cbpc < 0)
1692
            return -1;
1693
        if (cbpc > 20)
1694
            cbpc+=3;
1695
        else if (cbpc == 20)
1696
            fprintf(stderr, "Stuffing !");
1697
        
1698
        dquant = cbpc & 8;
1699
        s->mb_intra = ((cbpc & 4) != 0);
1700
        if (s->mb_intra) goto intra;
1701
        
1702
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
1703
            s->mcsel= get_bits1(&s->gb);
1704
        else s->mcsel= 0;
1705
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
1706
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
1707
        if (dquant) {
1708
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
1709
            if (s->qscale < 1)
1710
                s->qscale = 1;
1711
            else if (s->qscale > 31)
1712
                s->qscale = 31;
1713
            h263_dc_scale(s);
1714
        }
1715
        s->mv_dir = MV_DIR_FORWARD;
1716
        if ((cbpc & 16) == 0) {
1717
            /* 16x16 motion prediction */
1718
            s->mv_type = MV_TYPE_16X16;
1719
            h263_pred_motion(s, 0, &pred_x, &pred_y);
1720
            if (s->umvplus_dec)
1721
               mx = h263p_decode_umotion(s, pred_x);
1722
            else if(!s->mcsel)
1723
               mx = h263_decode_motion(s, pred_x, s->f_code);
1724
            else {
1725
               const int a= s->sprite_warping_accuracy;
1726
//        int l = (1 << (s->f_code - 1)) * 32;
1727
                if(s->divx_version==500 && s->divx_build==413){
1728
                    mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
1729
                }else{
1730
                    mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1731
                }
1732
//        if (mx < -l) mx= -l, printf("C");
1733
//        else if (mx >= l) mx= l-1, printf("C");
1734
            }
1735
            if (mx >= 0xffff)
1736
                return -1;
1737
            
1738
            if (s->umvplus_dec)
1739
               my = h263p_decode_umotion(s, pred_y);
1740
            else if(!s->mcsel)
1741
               my = h263_decode_motion(s, pred_y, s->f_code);
1742
            else{
1743
               const int a= s->sprite_warping_accuracy;
1744
//       int l = (1 << (s->f_code - 1)) * 32;
1745
                if(s->divx_version==500 && s->divx_build==413){
1746
                    my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
1747
                }else{
1748
                    my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1749
                }
1750
//       if (my < -l) my= -l, printf("C");
1751
//       else if (my >= l) my= l-1, printf("C");
1752
            }
1753
            if (my >= 0xffff)
1754
                return -1;
1755
            s->mv[0][0][0] = mx;
1756
            s->mv[0][0][1] = my;
1757
            /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
1758
            fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
1759
            fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
1760
            if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1761
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1762
                           
1763
        } else {
1764
            s->mv_type = MV_TYPE_8X8;
1765
            for(i=0;i<4;i++) {
1766
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1767
                if (s->umvplus_dec)
1768
                  mx = h263p_decode_umotion(s, pred_x);
1769
                else
1770
                  mx = h263_decode_motion(s, pred_x, s->f_code);
1771
                if (mx >= 0xffff)
1772
                    return -1;
1773
                
1774
                if (s->umvplus_dec)
1775
                  my = h263p_decode_umotion(s, pred_y);
1776
                else    
1777
                  my = h263_decode_motion(s, pred_y, s->f_code);
1778
                if (my >= 0xffff)
1779
                    return -1;
1780
                s->mv[0][i][0] = mx;
1781
                s->mv[0][i][1] = my;
1782
                if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1783
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1784
                mot_val[0] = mx;
1785
                mot_val[1] = my;
1786
            }
1787
        }
1788
    } else if(s->pict_type==B_TYPE) {
1789
        int modb1; // first bit of modb
1790
        int modb2; // second bit of modb
1791
        int mb_type;
1792
        uint16_t time_pp;
1793
        uint16_t time_pb;
1794
        int xy;
1795

    
1796
        s->mb_intra = 0; //B-frames never contain intra blocks
1797
        s->mcsel=0;      //     ...               true gmc blocks
1798

    
1799
        if(s->mb_x==0){
1800
            s->last_mv[0][0][0]= 
1801
            s->last_mv[0][0][1]= 
1802
            s->last_mv[1][0][0]= 
1803
            s->last_mv[1][0][1]= 0;
1804
//            printf("\n");
1805
        }
1806

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

    
1810
        if(s->mb_skiped){
1811
                /* skip mb */
1812
            for(i=0;i<6;i++)
1813
                s->block_last_index[i] = -1;
1814

    
1815
            s->mv_dir = MV_DIR_FORWARD;
1816
            s->mv_type = MV_TYPE_16X16;
1817
            s->mv[0][0][0] = 0;
1818
            s->mv[0][0][1] = 0;
1819
            s->mv[1][0][0] = 0;
1820
            s->mv[1][0][1] = 0;
1821
//FIXME is this correct?
1822
/*            s->last_mv[0][0][0]=
1823
            s->last_mv[0][0][1]=0;*/
1824
//            printf("S");
1825
            return 0;
1826
        }
1827

    
1828
        modb1= get_bits1(&s->gb);
1829
        if(modb1==0){
1830
            modb2= get_bits1(&s->gb);
1831
            mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
1832
            if(modb2==0) cbp= get_bits(&s->gb, 6);
1833
            else cbp=0;
1834
            if (mb_type && cbp) {
1835
                if(get_bits1(&s->gb)){
1836
                    s->qscale +=get_bits1(&s->gb)*4 - 2;
1837
                    if (s->qscale < 1)
1838
                        s->qscale = 1;
1839
                    else if (s->qscale > 31)
1840
                        s->qscale = 31;
1841
                    h263_dc_scale(s);
1842
                }
1843
            }
1844
        }else{
1845
            mb_type=4; //like 0 but no vectors coded
1846
            cbp=0;
1847
        }
1848
        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
1849
        mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
1850
        switch(mb_type)
1851
        {
1852
        case 0: /* direct */
1853
            mx = h263_decode_motion(s, 0, 1);
1854
            my = h263_decode_motion(s, 0, 1);
1855
        case 4: /* direct with mx=my=0 */
1856
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1857
            xy= s->block_index[0];
1858
            time_pp= s->pp_time;
1859
            time_pb= time_pp - s->bp_time;
1860
//if(time_pp>3000 )printf("%d %d  ", time_pp, time_pb);
1861
            //FIXME 4MV
1862
            //FIXME avoid divides
1863
            s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
1864
            s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
1865
            s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
1866
                                : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
1867
            s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
1868
                                : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
1869
/*            s->mv[0][0][0] = 
1870
            s->mv[0][0][1] = 
1871
            s->mv[1][0][0] = 
1872
            s->mv[1][0][1] = 1000;*/
1873
//            printf("D");
1874
            break;
1875
        case 1: 
1876
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
1877
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1878
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1879
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1880
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1881

    
1882
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1883
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1884
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1885
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1886
//            printf("I");
1887
            break;
1888
        case 2: 
1889
            s->mv_dir = MV_DIR_BACKWARD;
1890
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1891
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1892
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1893
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1894
//            printf("B");
1895
            break;
1896
        case 3:
1897
            s->mv_dir = MV_DIR_FORWARD;
1898
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1899
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1900
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1901
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1902
//            printf("F");
1903
            break;
1904
        default: return -1;
1905
        }
1906
    } else { /* I-Frame */
1907
        cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
1908
        if (cbpc < 0)
1909
            return -1;
1910
        dquant = cbpc & 4;
1911
        s->mb_intra = 1;
1912
intra:
1913
        s->ac_pred = 0;
1914
        if (s->h263_pred || s->h263_aic) {
1915
            s->ac_pred = get_bits1(&s->gb);
1916
            if (s->ac_pred && s->h263_aic)
1917
                s->h263_aic_dir = get_bits1(&s->gb);
1918
        }
1919
        if (s->h263_aic) {
1920
            s->y_dc_scale = 2 * s->qscale;
1921
            s->c_dc_scale = 2 * s->qscale;
1922
        }
1923
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
1924
        cbp = (cbpc & 3) | (cbpy << 2);
1925
        if (dquant) {
1926
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
1927
            if (s->qscale < 1)
1928
                s->qscale = 1;
1929
            else if (s->qscale > 31)
1930
                s->qscale = 31;
1931
            h263_dc_scale(s);
1932
        }
1933
    }
1934

    
1935
    /* decode each block */
1936
    if (s->h263_pred) {
1937
        for (i = 0; i < 6; i++) {
1938
            if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1939
                return -1;
1940
        }
1941
    } else {
1942
        for (i = 0; i < 6; i++) {
1943
            if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1944
                return -1;
1945
        }
1946
    }
1947
    return 0;
1948
}
1949

    
1950
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
1951
{
1952
    int code, val, sign, shift, l, m;
1953

    
1954
    code = get_vlc(&s->gb, &mv_vlc);
1955
    if (code < 0)
1956
        return 0xffff;
1957

    
1958
    if (code == 0)
1959
        return pred;
1960
    sign = get_bits1(&s->gb);
1961
    shift = f_code - 1;
1962
    val = (code - 1) << shift;
1963
    if (shift > 0)
1964
        val |= get_bits(&s->gb, shift);
1965
    val++;
1966
    if (sign)
1967
        val = -val;
1968
    val += pred;
1969
    
1970
    /* modulo decoding */
1971
    if (!s->h263_long_vectors) {
1972
        l = (1 << (f_code - 1)) * 32;
1973
        m = 2 * l;
1974
        if (val < -l) {
1975
            val += m;
1976
        } else if (val >= l) {
1977
            val -= m;
1978
        }
1979
    } else {
1980
        /* horrible h263 long vector mode */
1981
        if (pred < -31 && val < -63)
1982
            val += 64;
1983
        if (pred > 32 && val > 63)
1984
            val -= 64;
1985
        
1986
    }
1987
    return val;
1988
}
1989

    
1990
/* Decodes RVLC of H.263+ UMV */
1991
static int h263p_decode_umotion(MpegEncContext * s, int pred)
1992
{
1993
   int code = 0, sign;
1994
   
1995
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
1996
      return pred;
1997
   
1998
   code = 2 + get_bits1(&s->gb);
1999
   
2000
   while (get_bits1(&s->gb))
2001
   {
2002
      code <<= 1;
2003
      code += get_bits1(&s->gb);
2004
   }
2005
   sign = code & 1;
2006
   code >>= 1;
2007
   
2008
   code = (sign) ? (pred - code) : (pred + code);
2009
#ifdef DEBUG
2010
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
2011
#endif
2012
   return code;   
2013

    
2014
}
2015

    
2016
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
2017
                             int n, int coded)
2018
{
2019
    int code, level, i, j, last, run;
2020
    RLTable *rl = &rl_inter;
2021
    const UINT8 *scan_table;
2022

    
2023
    scan_table = zigzag_direct;
2024
    if (s->h263_aic && s->mb_intra) {
2025
        rl = &rl_intra_aic;
2026
        i = 0;
2027
        if (s->ac_pred) {
2028
            if (s->h263_aic_dir) 
2029
                scan_table = ff_alternate_vertical_scan; /* left */
2030
            else
2031
                scan_table = ff_alternate_horizontal_scan; /* top */
2032
        }
2033
    } else if (s->mb_intra) {
2034
        /* DC coef */
2035
        if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
2036
            int component, diff;
2037
            component = (n <= 3 ? 0 : n - 4 + 1);
2038
            level = s->last_dc[component];
2039
            if (s->rv10_first_dc_coded[component]) {
2040
                diff = rv_decode_dc(s, n);
2041
                if (diff == 0xffff)
2042
                    return -1;
2043
                level += diff;
2044
                level = level & 0xff; /* handle wrap round */
2045
                s->last_dc[component] = level;
2046
            } else {
2047
                s->rv10_first_dc_coded[component] = 1;
2048
            }
2049
        } else {
2050
            level = get_bits(&s->gb, 8);
2051
            if (level == 255)
2052
                level = 128;
2053
        }
2054
        block[0] = level;
2055
        i = 1;
2056
    } else {
2057
        i = 0;
2058
    }
2059
    if (!coded) {
2060
        if (s->mb_intra && s->h263_aic)
2061
            goto not_coded;
2062
        s->block_last_index[n] = i - 1;
2063
        return 0;
2064
    }
2065

    
2066
    for(;;) {
2067
        code = get_vlc(&s->gb, &rl->vlc);
2068
        if (code < 0)
2069
            return -1;
2070
        if (code == rl->n) {
2071
            /* escape */
2072
            last = get_bits1(&s->gb);
2073
            run = get_bits(&s->gb, 6);
2074
            level = (INT8)get_bits(&s->gb, 8);
2075
            if (s->h263_rv10 && level == -128) {
2076
                /* XXX: should patch encoder too */
2077
                level = get_bits(&s->gb, 12);
2078
                level = (level << 20) >> 20;
2079
            }
2080
        } else {
2081
            run = rl->table_run[code];
2082
            level = rl->table_level[code];
2083
            last = code >= rl->last;
2084
            if (get_bits1(&s->gb))
2085
                level = -level;
2086
        }
2087
        i += run;
2088
        if (i >= 64)
2089
            return -1;
2090
        j = scan_table[i];
2091
        block[j] = level;
2092
        if (last)
2093
            break;
2094
        i++;
2095
    }
2096
not_coded:    
2097
    if (s->mb_intra && s->h263_aic) {
2098
        h263_pred_acdc(s, block, n);
2099
        i = 63;
2100
    }
2101
    s->block_last_index[n] = i;
2102
    return 0;
2103
}
2104

    
2105
static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
2106
{
2107
    int level, pred, code;
2108
    UINT16 *dc_val;
2109

    
2110
    if (n < 4) 
2111
        code = get_vlc(&s->gb, &dc_lum);
2112
    else 
2113
        code = get_vlc(&s->gb, &dc_chrom);
2114
    if (code < 0)
2115
        return -1;
2116
    if (code == 0) {
2117
        level = 0;
2118
    } else {
2119
        level = get_bits(&s->gb, code);
2120
        if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
2121
            level = - (level ^ ((1 << code) - 1));
2122
        if (code > 8)
2123
            skip_bits1(&s->gb); /* marker */
2124
    }
2125

    
2126
    pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
2127
    level += pred;
2128
    if (level < 0)
2129
        level = 0;
2130
    if (n < 4) {
2131
        *dc_val = level * s->y_dc_scale;
2132
    } else {
2133
        *dc_val = level * s->c_dc_scale;
2134
    }
2135
    return level;
2136
}
2137

    
2138
static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
2139
                              int n, int coded)
2140
{
2141
    int code, level, i, j, last, run;
2142
    int dc_pred_dir;
2143
    RLTable *rl;
2144
    const UINT8 *scan_table;
2145

    
2146
    if (s->mb_intra) {
2147
        /* DC coef */
2148
        level = mpeg4_decode_dc(s, n, &dc_pred_dir);
2149
        if (level < 0)
2150
            return -1;
2151
        block[0] = level;
2152
        i = 1;
2153
        if (!coded) 
2154
            goto not_coded;
2155
        rl = &rl_intra;
2156
        if (s->ac_pred) {
2157
            if (dc_pred_dir == 0) 
2158
                scan_table = ff_alternate_vertical_scan; /* left */
2159
            else
2160
                scan_table = ff_alternate_horizontal_scan; /* top */
2161
        } else {
2162
            scan_table = zigzag_direct;
2163
        }
2164
    } else {
2165
        i = 0;
2166
        if (!coded) {
2167
            s->block_last_index[n] = i - 1;
2168
            return 0;
2169
        }
2170
        rl = &rl_inter;
2171
        scan_table = zigzag_direct;
2172
    }
2173

    
2174
    for(;;) {
2175
        code = get_vlc(&s->gb, &rl->vlc);
2176
        if (code < 0)
2177
            return -1;
2178
        if (code == rl->n) {
2179
            /* escape */
2180
            if (get_bits1(&s->gb) != 0) {
2181
                if (get_bits1(&s->gb) != 0) {
2182
                    /* third escape */
2183
                    last = get_bits1(&s->gb);
2184
                    run = get_bits(&s->gb, 6);
2185
                    get_bits1(&s->gb); /* marker */
2186
                    level = get_bits(&s->gb, 12);
2187
                    level = (level << 20) >> 20; /* sign extend */
2188
                    skip_bits1(&s->gb); /* marker */
2189
                } else {
2190
                    /* second escape */
2191
                    code = get_vlc(&s->gb, &rl->vlc);
2192
                    if (code < 0 || code >= rl->n)
2193
                        return -1;
2194
                    run = rl->table_run[code];
2195
                    level = rl->table_level[code];
2196
                    last = code >= rl->last;
2197
                    run += rl->max_run[last][level] + 1;
2198
                    if (get_bits1(&s->gb))
2199
                        level = -level;
2200
                }
2201
            } else {
2202
                /* first escape */
2203
                code = get_vlc(&s->gb, &rl->vlc);
2204
                if (code < 0 || code >= rl->n)
2205
                    return -1;
2206
                run = rl->table_run[code];
2207
                level = rl->table_level[code];
2208
                last = code >= rl->last;
2209
                level += rl->max_level[last][run];
2210
                if (get_bits1(&s->gb))
2211
                    level = -level;
2212
            }
2213
        } else {
2214
            run = rl->table_run[code];
2215
            level = rl->table_level[code];
2216
            last = code >= rl->last;
2217
            if (get_bits1(&s->gb))
2218
                level = -level;
2219
        }
2220
        i += run;
2221
        if (i >= 64)
2222
            return -1;
2223
        j = scan_table[i];
2224
        block[j] = level;
2225
        i++;
2226
        if (last)
2227
            break;
2228
    }
2229
 not_coded:
2230
    if (s->mb_intra) {
2231
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
2232
        if (s->ac_pred) {
2233
            i = 64; /* XXX: not optimal */
2234
        }
2235
    }
2236
    s->block_last_index[n] = i - 1;
2237
    return 0;
2238
}
2239

    
2240
/* most is hardcoded. should extend to handle all h263 streams */
2241
int h263_decode_picture_header(MpegEncContext *s)
2242
{
2243
    int format, width, height;
2244

    
2245
    /* picture header */
2246
    if (get_bits(&s->gb, 22) != 0x20)
2247
        return -1;
2248
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
2249
    
2250
    if (get_bits1(&s->gb) != 1)
2251
        return -1;        /* marker */
2252
    if (get_bits1(&s->gb) != 0)
2253
        return -1;        /* h263 id */
2254
    skip_bits1(&s->gb);        /* split screen off */
2255
    skip_bits1(&s->gb);        /* camera  off */
2256
    skip_bits1(&s->gb);        /* freeze picture release off */
2257

    
2258
    /* Reset GOB number */
2259
    s->gob_number = 0;
2260
        
2261
    format = get_bits(&s->gb, 3);
2262

    
2263
    if (format != 7 && format != 6) {
2264
        s->h263_plus = 0;
2265
        /* H.263v1 */
2266
        width = h263_format[format][0];
2267
        height = h263_format[format][1];
2268
        if (!width)
2269
            return -1;
2270
        
2271
        s->width = width;
2272
        s->height = height;
2273
        s->pict_type = I_TYPE + get_bits1(&s->gb);
2274

    
2275
        s->unrestricted_mv = get_bits1(&s->gb); 
2276
        s->h263_long_vectors = s->unrestricted_mv;
2277

    
2278
        if (get_bits1(&s->gb) != 0)
2279
            return -1;        /* SAC: off */
2280
        if (get_bits1(&s->gb) != 0) {
2281
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
2282
        }   
2283
        
2284
        if (get_bits1(&s->gb) != 0)
2285
            return -1;        /* not PB frame */
2286

    
2287
        s->qscale = get_bits(&s->gb, 5);
2288
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
2289
    } else {
2290
        int ufep;
2291
        
2292
        /* H.263v2 */
2293
        s->h263_plus = 1;
2294
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
2295
        
2296
        if (ufep == 1) {
2297
            /* OPPTYPE */       
2298
            format = get_bits(&s->gb, 3);
2299
            skip_bits(&s->gb,1); /* Custom PCF */
2300
            s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
2301
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
2302
            if (get_bits1(&s->gb) != 0) {
2303
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
2304
            }
2305
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
2306
                s->h263_aic = 1;
2307
            }
2308
            skip_bits(&s->gb, 7);
2309
            skip_bits(&s->gb, 3); /* Reserved */
2310
        } else if (ufep != 0)
2311
            return -1;
2312
            
2313
        /* MPPTYPE */
2314
        s->pict_type = get_bits(&s->gb, 3) + 1;
2315
        if (s->pict_type != I_TYPE &&
2316
            s->pict_type != P_TYPE)
2317
            return -1;
2318
        skip_bits(&s->gb, 2);
2319
        s->no_rounding = get_bits1(&s->gb);
2320
        //fprintf(stderr, "\nRTYPE: %d", s->no_rounding);
2321
        skip_bits(&s->gb, 4);
2322
        
2323
        /* Get the picture dimensions */
2324
        if (ufep) {
2325
            if (format == 6) {
2326
                /* Custom Picture Format (CPFMT) */
2327
                skip_bits(&s->gb, 4); /* aspect ratio */
2328
                width = (get_bits(&s->gb, 9) + 1) * 4;
2329
                skip_bits1(&s->gb);
2330
                height = get_bits(&s->gb, 9) * 4;
2331
#ifdef DEBUG 
2332
                fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);
2333
#endif            
2334
            }
2335
            else {
2336
                width = h263_format[format][0];
2337
                height = h263_format[format][1];
2338
            }
2339
            if ((width == 0) || (height == 0))
2340
                return -1;
2341
            s->width = width;
2342
            s->height = height;
2343
            if (s->umvplus_dec) {
2344
                skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
2345
            }
2346
        }
2347
            
2348
        s->qscale = get_bits(&s->gb, 5);
2349
    }
2350
    /* PEI */
2351
    while (get_bits1(&s->gb) != 0) {
2352
        skip_bits(&s->gb, 8);
2353
    }
2354
    s->f_code = 1;
2355
    return 0;
2356
}
2357

    
2358
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
2359
{
2360
    int i;
2361
    int a= 2<<s->sprite_warping_accuracy;
2362
    int rho= 3-s->sprite_warping_accuracy;
2363
    int r=16/a;
2364
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
2365
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
2366
    int sprite_ref[4][2];
2367
    int virtual_ref[2][2];
2368
    int w2, h2;
2369
    int alpha=0, beta=0;
2370
    int w= s->width;
2371
    int h= s->height;
2372
//printf("SP %d\n", s->sprite_warping_accuracy);
2373
    for(i=0; i<s->num_sprite_warping_points; i++){
2374
        int length;
2375
        int x=0, y=0;
2376

    
2377
        length= get_vlc(&s->gb, &sprite_trajectory);
2378
        if(length){
2379
            x= get_bits(&s->gb, length);
2380
//printf("lx %d %d\n", length, x);
2381
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
2382
                x = - (x ^ ((1 << length) - 1));
2383
        }
2384
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
2385
        
2386
        length= get_vlc(&s->gb, &sprite_trajectory);
2387
        if(length){
2388
            y=get_bits(&s->gb, length);
2389
//printf("ly %d %d\n", length, y);
2390
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
2391
                y = - (y ^ ((1 << length) - 1));
2392
        }
2393
        skip_bits1(&s->gb); /* marker bit */
2394
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
2395
//if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
2396
//x=y=0;
2397
        d[i][0]= x;
2398
        d[i][1]= y;
2399
    }
2400

    
2401
    while((1<<alpha)<w) alpha++;
2402
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
2403
    w2= 1<<alpha;
2404
    h2= 1<<beta;
2405

    
2406
// Note, the 4th point isnt used for GMC
2407
    if(s->divx_version==500 && s->divx_build==413){
2408
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
2409
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
2410
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
2411
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
2412
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
2413
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
2414
    } else {
2415
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
2416
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
2417
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
2418
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
2419
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
2420
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
2421
    }
2422
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
2423
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
2424
    
2425
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
2426
// perhaps it should be reordered to be more readable ...
2427
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
2428
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
2429
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
2430
        + 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);
2431
    virtual_ref[0][1]= 16*vop_ref[0][1] 
2432
        + 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);
2433
    virtual_ref[1][0]= 16*vop_ref[0][0] 
2434
        + 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);
2435
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
2436
        + 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);
2437

    
2438
    switch(s->num_sprite_warping_points)
2439
    {
2440
        case 0:
2441
            s->sprite_offset[0][0]= 0;
2442
            s->sprite_offset[0][1]= 0;
2443
            s->sprite_offset[1][0]= 0;
2444
            s->sprite_offset[1][1]= 0;
2445
            s->sprite_delta[0][0][0]= a;
2446
            s->sprite_delta[0][0][1]= 0;
2447
            s->sprite_delta[0][1][0]= 0;
2448
            s->sprite_delta[0][1][1]= a;
2449
            s->sprite_delta[1][0][0]= a;
2450
            s->sprite_delta[1][0][1]= 0;
2451
            s->sprite_delta[1][1][0]= 0;
2452
            s->sprite_delta[1][1][1]= a;
2453
            s->sprite_shift[0][0]= 0;
2454
            s->sprite_shift[0][1]= 0;
2455
            s->sprite_shift[1][0]= 0;
2456
            s->sprite_shift[1][1]= 0;
2457
            break;
2458
        case 1: //GMC only
2459
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
2460
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
2461
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
2462
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
2463
            s->sprite_delta[0][0][0]= a;
2464
            s->sprite_delta[0][0][1]= 0;
2465
            s->sprite_delta[0][1][0]= 0;
2466
            s->sprite_delta[0][1][1]= a;
2467
            s->sprite_delta[1][0][0]= a;
2468
            s->sprite_delta[1][0][1]= 0;
2469
            s->sprite_delta[1][1][0]= 0;
2470
            s->sprite_delta[1][1][1]= a;
2471
            s->sprite_shift[0][0]= 0;
2472
            s->sprite_shift[0][1]= 0;
2473
            s->sprite_shift[1][0]= 0;
2474
            s->sprite_shift[1][1]= 0;
2475
            break;
2476
        case 2:
2477
        case 3: //FIXME
2478
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
2479
                                                  + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
2480
                                                    +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
2481
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
2482
                                                  + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
2483
                                                    +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
2484
            s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
2485
                                 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
2486
                                 +2*w2*r*sprite_ref[0][0] - 16*w2);
2487
            s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
2488
                                 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
2489
                                 +2*w2*r*sprite_ref[0][1] - 16*w2);
2490
            s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2491
            s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);
2492
            s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
2493
            s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2494
            s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2495
            s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
2496
            s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
2497
            s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2498
            s->sprite_shift[0][0]= alpha+rho;
2499
            s->sprite_shift[0][1]= alpha+rho;
2500
            s->sprite_shift[1][0]= alpha+rho+2;
2501
            s->sprite_shift[1][1]= alpha+rho+2;
2502
            break;
2503
//        case 3:
2504
            break;
2505
    }
2506
/*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
2507
printf("%d %d\n", s->sprite_delta[0][0][1], 0);
2508
printf("%d %d\n", s->sprite_delta[0][1][0], 0);
2509
printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
2510
printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
2511
printf("%d %d\n", s->sprite_delta[1][0][1], 0);
2512
printf("%d %d\n", s->sprite_delta[1][1][0], 0);
2513
printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
2514
    /* try to simplify the situation */ 
2515
    if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
2516
       && s->sprite_delta[0][0][1] == 0
2517
       && s->sprite_delta[0][1][0] == 0
2518
       && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
2519
       && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
2520
       && s->sprite_delta[1][0][1] == 0
2521
       && s->sprite_delta[1][1][0] == 0
2522
       && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
2523
    {
2524
        s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
2525
        s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
2526
        s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
2527
        s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
2528
        s->sprite_delta[0][0][0]= a;
2529
        s->sprite_delta[0][0][1]= 0;
2530
        s->sprite_delta[0][1][0]= 0;
2531
        s->sprite_delta[0][1][1]= a;
2532
        s->sprite_delta[1][0][0]= a;
2533
        s->sprite_delta[1][0][1]= 0;
2534
        s->sprite_delta[1][1][0]= 0;
2535
        s->sprite_delta[1][1][1]= a;
2536
        s->sprite_shift[0][0]= 0;
2537
        s->sprite_shift[0][1]= 0;
2538
        s->sprite_shift[1][0]= 0;
2539
        s->sprite_shift[1][1]= 0;
2540
        s->real_sprite_warping_points=1;
2541
    }
2542
    else
2543
        s->real_sprite_warping_points= s->num_sprite_warping_points;
2544

    
2545
//printf("%d %d %d %d\n", d[0][0], d[0][1], s->sprite_offset[0][0], s->sprite_offset[0][1]);
2546
}
2547

    
2548
/* decode mpeg4 VOP header */
2549
int mpeg4_decode_picture_header(MpegEncContext * s)
2550
{
2551
    int time_incr, startcode, state, v;
2552
    int time_increment;
2553

    
2554
 redo:
2555
    /* search next start code */
2556
    align_get_bits(&s->gb);
2557
    state = 0xff;
2558
    for(;;) {
2559
        v = get_bits(&s->gb, 8);
2560
        if (state == 0x000001) {
2561
            state = ((state << 8) | v) & 0xffffff;
2562
            startcode = state;
2563
            break;
2564
        }
2565
        state = ((state << 8) | v) & 0xffffff;
2566
        if( get_bits_count(&s->gb) > s->gb.size*8-32){
2567
            if(s->gb.size>50){
2568
                printf("no VOP startcode found, frame size was=%d\n", s->gb.size);
2569
                return -1;
2570
            }else{
2571
                printf("frame skip\n");
2572
                return FRAME_SKIPED;
2573
            }
2574
        }
2575
    }
2576
//printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
2577
    if (startcode == 0x120) { // Video Object Layer
2578
        int width, height, vo_ver_id;
2579

    
2580
        /* vol header */
2581
        skip_bits(&s->gb, 1); /* random access */
2582
        skip_bits(&s->gb, 8); /* vo_type */
2583
        if (get_bits1(&s->gb) != 0) { /* is_ol_id */
2584
            vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
2585
            skip_bits(&s->gb, 3); /* vo_priority */
2586
        } else {
2587
            vo_ver_id = 1;
2588
        }
2589
        
2590
        s->aspect_ratio_info= get_bits(&s->gb, 4);
2591
        if(s->aspect_ratio_info == EXTENDET_PAR){
2592
            skip_bits(&s->gb, 8); //par_width
2593
            skip_bits(&s->gb, 8); // par_height
2594
        }
2595

    
2596
        if(get_bits1(&s->gb)){ /* vol control parameter */
2597
            printf("vol control parameter not supported\n");
2598
            return -1;   
2599
        }
2600
        s->shape = get_bits(&s->gb, 2); /* vol shape */
2601
        if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
2602
        if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
2603
            printf("Gray shape not supported\n");
2604
            skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
2605
        }
2606

    
2607
        skip_bits1(&s->gb);   /* marker */
2608
        
2609
        s->time_increment_resolution = get_bits(&s->gb, 16);
2610
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
2611
        if (s->time_increment_bits < 1)
2612
            s->time_increment_bits = 1;
2613
        skip_bits1(&s->gb);   /* marker */
2614

    
2615
        if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
2616
            skip_bits(&s->gb, s->time_increment_bits);
2617
        }
2618

    
2619
        if (s->shape != BIN_ONLY_SHAPE) {
2620
            if (s->shape == RECT_SHAPE) {
2621
                skip_bits1(&s->gb);   /* marker */
2622
                width = get_bits(&s->gb, 13);
2623
                skip_bits1(&s->gb);   /* marker */
2624
                height = get_bits(&s->gb, 13);
2625
                skip_bits1(&s->gb);   /* marker */
2626
                if(width && height){ /* they should be non zero but who knows ... */
2627
                    s->width = width;
2628
                    s->height = height;
2629
//                    printf("width/height: %d %d\n", width, height);
2630
                }
2631
            }
2632
            
2633
            if(get_bits1(&s->gb)) printf("interlaced not supported\n");   /* interlaced */
2634
            if(!get_bits1(&s->gb)) printf("OBMC not supported\n");   /* OBMC Disable */
2635
            if (vo_ver_id == 1) {
2636
                s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
2637
            } else {
2638
                s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
2639
            }
2640
            if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
2641
            if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
2642
                if(s->vol_sprite_usage==STATIC_SPRITE){
2643
                    s->sprite_width = get_bits(&s->gb, 13);
2644
                    skip_bits1(&s->gb); /* marker */
2645
                    s->sprite_height= get_bits(&s->gb, 13);
2646
                    skip_bits1(&s->gb); /* marker */
2647
                    s->sprite_left  = get_bits(&s->gb, 13);
2648
                    skip_bits1(&s->gb); /* marker */
2649
                    s->sprite_top   = get_bits(&s->gb, 13);
2650
                    skip_bits1(&s->gb); /* marker */
2651
                }
2652
                s->num_sprite_warping_points= get_bits(&s->gb, 6);
2653
                s->sprite_warping_accuracy = get_bits(&s->gb, 2);
2654
                s->sprite_brightness_change= get_bits1(&s->gb);
2655
                if(s->vol_sprite_usage==STATIC_SPRITE)
2656
                    s->low_latency_sprite= get_bits1(&s->gb);            
2657
            }
2658
            // FIXME sadct disable bit if verid!=1 && shape not rect
2659
            
2660
            if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
2661
                s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
2662
                if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
2663
                if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
2664
            } else {
2665
                s->quant_precision = 5;
2666
            }
2667
            
2668
            // FIXME a bunch of grayscale shape things
2669

    
2670
            if(get_bits1(&s->gb)){ /* vol_quant_type */
2671
                int i, j, v;
2672
                /* load default matrixes */
2673
                for(i=0; i<64; i++){
2674
                    v= ff_mpeg4_default_intra_matrix[i];
2675
                    s->intra_matrix[i]= v;
2676
                    s->chroma_intra_matrix[i]= v;
2677
                    
2678
                    v= ff_mpeg4_default_non_intra_matrix[i];
2679
                    s->non_intra_matrix[i]= v;
2680
                    s->chroma_non_intra_matrix[i]= v;
2681
                }
2682

    
2683
                /* load custom intra matrix */
2684
                if(get_bits1(&s->gb)){
2685
                    for(i=0; i<64; i++){
2686
                        v= get_bits(&s->gb, 8);
2687
                        if(v==0) break;
2688

    
2689
                        j= zigzag_direct[i];
2690
                        s->intra_matrix[j]= v;
2691
                        s->chroma_intra_matrix[j]= v;
2692
                    }
2693
                }
2694

    
2695
                /* load custom non intra matrix */
2696
                if(get_bits1(&s->gb)){
2697
                    for(i=0; i<64; i++){
2698
                        v= get_bits(&s->gb, 8);
2699
                        if(v==0) break;
2700

    
2701
                        j= zigzag_direct[i];
2702
                        s->non_intra_matrix[j]= v;
2703
                        s->chroma_non_intra_matrix[j]= v;
2704
                    }
2705

    
2706
                    /* replicate last value */
2707
                    for(; i<64; i++){
2708
                        j= zigzag_direct[i];
2709
                        s->non_intra_matrix[j]= v;
2710
                        s->chroma_non_intra_matrix[j]= v;
2711
                    }
2712
                }
2713

    
2714
                s->dct_unquantize= s->dct_unquantize_mpeg2;
2715

    
2716
                // FIXME a bunch of grayscale shape things
2717
            }else
2718
                s->dct_unquantize= s->dct_unquantize_h263;
2719

    
2720
            if(vo_ver_id != 1)
2721
                 s->quarter_sample= get_bits1(&s->gb);
2722
            else s->quarter_sample=0;
2723

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

    
2726
            s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */
2727

    
2728
            s->data_partioning= get_bits1(&s->gb);
2729
            if(s->data_partioning){
2730
                printf("data partitioning not supported\n");
2731
                skip_bits1(&s->gb); // reversible vlc
2732
            }
2733
            
2734
            if(vo_ver_id != 1) {
2735
                s->new_pred= get_bits1(&s->gb);
2736
                if(s->new_pred){
2737
                    printf("new pred not supported\n");
2738
                    skip_bits(&s->gb, 2); /* requested upstream message type */
2739
                    skip_bits1(&s->gb); /* newpred segment type */
2740
                }
2741
                s->reduced_res_vop= get_bits1(&s->gb);
2742
                if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
2743
            }
2744
            else{
2745
                s->new_pred=0;
2746
                s->reduced_res_vop= 0;
2747
            }
2748

    
2749
            s->scalability= get_bits1(&s->gb);
2750
            if (s->scalability) {
2751
                printf("scalability not supported\n");
2752
            }
2753
        }
2754
//printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
2755
        goto redo;
2756
    } else if (startcode == 0x1b2) { //userdata
2757
        char buf[256];
2758
        int i;
2759
        int e;
2760
        int ver, build;
2761

    
2762
//printf("user Data %X\n", show_bits(&s->gb, 32));
2763
        buf[0]= show_bits(&s->gb, 8);
2764
        for(i=1; i<256; i++){
2765
            buf[i]= show_bits(&s->gb, 16)&0xFF;
2766
            if(buf[i]==0) break;
2767
            skip_bits(&s->gb, 8);
2768
        }
2769
        buf[255]=0;
2770
        e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
2771
        if(e!=2)
2772
            e=sscanf(buf, "DivX%db%d", &ver, &build);
2773
        if(e==2){
2774
            s->divx_version= ver;
2775
            s->divx_build= build;
2776
            if(s->picture_number==0){
2777
                printf("This file was encoded with DivX%d Build%d\n", ver, build);
2778
                if(ver==500 && build==413){
2779
                    printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
2780
#if 0
2781
                }else{
2782
                    printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
2783
                           "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
2784
#endif 
2785
                }
2786
            }
2787
        }
2788
//printf("User Data: %s\n", buf);
2789
        goto redo;
2790
    } else if (startcode != 0x1b6) { //VOP
2791
        goto redo;
2792
    }
2793

    
2794
    s->pict_type = get_bits(&s->gb, 2) + 1;        /* pict type: I = 0 , P = 1 */
2795
// printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample); 
2796
    time_incr=0;
2797
    while (get_bits1(&s->gb) != 0) 
2798
        time_incr++;
2799

    
2800
    check_marker(&s->gb, "before time_increment");
2801
    time_increment= get_bits(&s->gb, s->time_increment_bits);
2802
//printf(" type:%d incr:%d increment:%d\n", s->pict_type, time_incr, time_increment);
2803
    if(s->pict_type!=B_TYPE){
2804
        s->last_time_base= s->time_base;
2805
        s->time_base+= time_incr;
2806
        s->time= s->time_base*s->time_increment_resolution + time_increment;
2807
        s->pp_time= s->time - s->last_non_b_time;
2808
        s->last_non_b_time= s->time;
2809
    }else{
2810
        s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
2811
        s->bp_time= s->last_non_b_time - s->time;
2812
    }
2813

    
2814
    if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
2815
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
2816
        for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
2817
            if(get_bits1(&s->gb)) break;
2818
        }
2819
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
2820
    }
2821
    /* vop coded */
2822
    if (get_bits1(&s->gb) != 1)
2823
        goto redo;
2824
//printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
2825
//s->time, s->last_non_b_time[0], s->last_non_b_time[1]);  
2826
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
2827
                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
2828
        /* rounding type for motion estimation */
2829
        s->no_rounding = get_bits1(&s->gb);
2830
    } else {
2831
        s->no_rounding = 0;
2832
    }
2833
//FIXME reduced res stuff
2834

    
2835
     if (s->shape != RECT_SHAPE) {
2836
         if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
2837
             int width, height, hor_spat_ref, ver_spat_ref;
2838
 
2839
             width = get_bits(&s->gb, 13);
2840
             skip_bits1(&s->gb);   /* marker */
2841
             height = get_bits(&s->gb, 13);
2842
             skip_bits1(&s->gb);   /* marker */
2843
             hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
2844
             skip_bits1(&s->gb);   /* marker */
2845
             ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
2846
         }
2847
         skip_bits1(&s->gb); /* change_CR_disable */
2848
 
2849
         if (get_bits1(&s->gb) != 0) {
2850
             skip_bits(&s->gb, 8); /* constant_alpha_value */
2851
         }
2852
     }
2853
//FIXME complexity estimation stuff
2854
     
2855
     if (s->shape != BIN_ONLY_SHAPE) {
2856
         int t;
2857
         t=get_bits(&s->gb, 3); /* intra dc VLC threshold */
2858
//printf("threshold %d\n", t);
2859
         //FIXME interlaced specific bits
2860
     }
2861

    
2862
     if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
2863
         if(s->num_sprite_warping_points){
2864
             mpeg4_decode_sprite_trajectory(s);
2865
         }
2866
         if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
2867
         if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
2868
     }
2869

    
2870
     if (s->shape != BIN_ONLY_SHAPE) {
2871
         /* note: we do not use quant_precision to avoid problem if no
2872
            MPEG4 vol header as it is found on some old opendivx
2873
            movies */
2874
         s->qscale = get_bits(&s->gb, 5);
2875
         if(s->qscale==0){
2876
             printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
2877
             return -1; // makes no sense to continue, as there is nothing left from the image then
2878
         }
2879
  
2880
         if (s->pict_type != I_TYPE) {
2881
             s->f_code = get_bits(&s->gb, 3);        /* fcode_for */
2882
             if(s->f_code==0){
2883
                 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
2884
                 return -1; // makes no sense to continue, as the MV decoding will break very quickly
2885
             }
2886
         }
2887
         if (s->pict_type == B_TYPE) {
2888
             s->b_code = get_bits(&s->gb, 3);
2889
//printf("b-code %d\n", s->b_code);
2890
         }
2891
//printf("quant:%d fcode:%d bcode:%d type:%d\n", s->qscale, s->f_code, s->b_code, s->pict_type);
2892
         if(!s->scalability){
2893
             if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
2894
                 skip_bits1(&s->gb); // vop shape coding type
2895
             }
2896
         }
2897
     }
2898
     s->picture_number++; // better than pic number==0 allways ;)
2899
//printf("done\n");
2900
     return 0;
2901
}
2902

    
2903
/* don't understand why they choose a different header ! */
2904
int intel_h263_decode_picture_header(MpegEncContext *s)
2905
{
2906
    int format;
2907

    
2908
    /* picture header */
2909
    if (get_bits(&s->gb, 22) != 0x20)
2910
        return -1;
2911
    skip_bits(&s->gb, 8); /* picture timestamp */
2912

    
2913
    if (get_bits1(&s->gb) != 1)
2914
        return -1;        /* marker */
2915
    if (get_bits1(&s->gb) != 0)
2916
        return -1;        /* h263 id */
2917
    skip_bits1(&s->gb);        /* split screen off */
2918
    skip_bits1(&s->gb);        /* camera  off */
2919
    skip_bits1(&s->gb);        /* freeze picture release off */
2920

    
2921
    format = get_bits(&s->gb, 3);
2922
    if (format != 7)
2923
        return -1;
2924

    
2925
    s->h263_plus = 0;
2926

    
2927
    s->pict_type = I_TYPE + get_bits1(&s->gb);
2928
    
2929
    s->unrestricted_mv = get_bits1(&s->gb); 
2930
    s->h263_long_vectors = s->unrestricted_mv;
2931

    
2932
    if (get_bits1(&s->gb) != 0)
2933
        return -1;        /* SAC: off */
2934
    if (get_bits1(&s->gb) != 0)
2935
        return -1;        /* advanced prediction mode: off */
2936
    if (get_bits1(&s->gb) != 0)
2937
        return -1;        /* not PB frame */
2938

    
2939
    /* skip unknown header garbage */
2940
    skip_bits(&s->gb, 41);
2941

    
2942
    s->qscale = get_bits(&s->gb, 5);
2943
    skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
2944

    
2945
    /* PEI */
2946
    while (get_bits1(&s->gb) != 0) {
2947
        skip_bits(&s->gb, 8);
2948
    }
2949
    s->f_code = 1;
2950
    return 0;
2951
}
2952