Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ d697b89b

History | View | Annotate | Download (98.6 KB)

1
/*
2
 * H263/MPEG4 backend for ffmpeg encoder and decoder
3
 * Copyright (c) 2000,2001 Gerard Lantau.
4
 * H263+ support.
5
 * Copyright (c) 2001 Juan J. Sierralta P.
6
 *
7
 * This program is free software; you can redistribute it and/or modify
8
 * it under the terms of the GNU General Public License as published by
9
 * the Free Software Foundation; either version 2 of the License, or
10
 * (at your option) any later version.
11
 *
12
 * This program is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 * GNU General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU General Public License
18
 * along with this program; if not, write to the Free Software
19
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
 *
21
 * ac prediction encoding & b-frame support by Michael Niedermayer <michaelni@gmx.at>
22
 */
23
#include "common.h"
24
#include "dsputil.h"
25
#include "avcodec.h"
26
#include "mpegvideo.h"
27
#include "h263data.h"
28
#include "mpeg4data.h"
29

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

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

    
54
extern UINT32 inverse[256];
55

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

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

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

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

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

    
86
    align_put_bits(&s->pb);
87

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
887
    }
888
}
889

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

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

    
897
        init_uni_dc_tab();
898

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

    
902
        init_mv_penalty_and_fcode(s);
903
    }
904
    s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
905
    
906
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
907
    if(s->h263_plus) s->fcode_tab= umv_fcode_tab;
908
    else if(s->h263_pred && !s->h263_msmpeg4) s->fcode_tab= fcode_tab;
909
}
910

    
911
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
912
{
913
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
914
    int code;
915
    RLTable *rl = &rl_inter;
916

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

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

    
968
/***************************************************/
969

    
970
static void mpeg4_stuffing(PutBitContext * pbc)
971
{
972
    int length;
973
    put_bits(pbc, 1, 0);
974
    length= (-get_bit_count(pbc))&7;
975
    put_bits(pbc, length, (1<<length)-1);
976
}
977

    
978
static void put_string(PutBitContext * pbc, char *s)
979
{
980
    while(*s){
981
        put_bits(pbc, 8, *s);
982
        s++;
983
    }
984
    put_bits(pbc, 8, 0);
985
}
986

    
987
/* must be called before writing the header */
988
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
989
    int time_div, time_mod;
990

    
991
    if(s->pict_type==I_TYPE){ //we will encode a vol header
992
        s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
993
        if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
994

    
995
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
996
    }
997

    
998
    s->time= picture_number*(int64_t)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
999
    time_div= s->time/s->time_increment_resolution;
1000
    time_mod= s->time%s->time_increment_resolution;
1001

    
1002
    if(s->pict_type==B_TYPE){
1003
        s->bp_time= s->last_non_b_time - s->time;
1004
    }else{
1005
        s->last_time_base= s->time_base;
1006
        s->time_base= time_div;
1007
        s->pp_time= s->time - s->last_non_b_time;
1008
        s->last_non_b_time= s->time;
1009
    }
1010
}
1011

    
1012
static void mpeg4_encode_vol_header(MpegEncContext * s)
1013
{
1014
    int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1015
    char buf[255];
1016

    
1017
    s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
1018

    
1019
    if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
1020
    put_bits(&s->pb, 16, 0);
1021
    put_bits(&s->pb, 16, 0x100);        /* video obj */
1022
    put_bits(&s->pb, 16, 0);
1023
    put_bits(&s->pb, 16, 0x120);        /* video obj layer */
1024

    
1025
    put_bits(&s->pb, 1, 0);                /* random access vol */
1026
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1027
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1028
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1029
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1030
    if(s->aspect_ratio_info) 
1031
        put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1032
    else
1033
        put_bits(&s->pb, 4, 1);                /* aspect ratio info= sqare pixel */
1034

    
1035
    if(s->low_delay){
1036
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1037
        put_bits(&s->pb, 2, 1);                /* chroma format 422 */
1038
        put_bits(&s->pb, 1, s->low_delay);
1039
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1040
    }else{
1041
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1042
    }
1043

    
1044
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1045
    put_bits(&s->pb, 1, 1);                /* marker bit */
1046
    
1047
    put_bits(&s->pb, 16, s->time_increment_resolution);
1048
    if (s->time_increment_bits < 1)
1049
        s->time_increment_bits = 1;
1050
    put_bits(&s->pb, 1, 1);                /* marker bit */
1051
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1052
    put_bits(&s->pb, 1, 1);                /* marker bit */
1053
    put_bits(&s->pb, 13, s->width);        /* vol width */
1054
    put_bits(&s->pb, 1, 1);                /* marker bit */
1055
    put_bits(&s->pb, 13, s->height);        /* vol height */
1056
    put_bits(&s->pb, 1, 1);                /* marker bit */
1057
    put_bits(&s->pb, 1, 0);                /* interlace */
1058
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1059
    if (vo_ver_id == 1) {
1060
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1061
    }else{ /* vo_ver_id == 2 */
1062
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1063
    }
1064
    put_bits(&s->pb, 1, 0);                /* not 8 bit */
1065
    put_bits(&s->pb, 1, 0);                /* quant type= h263 style*/
1066
    if (vo_ver_id != 1)
1067
        put_bits(&s->pb, 1, s->quarter_sample=0);
1068
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1069
    put_bits(&s->pb, 1, 1);                /* resync marker disable */
1070
    put_bits(&s->pb, 1, 0);                /* data partitioned */
1071
    if (vo_ver_id != 1){
1072
        put_bits(&s->pb, 1, 0);                /* newpred */
1073
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1074
    }
1075
    put_bits(&s->pb, 1, 0);                /* scalability */
1076

    
1077
    mpeg4_stuffing(&s->pb);
1078
    put_bits(&s->pb, 16, 0);
1079
    put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1080
    sprintf(buf, "FFmpeg v%s / libavcodec build: %s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1081
    put_string(&s->pb, buf);
1082

    
1083
    s->no_rounding = 0;
1084
}
1085

    
1086
/* write mpeg4 VOP header */
1087
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1088
{
1089
    int time_incr;
1090
    int time_div, time_mod;
1091
    
1092
    if(s->pict_type==I_TYPE) mpeg4_encode_vol_header(s);
1093
    
1094
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1095
    
1096
    if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
1097
    put_bits(&s->pb, 16, 0);                /* vop header */
1098
    put_bits(&s->pb, 16, 0x1B6);        /* vop header */
1099
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1100

    
1101
    time_div= s->time/s->time_increment_resolution;
1102
    time_mod= s->time%s->time_increment_resolution;
1103
    time_incr= time_div - s->last_time_base;
1104
    while(time_incr--)
1105
        put_bits(&s->pb, 1, 1);
1106
        
1107
    put_bits(&s->pb, 1, 0);
1108

    
1109
    put_bits(&s->pb, 1, 1);        /* marker */
1110
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1111
    put_bits(&s->pb, 1, 1);        /* marker */
1112
    put_bits(&s->pb, 1, 1);        /* vop coded */
1113
    if (    s->pict_type == P_TYPE 
1114
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1115
        s->no_rounding ^= 1;
1116
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1117
    }
1118
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1119
    //FIXME sprite stuff
1120

    
1121
    put_bits(&s->pb, 5, s->qscale);
1122

    
1123
    if (s->pict_type != I_TYPE)
1124
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1125
    if (s->pict_type == B_TYPE)
1126
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1127
    //    printf("****frame %d\n", picture_number);
1128
}
1129

    
1130
void h263_dc_scale(MpegEncContext * s)
1131
{
1132
#if 1
1133
    const static UINT8 y_tab[32]={
1134
    //  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
1135
        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
1136
    };
1137
    const static UINT8 c_tab[32]={
1138
    //  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
1139
        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
1140
    };
1141
    s->y_dc_scale = y_tab[s->qscale];
1142
    s->c_dc_scale = c_tab[s->qscale];
1143
#else
1144
    int quant;
1145
    quant = s->qscale;
1146
    /* luminance */
1147
    if (quant < 5)
1148
        s->y_dc_scale = 8;
1149
    else if (quant > 4 && quant < 9)
1150
        s->y_dc_scale = (2 * quant);
1151
    else if (quant > 8 && quant < 25)
1152
        s->y_dc_scale = (quant + 8);
1153
    else
1154
        s->y_dc_scale = (2 * quant - 16);
1155
    /* chrominance */
1156
    if (quant < 5)
1157
        s->c_dc_scale = 8;
1158
    else if (quant > 4 && quant < 25)
1159
        s->c_dc_scale = ((quant + 13) / 2);
1160
    else
1161
        s->c_dc_scale = (quant - 6);
1162
#endif
1163
}
1164

    
1165
static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1166
{
1167
    int a, b, c, wrap, pred, scale;
1168
    UINT16 *dc_val;
1169
    int dummy;
1170

    
1171
    /* find prediction */
1172
    if (n < 4) {
1173
        scale = s->y_dc_scale;
1174
    } else {
1175
        scale = s->c_dc_scale;
1176
    }
1177
    wrap= s->block_wrap[n];
1178
    dc_val = s->dc_val[0] + s->block_index[n];
1179

    
1180
    /* B C
1181
     * A X 
1182
     */
1183
    a = dc_val[ - 1];
1184
    b = dc_val[ - 1 - wrap];
1185
    c = dc_val[ - wrap];
1186

    
1187
    if (abs(a - b) < abs(b - c)) {
1188
        pred = c;
1189
        *dir_ptr = 1; /* top */
1190
    } else {
1191
        pred = a;
1192
        *dir_ptr = 0; /* left */
1193
    }
1194
    /* we assume pred is positive */
1195
#ifdef ARCH_X86
1196
        asm volatile (
1197
                "xorl %%edx, %%edx        \n\t"
1198
                "mul %%ecx                \n\t"
1199
                : "=d" (pred), "=a"(dummy)
1200
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1201
        );
1202
#else
1203
    pred = (pred + (scale >> 1)) / scale;
1204
#endif
1205

    
1206
    /* prepare address for prediction update */
1207
    *dc_val_ptr = &dc_val[0];
1208

    
1209
    return pred;
1210
}
1211

    
1212
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1213
                   int dir)
1214
{
1215
    int i;
1216
    INT16 *ac_val, *ac_val1;
1217

    
1218
    /* find prediction */
1219
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1220
    ac_val1 = ac_val;
1221
    if (s->ac_pred) {
1222
        if (dir == 0) {
1223
            /* left prediction */
1224
            ac_val -= 16;
1225
            for(i=1;i<8;i++) {
1226
                block[block_permute_op(i*8)] += ac_val[i];
1227
            }
1228
        } else {
1229
            /* top prediction */
1230
            ac_val -= 16 * s->block_wrap[n];
1231
            for(i=1;i<8;i++) {
1232
                block[block_permute_op(i)] += ac_val[i + 8];
1233
            }
1234
        }
1235
    }
1236
    /* left copy */
1237
    for(i=1;i<8;i++)
1238
        ac_val1[i] = block[block_permute_op(i * 8)];
1239
    /* top copy */
1240
    for(i=1;i<8;i++)
1241
        ac_val1[8 + i] = block[block_permute_op(i)];
1242
}
1243

    
1244
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1245
                              int dir)
1246
{
1247
    int i;
1248
    INT16 *ac_val;
1249

    
1250
    /* find prediction */
1251
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1252
 
1253
    if (dir == 0) {
1254
        /* left prediction */
1255
        ac_val -= 16;
1256
        for(i=1;i<8;i++) {
1257
            block[block_permute_op(i*8)] -= ac_val[i];
1258
        }
1259
    } else {
1260
        /* top prediction */
1261
        ac_val -= 16 * s->block_wrap[n];
1262
        for(i=1;i<8;i++) {
1263
            block[block_permute_op(i)] -= ac_val[i + 8];
1264
        }
1265
    }
1266
}
1267

    
1268
static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)
1269
{
1270
#if 1
1271
    level+=256;
1272
    if (n < 4) {
1273
        /* luminance */
1274
        put_bits(&s->pb, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1275
    } else {
1276
        /* chrominance */
1277
        put_bits(&s->pb, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1278
    }
1279
#else
1280
    int size, v;
1281
    /* find number of bits */
1282
    size = 0;
1283
    v = abs(level);
1284
    while (v) {
1285
        v >>= 1;
1286
        size++;
1287
    }
1288

    
1289
    if (n < 4) {
1290
        /* luminance */
1291
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1292
    } else {
1293
        /* chrominance */
1294
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1295
    }
1296

    
1297
    /* encode remaining bits */
1298
    if (size > 0) {
1299
        if (level < 0)
1300
            level = (-level) ^ ((1 << size) - 1);
1301
        put_bits(&s->pb, size, level);
1302
        if (size > 8)
1303
            put_bits(&s->pb, 1, 1);
1304
    }
1305
#endif
1306
}
1307

    
1308
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table)
1309
{
1310
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
1311
    int code;
1312
    const RLTable *rl;
1313

    
1314
    if (s->mb_intra) {
1315
        /* mpeg4 based DC predictor */
1316
        mpeg4_encode_dc(s, intra_dc, n);
1317
        i = 1;
1318
        rl = &rl_intra;
1319
    } else {
1320
        i = 0;
1321
        rl = &rl_inter;
1322
    }
1323

    
1324
    /* AC coefs */
1325
    last_index = s->block_last_index[n];
1326
    last_non_zero = i - 1;
1327
    for (; i <= last_index; i++) {
1328
        j = scan_table[i];
1329
        level = block[j];
1330
        if (level) {
1331
            run = i - last_non_zero - 1;
1332
            last = (i == last_index);
1333
            sign = 0;
1334
            slevel = level;
1335
            if (level < 0) {
1336
                sign = 1;
1337
                level = -level;
1338
            }
1339
            code = get_rl_index(rl, last, run, level);
1340
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1341
            if (code == rl->n) {
1342
                int level1, run1;
1343
                level1 = level - rl->max_level[last][run];
1344
                if (level1 < 1) 
1345
                    goto esc2;
1346
                code = get_rl_index(rl, last, run, level1);
1347
                if (code == rl->n) {
1348
                esc2:
1349
                    put_bits(&s->pb, 1, 1);
1350
                    if (level > MAX_LEVEL)
1351
                        goto esc3;
1352
                    run1 = run - rl->max_run[last][level] - 1;
1353
                    if (run1 < 0)
1354
                        goto esc3;
1355
                    code = get_rl_index(rl, last, run1, level);
1356
                    if (code == rl->n) {
1357
                    esc3:
1358
                        /* third escape */
1359
                        put_bits(&s->pb, 1, 1);
1360
                        put_bits(&s->pb, 1, last);
1361
                        put_bits(&s->pb, 6, run);
1362
                        put_bits(&s->pb, 1, 1);
1363
                        put_bits(&s->pb, 12, slevel & 0xfff);
1364
                        put_bits(&s->pb, 1, 1);
1365
                    } else {
1366
                        /* second escape */
1367
                        put_bits(&s->pb, 1, 0);
1368
                        put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1369
                        put_bits(&s->pb, 1, sign);
1370
                    }
1371
                } else {
1372
                    /* first escape */
1373
                    put_bits(&s->pb, 1, 0);
1374
                    put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1375
                    put_bits(&s->pb, 1, sign);
1376
                }
1377
            } else {
1378
                put_bits(&s->pb, 1, sign);
1379
            }
1380
            last_non_zero = i;
1381
        }
1382
    }
1383
}
1384

    
1385

    
1386

    
1387
/***********************************************/
1388
/* decoding */
1389

    
1390
static VLC intra_MCBPC_vlc;
1391
static VLC inter_MCBPC_vlc;
1392
static VLC cbpy_vlc;
1393
static VLC mv_vlc;
1394
static VLC dc_lum, dc_chrom;
1395
static VLC sprite_trajectory;
1396
static VLC mb_type_b_vlc;
1397

    
1398
void init_rl(RLTable *rl)
1399
{
1400
    INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1401
    UINT8 index_run[MAX_RUN+1];
1402
    int last, run, level, start, end, i;
1403

    
1404
    /* compute max_level[], max_run[] and index_run[] */
1405
    for(last=0;last<2;last++) {
1406
        if (last == 0) {
1407
            start = 0;
1408
            end = rl->last;
1409
        } else {
1410
            start = rl->last;
1411
            end = rl->n;
1412
        }
1413

    
1414
        memset(max_level, 0, MAX_RUN + 1);
1415
        memset(max_run, 0, MAX_LEVEL + 1);
1416
        memset(index_run, rl->n, MAX_RUN + 1);
1417
        for(i=start;i<end;i++) {
1418
            run = rl->table_run[i];
1419
            level = rl->table_level[i];
1420
            if (index_run[run] == rl->n)
1421
                index_run[run] = i;
1422
            if (level > max_level[run])
1423
                max_level[run] = level;
1424
            if (run > max_run[level])
1425
                max_run[level] = run;
1426
        }
1427
        rl->max_level[last] = malloc(MAX_RUN + 1);
1428
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1429
        rl->max_run[last] = malloc(MAX_LEVEL + 1);
1430
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1431
        rl->index_run[last] = malloc(MAX_RUN + 1);
1432
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1433
    }
1434
}
1435

    
1436
void init_vlc_rl(RLTable *rl)
1437
{
1438
    init_vlc(&rl->vlc, 9, rl->n + 1, 
1439
             &rl->table_vlc[0][1], 4, 2,
1440
             &rl->table_vlc[0][0], 4, 2);
1441
}
1442

    
1443
/* init vlcs */
1444

    
1445
/* XXX: find a better solution to handle static init */
1446
void h263_decode_init_vlc(MpegEncContext *s)
1447
{
1448
    static int done = 0;
1449

    
1450
    if (!done) {
1451
        done = 1;
1452

    
1453
        init_vlc(&intra_MCBPC_vlc, 6, 8, 
1454
                 intra_MCBPC_bits, 1, 1,
1455
                 intra_MCBPC_code, 1, 1);
1456
        init_vlc(&inter_MCBPC_vlc, 9, 25, 
1457
                 inter_MCBPC_bits, 1, 1,
1458
                 inter_MCBPC_code, 1, 1);
1459
        init_vlc(&cbpy_vlc, 6, 16,
1460
                 &cbpy_tab[0][1], 2, 1,
1461
                 &cbpy_tab[0][0], 2, 1);
1462
        init_vlc(&mv_vlc, 9, 33,
1463
                 &mvtab[0][1], 2, 1,
1464
                 &mvtab[0][0], 2, 1);
1465
        init_rl(&rl_inter);
1466
        init_rl(&rl_intra);
1467
        init_rl(&rl_intra_aic);
1468
        init_vlc_rl(&rl_inter);
1469
        init_vlc_rl(&rl_intra);
1470
        init_vlc_rl(&rl_intra_aic);
1471
        init_vlc(&dc_lum, 9, 13,
1472
                 &DCtab_lum[0][1], 2, 1,
1473
                 &DCtab_lum[0][0], 2, 1);
1474
        init_vlc(&dc_chrom, 9, 13,
1475
                 &DCtab_chrom[0][1], 2, 1,
1476
                 &DCtab_chrom[0][0], 2, 1);
1477
        init_vlc(&sprite_trajectory, 9, 15,
1478
                 &sprite_trajectory_tab[0][1], 4, 2,
1479
                 &sprite_trajectory_tab[0][0], 4, 2);
1480
        init_vlc(&mb_type_b_vlc, 4, 4,
1481
                 &mb_type_b_tab[0][1], 2, 1,
1482
                 &mb_type_b_tab[0][0], 2, 1);
1483
    }
1484
}
1485

    
1486
int h263_decode_gob_header(MpegEncContext *s)
1487
{
1488
    unsigned int val, gfid;
1489
    
1490
    /* Check for GOB Start Code */
1491
    val = show_bits(&s->gb, 16);
1492
    if (val == 0) {
1493
        /* We have a GBSC probably with GSTUFF */
1494
        skip_bits(&s->gb, 16); /* Drop the zeros */
1495
        while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1496
#ifdef DEBUG
1497
        fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1498
#endif
1499
        s->gob_number = get_bits(&s->gb, 5); /* GN */
1500
        gfid = get_bits(&s->gb, 2); /* GFID */
1501
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1502
#ifdef DEBUG
1503
        fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1504
#endif
1505
        return 1;
1506
    }
1507
    return 0;
1508
            
1509
}
1510

    
1511
static inline void memsetw(short *tab, int val, int n)
1512
{
1513
    int i;
1514
    for(i=0;i<n;i++)
1515
        tab[i] = val;
1516
}
1517

    
1518
static int mpeg4_resync(MpegEncContext *s)
1519
{
1520
    int state, v, bits;
1521
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1522
    int header_extension=0, mb_num;
1523
    int c_wrap, c_xy, l_wrap, l_xy;
1524
    int time_increment;
1525
//printf("resync at %d %d\n", s->mb_x, s->mb_y);
1526
//printf("%X\n", show_bits(&s->gb, 24));
1527

    
1528
    if( get_bits_count(&s->gb) > s->gb.size*8-32)
1529
        return 0;
1530

    
1531
    align_get_bits(&s->gb);
1532
    state = 0xff;
1533
    for(;;) {
1534
        v = get_bits(&s->gb, 8);
1535
//printf("%X ", v);
1536
        state = ((state << 8) | v) & 0xffff;
1537
        if (state == 0) break;
1538
        if( get_bits_count(&s->gb) > s->gb.size*8-32){
1539
            printf("resync failed\n");
1540
            return -1;
1541
        }
1542
    }
1543
//printf("%X\n", show_bits(&s->gb, 24));
1544
    bits=0;
1545
    while(!get_bits1(&s->gb) && bits<30) bits++;
1546
    if(s->pict_type == P_TYPE && bits != s->f_code-1)
1547
        printf("marker does not match f_code\n");
1548
    //FIXME check bits for B-framess
1549
//printf("%X\n", show_bits(&s->gb, 24));
1550

    
1551
    if(s->shape != RECT_SHAPE){
1552
        header_extension= get_bits1(&s->gb);
1553
        //FIXME more stuff here
1554
    }
1555

    
1556
    mb_num= get_bits(&s->gb, mb_num_bits);
1557
    if(mb_num != s->mb_x + s->mb_y*s->mb_width){
1558
        printf("MB-num change not supported %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width);
1559
//        s->mb_x= mb_num % s->mb_width;
1560
//        s->mb_y= mb_num / s->mb_width;
1561
        //FIXME many vars are wrong now
1562
    } 
1563

    
1564
    if(s->shape != BIN_ONLY_SHAPE){
1565
        s->qscale= get_bits(&s->gb, 5);
1566
        h263_dc_scale(s);
1567
    }
1568

    
1569
    if(s->shape == RECT_SHAPE){
1570
        header_extension= get_bits1(&s->gb);
1571
    }
1572
    if(header_extension){
1573
        int time_incr=0;
1574
        printf("header extension not really supported\n");
1575
        while (get_bits1(&s->gb) != 0) 
1576
            time_incr++;
1577

    
1578
        check_marker(&s->gb, "before time_increment in video packed header");
1579
        time_increment= get_bits(&s->gb, s->time_increment_bits);
1580
        if(s->pict_type!=B_TYPE){
1581
            s->last_time_base= s->time_base;
1582
            s->time_base+= time_incr;
1583
            s->time= s->time_base*s->time_increment_resolution + time_increment;
1584
            s->pp_time= s->time - s->last_non_b_time;
1585
            s->last_non_b_time= s->time;
1586
        }else{
1587
            s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
1588
            s->bp_time= s->last_non_b_time - s->time;
1589
        }
1590
        check_marker(&s->gb, "before vop_coding_type in video packed header");
1591
        
1592
        skip_bits(&s->gb, 2); /* vop coding type */
1593
        //FIXME not rect stuff here
1594

    
1595
        if(s->shape != BIN_ONLY_SHAPE){
1596
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
1597

    
1598
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){
1599
                mpeg4_decode_sprite_trajectory(s);
1600
            }
1601

    
1602
            //FIXME reduced res stuff here
1603
            
1604
            if (s->pict_type != I_TYPE) {
1605
                s->f_code = get_bits(&s->gb, 3);        /* fcode_for */
1606
                if(s->f_code==0){
1607
                    printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n");
1608
                    return -1; // makes no sense to continue, as the MV decoding will break very quickly
1609
                }
1610
            }
1611
            if (s->pict_type == B_TYPE) {
1612
                s->b_code = get_bits(&s->gb, 3);
1613
            }       
1614
        }
1615

    
1616
    }
1617
    //FIXME new-pred stuff
1618

    
1619
    l_wrap= s->block_wrap[0];
1620
    l_xy= s->mb_y*l_wrap*2;
1621
    c_wrap= s->block_wrap[4];
1622
    c_xy= s->mb_y*c_wrap;
1623

    
1624
    /* clean DC */
1625
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*3);
1626
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap*2);
1627
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap*2);
1628

    
1629
    /* clean AC */
1630
    memset(s->ac_val[0] + l_xy, 0, l_wrap*3*16*sizeof(INT16));
1631
    memset(s->ac_val[1] + c_xy, 0, c_wrap*2*16*sizeof(INT16));
1632
    memset(s->ac_val[2] + c_xy, 0, c_wrap*2*16*sizeof(INT16));
1633

    
1634
    /* clean MV */
1635
    memset(s->motion_val + l_xy, 0, l_wrap*3*2*sizeof(INT16));
1636
//    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
1637
    s->resync_x_pos= s->mb_x;
1638
    s->first_slice_line=1;
1639

    
1640
    return 0;
1641
}
1642

    
1643
int h263_decode_mb(MpegEncContext *s,
1644
                   DCTELEM block[6][64])
1645
{
1646
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1647
    INT16 *mot_val;
1648
    static INT8 quant_tab[4] = { -1, -2, 1, 2 };
1649

    
1650
    if(s->resync_marker){
1651
        if(   s->resync_x_pos == s->mb_x+1
1652
           || s->resync_x_pos == s->mb_x){
1653
            /* f*ck mpeg4
1654
               this is here so we dont need to slowdown h263_pred_motion with it */
1655
            if(s->resync_x_pos == s->mb_x+1 && s->mb_x==0){
1656
                int xy= s->block_index[0] - s->block_wrap[0];
1657
                s->motion_val[xy][0]= s->motion_val[xy+2][0];
1658
                s->motion_val[xy][1]= s->motion_val[xy+2][1];
1659
            }
1660

    
1661
            s->first_slice_line=0; 
1662
            s->resync_x_pos=0; // isnt needed but for cleanness sake ;)
1663
        }
1664

    
1665
        if(show_aligned_bits(&s->gb, 1, 16) == 0){
1666
            if( mpeg4_resync(s) < 0 ) return -1;
1667
            
1668
        }
1669
    }
1670

    
1671
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
1672
        if (get_bits1(&s->gb)) {
1673
            /* skip mb */
1674
            s->mb_intra = 0;
1675
            for(i=0;i<6;i++)
1676
                s->block_last_index[i] = -1;
1677
            s->mv_dir = MV_DIR_FORWARD;
1678
            s->mv_type = MV_TYPE_16X16;
1679
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
1680
                const int a= s->sprite_warping_accuracy;
1681
//                int l = (1 << (s->f_code - 1)) * 32;
1682

    
1683
                s->mcsel=1;
1684
                if(s->divx_version==500 && s->divx_build==413){
1685
                    s->mv[0][0][0] = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
1686
                    s->mv[0][0][1] = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
1687
                }else{
1688
                    s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1689
                    s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1690
                }
1691
/*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
1692
                else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
1693
                if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
1694
                else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
1695

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

    
1812
        s->mb_intra = 0; //B-frames never contain intra blocks
1813
        s->mcsel=0;      //     ...               true gmc blocks
1814

    
1815
        if(s->mb_x==0){
1816
            s->last_mv[0][0][0]= 
1817
            s->last_mv[0][0][1]= 
1818
            s->last_mv[1][0][0]= 
1819
            s->last_mv[1][0][1]= 0;
1820
//            printf("\n");
1821
        }
1822

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

    
1826
        if(s->mb_skiped){
1827
                /* skip mb */
1828
            for(i=0;i<6;i++)
1829
                s->block_last_index[i] = -1;
1830

    
1831
            s->mv_dir = MV_DIR_FORWARD;
1832
            s->mv_type = MV_TYPE_16X16;
1833
            s->mv[0][0][0] = 0;
1834
            s->mv[0][0][1] = 0;
1835
            s->mv[1][0][0] = 0;
1836
            s->mv[1][0][1] = 0;
1837
//FIXME is this correct?
1838
/*            s->last_mv[0][0][0]=
1839
            s->last_mv[0][0][1]=0;*/
1840
//            printf("S");
1841
            return 0;
1842
        }
1843

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

    
1898
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1899
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1900
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1901
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1902
//            printf("I");
1903
            break;
1904
        case 2: 
1905
            s->mv_dir = MV_DIR_BACKWARD;
1906
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1907
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1908
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1909
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1910
//            printf("B");
1911
            break;
1912
        case 3:
1913
            s->mv_dir = MV_DIR_FORWARD;
1914
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1915
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1916
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1917
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1918
//            printf("F");
1919
            break;
1920
        default: return -1;
1921
        }
1922
    } else { /* I-Frame */
1923
        cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
1924
        if (cbpc < 0)
1925
            return -1;
1926
        dquant = cbpc & 4;
1927
        s->mb_intra = 1;
1928
intra:
1929
        s->ac_pred = 0;
1930
        if (s->h263_pred || s->h263_aic) {
1931
            s->ac_pred = get_bits1(&s->gb);
1932
            if (s->ac_pred && s->h263_aic)
1933
                s->h263_aic_dir = get_bits1(&s->gb);
1934
        }
1935
        if (s->h263_aic) {
1936
            s->y_dc_scale = 2 * s->qscale;
1937
            s->c_dc_scale = 2 * s->qscale;
1938
        }
1939
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
1940
        cbp = (cbpc & 3) | (cbpy << 2);
1941
        if (dquant) {
1942
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
1943
            if (s->qscale < 1)
1944
                s->qscale = 1;
1945
            else if (s->qscale > 31)
1946
                s->qscale = 31;
1947
            h263_dc_scale(s);
1948
        }
1949
    }
1950

    
1951
    /* decode each block */
1952
    if (s->h263_pred) {
1953
        for (i = 0; i < 6; i++) {
1954
            if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1955
                return -1;
1956
        }
1957
    } else {
1958
        for (i = 0; i < 6; i++) {
1959
            if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1960
                return -1;
1961
        }
1962
    }
1963
    return 0;
1964
}
1965

    
1966
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
1967
{
1968
    int code, val, sign, shift, l, m;
1969

    
1970
    code = get_vlc(&s->gb, &mv_vlc);
1971
    if (code < 0)
1972
        return 0xffff;
1973

    
1974
    if (code == 0)
1975
        return pred;
1976
    sign = get_bits1(&s->gb);
1977
    shift = f_code - 1;
1978
    val = (code - 1) << shift;
1979
    if (shift > 0)
1980
        val |= get_bits(&s->gb, shift);
1981
    val++;
1982
    if (sign)
1983
        val = -val;
1984
    val += pred;
1985
    
1986
    /* modulo decoding */
1987
    if (!s->h263_long_vectors) {
1988
        l = (1 << (f_code - 1)) * 32;
1989
        m = 2 * l;
1990
        if (val < -l) {
1991
            val += m;
1992
        } else if (val >= l) {
1993
            val -= m;
1994
        }
1995
    } else {
1996
        /* horrible h263 long vector mode */
1997
        if (pred < -31 && val < -63)
1998
            val += 64;
1999
        if (pred > 32 && val > 63)
2000
            val -= 64;
2001
        
2002
    }
2003
    return val;
2004
}
2005

    
2006
/* Decodes RVLC of H.263+ UMV */
2007
static int h263p_decode_umotion(MpegEncContext * s, int pred)
2008
{
2009
   int code = 0, sign;
2010
   
2011
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
2012
      return pred;
2013
   
2014
   code = 2 + get_bits1(&s->gb);
2015
   
2016
   while (get_bits1(&s->gb))
2017
   {
2018
      code <<= 1;
2019
      code += get_bits1(&s->gb);
2020
   }
2021
   sign = code & 1;
2022
   code >>= 1;
2023
   
2024
   code = (sign) ? (pred - code) : (pred + code);
2025
#ifdef DEBUG
2026
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
2027
#endif
2028
   return code;   
2029

    
2030
}
2031

    
2032
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
2033
                             int n, int coded)
2034
{
2035
    int code, level, i, j, last, run;
2036
    RLTable *rl = &rl_inter;
2037
    const UINT8 *scan_table;
2038

    
2039
    scan_table = zigzag_direct;
2040
    if (s->h263_aic && s->mb_intra) {
2041
        rl = &rl_intra_aic;
2042
        i = 0;
2043
        if (s->ac_pred) {
2044
            if (s->h263_aic_dir) 
2045
                scan_table = ff_alternate_vertical_scan; /* left */
2046
            else
2047
                scan_table = ff_alternate_horizontal_scan; /* top */
2048
        }
2049
    } else if (s->mb_intra) {
2050
        /* DC coef */
2051
        if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
2052
            int component, diff;
2053
            component = (n <= 3 ? 0 : n - 4 + 1);
2054
            level = s->last_dc[component];
2055
            if (s->rv10_first_dc_coded[component]) {
2056
                diff = rv_decode_dc(s, n);
2057
                if (diff == 0xffff)
2058
                    return -1;
2059
                level += diff;
2060
                level = level & 0xff; /* handle wrap round */
2061
                s->last_dc[component] = level;
2062
            } else {
2063
                s->rv10_first_dc_coded[component] = 1;
2064
            }
2065
        } else {
2066
            level = get_bits(&s->gb, 8);
2067
            if (level == 255)
2068
                level = 128;
2069
        }
2070
        block[0] = level;
2071
        i = 1;
2072
    } else {
2073
        i = 0;
2074
    }
2075
    if (!coded) {
2076
        if (s->mb_intra && s->h263_aic)
2077
            goto not_coded;
2078
        s->block_last_index[n] = i - 1;
2079
        return 0;
2080
    }
2081

    
2082
    for(;;) {
2083
        code = get_vlc(&s->gb, &rl->vlc);
2084
        if (code < 0)
2085
            return -1;
2086
        if (code == rl->n) {
2087
            /* escape */
2088
            last = get_bits1(&s->gb);
2089
            run = get_bits(&s->gb, 6);
2090
            level = (INT8)get_bits(&s->gb, 8);
2091
            if (s->h263_rv10 && level == -128) {
2092
                /* XXX: should patch encoder too */
2093
                level = get_bits(&s->gb, 12);
2094
                level = (level << 20) >> 20;
2095
            }
2096
        } else {
2097
            run = rl->table_run[code];
2098
            level = rl->table_level[code];
2099
            last = code >= rl->last;
2100
            if (get_bits1(&s->gb))
2101
                level = -level;
2102
        }
2103
        i += run;
2104
        if (i >= 64)
2105
            return -1;
2106
        j = scan_table[i];
2107
        block[j] = level;
2108
        if (last)
2109
            break;
2110
        i++;
2111
    }
2112
not_coded:    
2113
    if (s->mb_intra && s->h263_aic) {
2114
        h263_pred_acdc(s, block, n);
2115
        i = 63;
2116
    }
2117
    s->block_last_index[n] = i;
2118
    return 0;
2119
}
2120

    
2121
static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
2122
{
2123
    int level, pred, code;
2124
    UINT16 *dc_val;
2125

    
2126
    if (n < 4) 
2127
        code = get_vlc(&s->gb, &dc_lum);
2128
    else 
2129
        code = get_vlc(&s->gb, &dc_chrom);
2130
    if (code < 0)
2131
        return -1;
2132
    if (code == 0) {
2133
        level = 0;
2134
    } else {
2135
        level = get_bits(&s->gb, code);
2136
        if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
2137
            level = - (level ^ ((1 << code) - 1));
2138
        if (code > 8)
2139
            skip_bits1(&s->gb); /* marker */
2140
    }
2141

    
2142
    pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
2143
    level += pred;
2144
    if (level < 0)
2145
        level = 0;
2146
    if (n < 4) {
2147
        *dc_val = level * s->y_dc_scale;
2148
    } else {
2149
        *dc_val = level * s->c_dc_scale;
2150
    }
2151
    return level;
2152
}
2153

    
2154
static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
2155
                              int n, int coded)
2156
{
2157
    int code, level, i, j, last, run;
2158
    int dc_pred_dir;
2159
    RLTable *rl;
2160
    const UINT8 *scan_table;
2161

    
2162
    if (s->mb_intra) {
2163
        /* DC coef */
2164
        level = mpeg4_decode_dc(s, n, &dc_pred_dir);
2165
        if (level < 0)
2166
            return -1;
2167
        block[0] = level;
2168
        i = 1;
2169
        if (!coded) 
2170
            goto not_coded;
2171
        rl = &rl_intra;
2172
        if (s->ac_pred) {
2173
            if (dc_pred_dir == 0) 
2174
                scan_table = ff_alternate_vertical_scan; /* left */
2175
            else
2176
                scan_table = ff_alternate_horizontal_scan; /* top */
2177
        } else {
2178
            scan_table = zigzag_direct;
2179
        }
2180
    } else {
2181
        i = 0;
2182
        if (!coded) {
2183
            s->block_last_index[n] = i - 1;
2184
            return 0;
2185
        }
2186
        rl = &rl_inter;
2187
        scan_table = zigzag_direct;
2188
    }
2189

    
2190
    for(;;) {
2191
        code = get_vlc(&s->gb, &rl->vlc);
2192
        if (code < 0)
2193
            return -1;
2194
        if (code == rl->n) {
2195
            /* escape */
2196
            if (get_bits1(&s->gb) != 0) {
2197
                if (get_bits1(&s->gb) != 0) {
2198
                    /* third escape */
2199
                    last = get_bits1(&s->gb);
2200
                    run = get_bits(&s->gb, 6);
2201
                    get_bits1(&s->gb); /* marker */
2202
                    level = get_bits(&s->gb, 12);
2203
                    level = (level << 20) >> 20; /* sign extend */
2204
                    skip_bits1(&s->gb); /* marker */
2205
                } else {
2206
                    /* second escape */
2207
                    code = get_vlc(&s->gb, &rl->vlc);
2208
                    if (code < 0 || code >= rl->n)
2209
                        return -1;
2210
                    run = rl->table_run[code];
2211
                    level = rl->table_level[code];
2212
                    last = code >= rl->last;
2213
                    run += rl->max_run[last][level] + 1;
2214
                    if (get_bits1(&s->gb))
2215
                        level = -level;
2216
                }
2217
            } else {
2218
                /* first escape */
2219
                code = get_vlc(&s->gb, &rl->vlc);
2220
                if (code < 0 || code >= rl->n)
2221
                    return -1;
2222
                run = rl->table_run[code];
2223
                level = rl->table_level[code];
2224
                last = code >= rl->last;
2225
                level += rl->max_level[last][run];
2226
                if (get_bits1(&s->gb))
2227
                    level = -level;
2228
            }
2229
        } else {
2230
            run = rl->table_run[code];
2231
            level = rl->table_level[code];
2232
            last = code >= rl->last;
2233
            if (get_bits1(&s->gb))
2234
                level = -level;
2235
        }
2236
        i += run;
2237
        if (i >= 64)
2238
            return -1;
2239
        j = scan_table[i];
2240
        block[j] = level;
2241
        i++;
2242
        if (last)
2243
            break;
2244
    }
2245
 not_coded:
2246
    if (s->mb_intra) {
2247
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
2248
        if (s->ac_pred) {
2249
            i = 64; /* XXX: not optimal */
2250
        }
2251
    }
2252
    s->block_last_index[n] = i - 1;
2253
    return 0;
2254
}
2255

    
2256
/* most is hardcoded. should extend to handle all h263 streams */
2257
int h263_decode_picture_header(MpegEncContext *s)
2258
{
2259
    int format, width, height;
2260

    
2261
    /* picture header */
2262
    if (get_bits(&s->gb, 22) != 0x20)
2263
        return -1;
2264
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
2265
    
2266
    if (get_bits1(&s->gb) != 1)
2267
        return -1;        /* marker */
2268
    if (get_bits1(&s->gb) != 0)
2269
        return -1;        /* h263 id */
2270
    skip_bits1(&s->gb);        /* split screen off */
2271
    skip_bits1(&s->gb);        /* camera  off */
2272
    skip_bits1(&s->gb);        /* freeze picture release off */
2273

    
2274
    /* Reset GOB number */
2275
    s->gob_number = 0;
2276
        
2277
    format = get_bits(&s->gb, 3);
2278

    
2279
    if (format != 7 && format != 6) {
2280
        s->h263_plus = 0;
2281
        /* H.263v1 */
2282
        width = h263_format[format][0];
2283
        height = h263_format[format][1];
2284
        if (!width)
2285
            return -1;
2286
        
2287
        s->width = width;
2288
        s->height = height;
2289
        s->pict_type = I_TYPE + get_bits1(&s->gb);
2290

    
2291
        s->unrestricted_mv = get_bits1(&s->gb); 
2292
        s->h263_long_vectors = s->unrestricted_mv;
2293

    
2294
        if (get_bits1(&s->gb) != 0)
2295
            return -1;        /* SAC: off */
2296
        if (get_bits1(&s->gb) != 0) {
2297
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
2298
        }   
2299
        
2300
        if (get_bits1(&s->gb) != 0)
2301
            return -1;        /* not PB frame */
2302

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

    
2374
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
2375
{
2376
    int i;
2377
    int a= 2<<s->sprite_warping_accuracy;
2378
    int rho= 3-s->sprite_warping_accuracy;
2379
    int r=16/a;
2380
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
2381
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
2382
    int sprite_ref[4][2];
2383
    int virtual_ref[2][2];
2384
    int w2, h2;
2385
    int alpha=0, beta=0;
2386
    int w= s->width;
2387
    int h= s->height;
2388
//printf("SP %d\n", s->sprite_warping_accuracy);
2389
    for(i=0; i<s->num_sprite_warping_points; i++){
2390
        int length;
2391
        int x=0, y=0;
2392

    
2393
        length= get_vlc(&s->gb, &sprite_trajectory);
2394
        if(length){
2395
            x= get_bits(&s->gb, length);
2396
//printf("lx %d %d\n", length, x);
2397
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
2398
                x = - (x ^ ((1 << length) - 1));
2399
        }
2400
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
2401
        
2402
        length= get_vlc(&s->gb, &sprite_trajectory);
2403
        if(length){
2404
            y=get_bits(&s->gb, length);
2405
//printf("ly %d %d\n", length, y);
2406
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
2407
                y = - (y ^ ((1 << length) - 1));
2408
        }
2409
        skip_bits1(&s->gb); /* marker bit */
2410
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
2411
//if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
2412
//x=y=0;
2413
        d[i][0]= x;
2414
        d[i][1]= y;
2415
    }
2416

    
2417
    while((1<<alpha)<w) alpha++;
2418
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
2419
    w2= 1<<alpha;
2420
    h2= 1<<beta;
2421

    
2422
// Note, the 4th point isnt used for GMC
2423
    if(s->divx_version==500 && s->divx_build==413){
2424
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
2425
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
2426
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
2427
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
2428
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
2429
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
2430
    } else {
2431
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
2432
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
2433
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
2434
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
2435
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
2436
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
2437
    }
2438
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
2439
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
2440
    
2441
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
2442
// perhaps it should be reordered to be more readable ...
2443
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
2444
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
2445
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
2446
        + 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);
2447
    virtual_ref[0][1]= 16*vop_ref[0][1] 
2448
        + 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);
2449
    virtual_ref[1][0]= 16*vop_ref[0][0] 
2450
        + 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);
2451
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
2452
        + 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);
2453

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

    
2561
//printf("%d %d %d %d\n", d[0][0], d[0][1], s->sprite_offset[0][0], s->sprite_offset[0][1]);
2562
}
2563

    
2564
/* decode mpeg4 VOP header */
2565
int mpeg4_decode_picture_header(MpegEncContext * s)
2566
{
2567
    int time_incr, startcode, state, v;
2568
    int time_increment;
2569

    
2570
 redo:
2571
    /* search next start code */
2572
    align_get_bits(&s->gb);
2573
    state = 0xff;
2574
    for(;;) {
2575
        v = get_bits(&s->gb, 8);
2576
        if (state == 0x000001) {
2577
            state = ((state << 8) | v) & 0xffffff;
2578
            startcode = state;
2579
            break;
2580
        }
2581
        state = ((state << 8) | v) & 0xffffff;
2582
        if( get_bits_count(&s->gb) > s->gb.size*8-32){
2583
            if(s->gb.size>50){
2584
                printf("no VOP startcode found, frame size was=%d\n", s->gb.size);
2585
                return -1;
2586
            }else{
2587
                printf("frame skip\n");
2588
                return FRAME_SKIPED;
2589
            }
2590
        }
2591
    }
2592
//printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
2593
    if (startcode == 0x120) { // Video Object Layer
2594
        int width, height, vo_ver_id;
2595

    
2596
        /* vol header */
2597
        skip_bits(&s->gb, 1); /* random access */
2598
        s->vo_type= get_bits(&s->gb, 8);
2599
        if (get_bits1(&s->gb) != 0) { /* is_ol_id */
2600
            vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
2601
            skip_bits(&s->gb, 3); /* vo_priority */
2602
        } else {
2603
            vo_ver_id = 1;
2604
        }
2605
        
2606
        s->aspect_ratio_info= get_bits(&s->gb, 4);
2607
        if(s->aspect_ratio_info == EXTENDET_PAR){
2608
            skip_bits(&s->gb, 8); //par_width
2609
            skip_bits(&s->gb, 8); // par_height
2610
        }
2611

    
2612
        if(get_bits1(&s->gb)){ /* vol control parameter */
2613
            int chroma_format= get_bits(&s->gb, 2);
2614
            if(chroma_format!=1){
2615
                printf("illegal chroma format\n");
2616
            }
2617
            s->low_delay= get_bits1(&s->gb);
2618
            if(get_bits1(&s->gb)){ /* vbv parameters */
2619
                printf("vbv parameters not supported\n");
2620
                return -1;
2621
            }
2622
        }else{
2623
            s->low_delay=0;
2624
        }
2625

    
2626
        s->shape = get_bits(&s->gb, 2); /* vol shape */
2627
        if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
2628
        if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
2629
            printf("Gray shape not supported\n");
2630
            skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
2631
        }
2632

    
2633
        skip_bits1(&s->gb);   /* marker */
2634
        
2635
        s->time_increment_resolution = get_bits(&s->gb, 16);
2636
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
2637
        if (s->time_increment_bits < 1)
2638
            s->time_increment_bits = 1;
2639
        skip_bits1(&s->gb);   /* marker */
2640

    
2641
        if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
2642
            skip_bits(&s->gb, s->time_increment_bits);
2643
        }
2644

    
2645
        if (s->shape != BIN_ONLY_SHAPE) {
2646
            if (s->shape == RECT_SHAPE) {
2647
                skip_bits1(&s->gb);   /* marker */
2648
                width = get_bits(&s->gb, 13);
2649
                skip_bits1(&s->gb);   /* marker */
2650
                height = get_bits(&s->gb, 13);
2651
                skip_bits1(&s->gb);   /* marker */
2652
                if(width && height){ /* they should be non zero but who knows ... */
2653
                    s->width = width;
2654
                    s->height = height;
2655
//                    printf("width/height: %d %d\n", width, height);
2656
                }
2657
            }
2658
            
2659
            if(get_bits1(&s->gb)) printf("interlaced not supported\n");   /* interlaced */
2660
            if(!get_bits1(&s->gb)) printf("OBMC not supported\n");   /* OBMC Disable */
2661
            if (vo_ver_id == 1) {
2662
                s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
2663
            } else {
2664
                s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
2665
            }
2666
            if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
2667
            if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
2668
                if(s->vol_sprite_usage==STATIC_SPRITE){
2669
                    s->sprite_width = get_bits(&s->gb, 13);
2670
                    skip_bits1(&s->gb); /* marker */
2671
                    s->sprite_height= get_bits(&s->gb, 13);
2672
                    skip_bits1(&s->gb); /* marker */
2673
                    s->sprite_left  = get_bits(&s->gb, 13);
2674
                    skip_bits1(&s->gb); /* marker */
2675
                    s->sprite_top   = get_bits(&s->gb, 13);
2676
                    skip_bits1(&s->gb); /* marker */
2677
                }
2678
                s->num_sprite_warping_points= get_bits(&s->gb, 6);
2679
                s->sprite_warping_accuracy = get_bits(&s->gb, 2);
2680
                s->sprite_brightness_change= get_bits1(&s->gb);
2681
                if(s->vol_sprite_usage==STATIC_SPRITE)
2682
                    s->low_latency_sprite= get_bits1(&s->gb);            
2683
            }
2684
            // FIXME sadct disable bit if verid!=1 && shape not rect
2685
            
2686
            if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
2687
                s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
2688
                if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
2689
                if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
2690
            } else {
2691
                s->quant_precision = 5;
2692
            }
2693
            
2694
            // FIXME a bunch of grayscale shape things
2695

    
2696
            if(get_bits1(&s->gb)){ /* vol_quant_type */
2697
                int i, j, v;
2698
                /* load default matrixes */
2699
                for(i=0; i<64; i++){
2700
                    v= ff_mpeg4_default_intra_matrix[i];
2701
                    s->intra_matrix[i]= v;
2702
                    s->chroma_intra_matrix[i]= v;
2703
                    
2704
                    v= ff_mpeg4_default_non_intra_matrix[i];
2705
                    s->non_intra_matrix[i]= v;
2706
                    s->chroma_non_intra_matrix[i]= v;
2707
                }
2708

    
2709
                /* load custom intra matrix */
2710
                if(get_bits1(&s->gb)){
2711
                    for(i=0; i<64; i++){
2712
                        v= get_bits(&s->gb, 8);
2713
                        if(v==0) break;
2714

    
2715
                        j= zigzag_direct[i];
2716
                        s->intra_matrix[j]= v;
2717
                        s->chroma_intra_matrix[j]= v;
2718
                    }
2719
                }
2720

    
2721
                /* load custom non intra matrix */
2722
                if(get_bits1(&s->gb)){
2723
                    for(i=0; i<64; i++){
2724
                        v= get_bits(&s->gb, 8);
2725
                        if(v==0) break;
2726

    
2727
                        j= zigzag_direct[i];
2728
                        s->non_intra_matrix[j]= v;
2729
                        s->chroma_non_intra_matrix[j]= v;
2730
                    }
2731

    
2732
                    /* replicate last value */
2733
                    for(; i<64; i++){
2734
                        j= zigzag_direct[i];
2735
                        s->non_intra_matrix[j]= v;
2736
                        s->chroma_non_intra_matrix[j]= v;
2737
                    }
2738
                }
2739

    
2740
                s->dct_unquantize= s->dct_unquantize_mpeg2;
2741

    
2742
                // FIXME a bunch of grayscale shape things
2743
            }else
2744
                s->dct_unquantize= s->dct_unquantize_h263;
2745

    
2746
            if(vo_ver_id != 1)
2747
                 s->quarter_sample= get_bits1(&s->gb);
2748
            else s->quarter_sample=0;
2749

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

    
2752
            s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */
2753

    
2754
            s->data_partioning= get_bits1(&s->gb);
2755
            if(s->data_partioning){
2756
                printf("data partitioning not supported\n");
2757
                skip_bits1(&s->gb); // reversible vlc
2758
            }
2759
            
2760
            if(vo_ver_id != 1) {
2761
                s->new_pred= get_bits1(&s->gb);
2762
                if(s->new_pred){
2763
                    printf("new pred not supported\n");
2764
                    skip_bits(&s->gb, 2); /* requested upstream message type */
2765
                    skip_bits1(&s->gb); /* newpred segment type */
2766
                }
2767
                s->reduced_res_vop= get_bits1(&s->gb);
2768
                if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
2769
            }
2770
            else{
2771
                s->new_pred=0;
2772
                s->reduced_res_vop= 0;
2773
            }
2774

    
2775
            s->scalability= get_bits1(&s->gb);
2776
            if (s->scalability) {
2777
                printf("scalability not supported\n");
2778
            }
2779
        }
2780
//printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
2781
        goto redo;
2782
    } else if (startcode == 0x1b2) { //userdata
2783
        char buf[256];
2784
        int i;
2785
        int e;
2786
        int ver, build;
2787

    
2788
//printf("user Data %X\n", show_bits(&s->gb, 32));
2789
        buf[0]= show_bits(&s->gb, 8);
2790
        for(i=1; i<256; i++){
2791
            buf[i]= show_bits(&s->gb, 16)&0xFF;
2792
            if(buf[i]==0) break;
2793
            skip_bits(&s->gb, 8);
2794
        }
2795
        buf[255]=0;
2796
        e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
2797
        if(e!=2)
2798
            e=sscanf(buf, "DivX%db%d", &ver, &build);
2799
        if(e==2){
2800
            s->divx_version= ver;
2801
            s->divx_build= build;
2802
            if(s->picture_number==0){
2803
                printf("This file was encoded with DivX%d Build%d\n", ver, build);
2804
                if(ver==500 && build==413){
2805
                    printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
2806
#if 0
2807
                }else{
2808
                    printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
2809
                           "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
2810
#endif 
2811
                }
2812
            }
2813
        }
2814
//printf("User Data: %s\n", buf);
2815
        goto redo;
2816
    } else if (startcode != 0x1b6) { //VOP
2817
        goto redo;
2818
    }
2819

    
2820
    s->pict_type = get_bits(&s->gb, 2) + 1;        /* pict type: I = 0 , P = 1 */
2821
// printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample); 
2822
    time_incr=0;
2823
    while (get_bits1(&s->gb) != 0) 
2824
        time_incr++;
2825

    
2826
    check_marker(&s->gb, "before time_increment");
2827
    time_increment= get_bits(&s->gb, s->time_increment_bits);
2828
//printf(" type:%d incr:%d increment:%d\n", s->pict_type, time_incr, time_increment);
2829
    if(s->pict_type!=B_TYPE){
2830
        s->last_time_base= s->time_base;
2831
        s->time_base+= time_incr;
2832
        s->time= s->time_base*s->time_increment_resolution + time_increment;
2833
        s->pp_time= s->time - s->last_non_b_time;
2834
        s->last_non_b_time= s->time;
2835
    }else{
2836
        s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
2837
        s->bp_time= s->last_non_b_time - s->time;
2838
        if(s->pp_time <=s->bp_time){
2839
//            printf("messed up order, seeking?, skiping current b frame\n");
2840
            return FRAME_SKIPED;
2841
        }
2842
    }
2843

    
2844
    if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
2845
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
2846
        for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
2847
            if(get_bits1(&s->gb)) break;
2848
        }
2849
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
2850
    }
2851
    /* vop coded */
2852
    if (get_bits1(&s->gb) != 1)
2853
        goto redo;
2854
//printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
2855
//s->time, s->last_non_b_time[0], s->last_non_b_time[1]);  
2856
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
2857
                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
2858
        /* rounding type for motion estimation */
2859
        s->no_rounding = get_bits1(&s->gb);
2860
    } else {
2861
        s->no_rounding = 0;
2862
    }
2863
//FIXME reduced res stuff
2864

    
2865
     if (s->shape != RECT_SHAPE) {
2866
         if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
2867
             int width, height, hor_spat_ref, ver_spat_ref;
2868
 
2869
             width = get_bits(&s->gb, 13);
2870
             skip_bits1(&s->gb);   /* marker */
2871
             height = get_bits(&s->gb, 13);
2872
             skip_bits1(&s->gb);   /* marker */
2873
             hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
2874
             skip_bits1(&s->gb);   /* marker */
2875
             ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
2876
         }
2877
         skip_bits1(&s->gb); /* change_CR_disable */
2878
 
2879
         if (get_bits1(&s->gb) != 0) {
2880
             skip_bits(&s->gb, 8); /* constant_alpha_value */
2881
         }
2882
     }
2883
//FIXME complexity estimation stuff
2884
     
2885
     if (s->shape != BIN_ONLY_SHAPE) {
2886
         int t;
2887
         t=get_bits(&s->gb, 3); /* intra dc VLC threshold */
2888
//printf("threshold %d\n", t);
2889
         //FIXME interlaced specific bits
2890
     }
2891

    
2892
     if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
2893
         if(s->num_sprite_warping_points){
2894
             mpeg4_decode_sprite_trajectory(s);
2895
         }
2896
         if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
2897
         if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
2898
     }
2899

    
2900
     if (s->shape != BIN_ONLY_SHAPE) {
2901
         /* note: we do not use quant_precision to avoid problem if no
2902
            MPEG4 vol header as it is found on some old opendivx
2903
            movies */
2904
         s->qscale = get_bits(&s->gb, 5);
2905
         if(s->qscale==0){
2906
             printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
2907
             return -1; // makes no sense to continue, as there is nothing left from the image then
2908
         }
2909
  
2910
         if (s->pict_type != I_TYPE) {
2911
             s->f_code = get_bits(&s->gb, 3);        /* fcode_for */
2912
             if(s->f_code==0){
2913
                 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
2914
                 return -1; // makes no sense to continue, as the MV decoding will break very quickly
2915
             }
2916
         }
2917
         if (s->pict_type == B_TYPE) {
2918
             s->b_code = get_bits(&s->gb, 3);
2919
//printf("b-code %d\n", s->b_code);
2920
         }
2921
//printf("quant:%d fcode:%d bcode:%d type:%d\n", s->qscale, s->f_code, s->b_code, s->pict_type);
2922
         if(!s->scalability){
2923
             if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
2924
                 skip_bits1(&s->gb); // vop shape coding type
2925
             }
2926
         }
2927
     }
2928
     s->picture_number++; // better than pic number==0 allways ;)
2929
//printf("done\n");
2930
     return 0;
2931
}
2932

    
2933
/* don't understand why they choose a different header ! */
2934
int intel_h263_decode_picture_header(MpegEncContext *s)
2935
{
2936
    int format;
2937

    
2938
    /* picture header */
2939
    if (get_bits(&s->gb, 22) != 0x20)
2940
        return -1;
2941
    skip_bits(&s->gb, 8); /* picture timestamp */
2942

    
2943
    if (get_bits1(&s->gb) != 1)
2944
        return -1;        /* marker */
2945
    if (get_bits1(&s->gb) != 0)
2946
        return -1;        /* h263 id */
2947
    skip_bits1(&s->gb);        /* split screen off */
2948
    skip_bits1(&s->gb);        /* camera  off */
2949
    skip_bits1(&s->gb);        /* freeze picture release off */
2950

    
2951
    format = get_bits(&s->gb, 3);
2952
    if (format != 7)
2953
        return -1;
2954

    
2955
    s->h263_plus = 0;
2956

    
2957
    s->pict_type = I_TYPE + get_bits1(&s->gb);
2958
    
2959
    s->unrestricted_mv = get_bits1(&s->gb); 
2960
    s->h263_long_vectors = s->unrestricted_mv;
2961

    
2962
    if (get_bits1(&s->gb) != 0)
2963
        return -1;        /* SAC: off */
2964
    if (get_bits1(&s->gb) != 0)
2965
        return -1;        /* advanced prediction mode: off */
2966
    if (get_bits1(&s->gb) != 0)
2967
        return -1;        /* not PB frame */
2968

    
2969
    /* skip unknown header garbage */
2970
    skip_bits(&s->gb, 41);
2971

    
2972
    s->qscale = get_bits(&s->gb, 5);
2973
    skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
2974

    
2975
    /* PEI */
2976
    while (get_bits1(&s->gb) != 0) {
2977
        skip_bits(&s->gb, 8);
2978
    }
2979
    s->f_code = 1;
2980
    return 0;
2981
}
2982