Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ bb71e317

History | View | Annotate | Download (99.5 KB)

1 de6d9b64 Fabrice Bellard
/*
2
 * H263/MPEG4 backend for ffmpeg encoder and decoder
3
 * Copyright (c) 2000,2001 Gerard Lantau.
4 6dbd39fe Juanjo
 * H263+ support.
5 de6d9b64 Fabrice Bellard
 * 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 45870f57 Michael Niedermayer
 *
21 91029be7 Michael Niedermayer
 * ac prediction encoding & b-frame support by Michael Niedermayer <michaelni@gmx.at>
22 de6d9b64 Fabrice Bellard
 */
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 44eb4951 Michael Niedermayer
//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 d6231b9e Michael Niedermayer
#define ABS(a) (((a)>=0)?(a):(-(a)))
34 49092244 Michael Niedermayer
#define MAX(a,b) ((a) > (b) ? (a) : (b))
35
#define MIN(a,b) ((a) < (b) ? (a) : (b))
36 44eb4951 Michael Niedermayer
37 de6d9b64 Fabrice Bellard
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
38
                              int n);
39 9dbcbd92 Michael Niedermayer
static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
40 6dbd39fe Juanjo
static void h263p_encode_umotion(MpegEncContext * s, int val);
41 de6d9b64 Fabrice Bellard
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
42 d6231b9e Michael Niedermayer
                               int n, int dc, UINT8 *scan_table);
43 6f91bcd1 Michael Niedermayer
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
44 6dbd39fe Juanjo
static int h263p_decode_umotion(MpegEncContext * s, int pred);
45 de6d9b64 Fabrice Bellard
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 d6231b9e Michael Niedermayer
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 49092244 Michael Niedermayer
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
53
54 d6231b9e Michael Niedermayer
extern UINT32 inverse[256];
55 de6d9b64 Fabrice Bellard
56 9c15096e Michael Niedermayer
static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
57 45870f57 Michael Niedermayer
static UINT8 fcode_tab[MAX_MV*2+1];
58 9d2a0355 Michael Niedermayer
static UINT8 umv_fcode_tab[MAX_MV*2+1];
59 45870f57 Michael Niedermayer
60 2a164b25 Michael Niedermayer
static UINT16 uni_DCtab_lum  [512][2];
61
static UINT16 uni_DCtab_chrom[512][2];
62
63 de6d9b64 Fabrice Bellard
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 6dbd39fe Juanjo
    int format;
85 de6d9b64 Fabrice Bellard
86
    align_put_bits(&s->pb);
87 81401c1f Juanjo
88
    /* Update the pointer to last GOB */
89 17592475 Michael Niedermayer
    s->ptr_lastgob = pbBufPtr(&s->pb);
90 81401c1f Juanjo
    s->gob_number = 0;
91
92
    put_bits(&s->pb, 22, 0x20); /* PSC */
93 bb6f51ae Michael Niedermayer
    put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / 
94 de6d9b64 Fabrice Bellard
                         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 6dbd39fe Juanjo
    
102
    format = h263_get_picture_format(s->width, s->height);
103 de6d9b64 Fabrice Bellard
    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 6dbd39fe Juanjo
        if (format == 7)
122
            put_bits(&s->pb,3,6); /* Custom Source Format */
123
        else
124
            put_bits(&s->pb, 3, format);
125
            
126 de6d9b64 Fabrice Bellard
        put_bits(&s->pb,1,0); /* Custom PCF: off */
127 544286b3 Juanjo
        s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
128
        put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
129 de6d9b64 Fabrice Bellard
        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 6dbd39fe Juanjo
                if (format == 7) {
153
            /* Custom Picture Format (CPFMT) */
154 de6d9b64 Fabrice Bellard
                
155 6dbd39fe Juanjo
            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 de6d9b64 Fabrice Bellard
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
162 544286b3 Juanjo
        if (s->umvplus)
163 de6d9b64 Fabrice Bellard
            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 644d98a4 Juanjo
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 17592475 Michael Niedermayer
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
178 644d98a4 Juanjo
        if (pdif >= s->rtp_payload_size) {
179
            /* Bad luck, packet must be cut before */
180
            align_put_bits(&s->pb);
181 81401c1f Juanjo
            flush_put_bits(&s->pb);
182
            /* Call the RTP callback to send the last GOB */
183
            if (s->rtp_callback) {
184 17592475 Michael Niedermayer
                pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
185 81401c1f Juanjo
                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
186
            }
187 17592475 Michael Niedermayer
            s->ptr_lastgob = pbBufPtr(&s->pb);
188 644d98a4 Juanjo
            put_bits(&s->pb, 17, 1); /* GBSC */
189 81401c1f Juanjo
            s->gob_number = mb_line / s->gob_index;
190 644d98a4 Juanjo
            put_bits(&s->pb, 5, s->gob_number); /* GN */
191 81401c1f Juanjo
            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
192 644d98a4 Juanjo
            put_bits(&s->pb, 5, s->qscale); /* GQUANT */
193 81401c1f Juanjo
            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
194 644d98a4 Juanjo
            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 81401c1f Juanjo
           flush_put_bits(&s->pb);
199
           /* Call the RTP callback to send the last GOB */
200
           if (s->rtp_callback) {
201 17592475 Michael Niedermayer
               pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
202 81401c1f Juanjo
               s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
203
           }
204 17592475 Michael Niedermayer
           s->ptr_lastgob = pbBufPtr(&s->pb);
205 644d98a4 Juanjo
           put_bits(&s->pb, 17, 1); /* GBSC */
206 81401c1f Juanjo
           s->gob_number = mb_line / s->gob_index;
207 644d98a4 Juanjo
           put_bits(&s->pb, 5, s->gob_number); /* GN */
208 81401c1f Juanjo
           put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
209 644d98a4 Juanjo
           put_bits(&s->pb, 5, s->qscale); /* GQUANT */
210 81401c1f Juanjo
           //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
211 644d98a4 Juanjo
           return pdif;
212
       }
213
   }
214
   return 0;
215
}
216 d6231b9e Michael Niedermayer
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 4278e7a6 Michael Niedermayer
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
226 d6231b9e Michael Niedermayer
        ac_val1= ac_val;
227
        if(dir[n]){
228 4278e7a6 Michael Niedermayer
            ac_val-= s->block_wrap[n]*16;
229 d6231b9e Michael Niedermayer
            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 9dbcbd92 Michael Niedermayer
    int cbpc, cbpy, i, pred_x, pred_y;
256 098eefe1 Michael Niedermayer
    int bits;
257 644d98a4 Juanjo
    
258 d6231b9e Michael Niedermayer
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
259
    if (!s->mb_intra) {
260
        /* compute cbp */
261 9dbcbd92 Michael Niedermayer
        int cbp = 0;
262 d6231b9e Michael Niedermayer
        for (i = 0; i < 6; i++) {
263 9dbcbd92 Michael Niedermayer
            if (s->block_last_index[i] >= 0)
264
                cbp |= 1 << (5 - i);
265 d6231b9e Michael Niedermayer
        }
266 9dbcbd92 Michael Niedermayer
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 91029be7 Michael Niedermayer
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
286 9dbcbd92 Michael Niedermayer
                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 cf8039b2 Michael Niedermayer
            bits= get_bit_count(&s->pb);
306
            s->misc_bits+= bits - s->last_bits;
307
            s->last_bits=bits;
308
309 9dbcbd92 Michael Niedermayer
            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 91029be7 Michael Niedermayer
            default:
338
                printf("unknown mb type\n");
339 9dbcbd92 Michael Niedermayer
                return;
340
            }
341 cf8039b2 Michael Niedermayer
            bits= get_bit_count(&s->pb);
342 9dbcbd92 Michael Niedermayer
            s->mv_bits+= bits - s->last_bits;
343 cf8039b2 Michael Niedermayer
            s->last_bits=bits;
344 d6231b9e Michael Niedermayer
345 9dbcbd92 Michael Niedermayer
            /* 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 ee6f7861 Michael Niedermayer
                /* 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 d697b89b Michael Niedermayer
                        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 ee6f7861 Michael Niedermayer
                        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 9dbcbd92 Michael Niedermayer
            }
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 d6231b9e Michael Niedermayer
400 9dbcbd92 Michael Niedermayer
                /* 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 cf8039b2 Michael Niedermayer
            }
426 9dbcbd92 Michael Niedermayer
            bits= get_bit_count(&s->pb);
427
            s->mv_bits+= bits - s->last_bits;
428
            s->last_bits=bits;
429 098eefe1 Michael Niedermayer
430 9dbcbd92 Michael Niedermayer
            /* 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 d6231b9e Michael Niedermayer
        }
439
    } else {
440 9dbcbd92 Michael Niedermayer
        int cbp;
441 d6231b9e Michael Niedermayer
        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 098eefe1 Michael Niedermayer
        bits= get_bit_count(&s->pb);
503
        s->misc_bits+= bits - s->last_bits;
504
        s->last_bits=bits;
505
506 d6231b9e Michael Niedermayer
        /* 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 098eefe1 Michael Niedermayer
        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 d6231b9e Michael Niedermayer
        /* 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 4278e7a6 Michael Niedermayer
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
523 d6231b9e Michael Niedermayer
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 de6d9b64 Fabrice Bellard
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 644d98a4 Juanjo
   
543 de6d9b64 Fabrice Bellard
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
544 9dbcbd92 Michael Niedermayer
    if (!s->mb_intra) {
545 6dbd39fe Juanjo
           /* compute cbp */
546 9dbcbd92 Michael Niedermayer
        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 6dbd39fe Juanjo
      
568 9dbcbd92 Michael Niedermayer
        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 6dbd39fe Juanjo
            /* To prevent Start Code emulation */
577 9dbcbd92 Michael Niedermayer
                put_bits(&s->pb,1,1);
578
        }
579 6dbd39fe Juanjo
   } else {
580 de6d9b64 Fabrice Bellard
        /* 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 ba6802de Michael Niedermayer
    for (i = 0; i < 6; i++) {
608
        h263_encode_block(s, block[i], i);
609 de6d9b64 Fabrice Bellard
    }
610
}
611
612 9e15ad28 Juanjo
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
613 d140623f Juanjo
{
614 9e15ad28 Juanjo
    int x, y, wrap, a, c, pred_dc, scale, i;
615
    INT16 *dc_val, *ac_val, *ac_val1;
616 d140623f Juanjo
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 9e15ad28 Juanjo
        ac_val = s->ac_val[0][0];
624 d140623f Juanjo
        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 9e15ad28 Juanjo
        ac_val = s->ac_val[n - 4 + 1][0];
631 d140623f Juanjo
        scale = s->c_dc_scale;
632
    }
633 9e15ad28 Juanjo
    
634
    ac_val += ((y) * wrap + (x)) * 16;
635
    ac_val1 = ac_val;
636
    
637 d140623f Juanjo
    /* B C
638
     * A X 
639
     */
640
    a = dc_val[(x - 1) + (y) * wrap];
641
    c = dc_val[(x) + (y - 1) * wrap];
642
    
643 9e15ad28 Juanjo
    pred_dc = 1024;
644 d140623f Juanjo
    if (s->ac_pred) {
645
        if (s->h263_aic_dir) {
646
            /* left prediction */
647 9e15ad28 Juanjo
            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 d140623f Juanjo
            }
654
        } else {
655
            /* top prediction */
656 9e15ad28 Juanjo
            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 d140623f Juanjo
            }
663
        }
664 9e15ad28 Juanjo
    } 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 d140623f Juanjo
    }
673 9e15ad28 Juanjo
    
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 d140623f Juanjo
    /* 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 de6d9b64 Fabrice Bellard
INT16 *h263_pred_motion(MpegEncContext * s, int block, 
694
                        int *px, int *py)
695
{
696 4278e7a6 Michael Niedermayer
    int xy, wrap;
697 de6d9b64 Fabrice Bellard
    INT16 *A, *B, *C, *mot_val;
698 49c9325f Michael Niedermayer
    static const int off[4]= {2, 1, 1, -1};
699 de6d9b64 Fabrice Bellard
700 4278e7a6 Michael Niedermayer
    wrap = s->block_wrap[0];
701
    xy = s->block_index[block];
702 de6d9b64 Fabrice Bellard
703 af8793ae Zdenek Kabelac
    mot_val = s->motion_val[xy];
704 de6d9b64 Fabrice Bellard
705
    /* special case for first line */
706 2e3be0fb Michael Niedermayer
    if ((s->mb_y == 0 || s->first_slice_line || s->first_gob_line) && block<2) {
707 af8793ae Zdenek Kabelac
        A = s->motion_val[xy - 1];
708 de6d9b64 Fabrice Bellard
        *px = A[0];
709
        *py = A[1];
710
    } else {
711 49c9325f Michael Niedermayer
        A = s->motion_val[xy - 1];
712
        B = s->motion_val[xy - wrap];
713
        C = s->motion_val[xy + off[block] - wrap];
714 de6d9b64 Fabrice Bellard
        *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 9dbcbd92 Michael Niedermayer
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
721 de6d9b64 Fabrice Bellard
{
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 9dbcbd92 Michael Niedermayer
        bit_size = f_code - 1;
730 de6d9b64 Fabrice Bellard
        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 3bf43d42 Michael Niedermayer
        val--;
747
        code = (val >> bit_size) + 1;
748
        bits = val & (range - 1);
749 de6d9b64 Fabrice Bellard
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 6dbd39fe Juanjo
/* 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 45870f57 Michael Niedermayer
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 9d2a0355 Michael Niedermayer
833
    for(mv=0; mv<MAX_MV*2+1; mv++){
834
        umv_fcode_tab[mv]= 1;
835
    }
836 45870f57 Michael Niedermayer
}
837
838 2a164b25 Michael Niedermayer
static void init_uni_dc_tab()
839
{
840
    int level, uni_code, uni_len;
841
842 3bf43d42 Michael Niedermayer
    for(level=-256; level<256; level++){
843 2a164b25 Michael Niedermayer
        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 45870f57 Michael Niedermayer
void h263_encode_init(MpegEncContext *s)
891 de6d9b64 Fabrice Bellard
{
892
    static int done = 0;
893
894
    if (!done) {
895
        done = 1;
896 2a164b25 Michael Niedermayer
897
        init_uni_dc_tab();
898
899 de6d9b64 Fabrice Bellard
        init_rl(&rl_inter);
900
        init_rl(&rl_intra);
901 45870f57 Michael Niedermayer
902
        init_mv_penalty_and_fcode(s);
903 de6d9b64 Fabrice Bellard
    }
904 9d2a0355 Michael Niedermayer
    s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
905 45870f57 Michael Niedermayer
    
906 9d2a0355 Michael Niedermayer
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
907 d7e9533a Michael Niedermayer
    switch(s->codec_id){
908
    case CODEC_ID_MPEG4:
909
        s->fcode_tab= fcode_tab;
910
        s->min_qcoeff= -2048;
911
        s->max_qcoeff=  2047;
912
        break;
913
    case CODEC_ID_H263P:
914
        s->fcode_tab= umv_fcode_tab;
915
        s->min_qcoeff= -128;
916
        s->max_qcoeff=  127;
917
        break;
918
    default: //nothing needed default table allready set in mpegvideo.c
919
        s->min_qcoeff= -128;
920
        s->max_qcoeff=  127;
921
    }
922
923
    /* h263 type bias */
924
    //FIXME mpeg4 mpeg quantizer    
925
    s->intra_quant_bias=0;
926
    s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
927 de6d9b64 Fabrice Bellard
}
928
929
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
930
{
931
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
932
    int code;
933
    RLTable *rl = &rl_inter;
934
935
    if (s->mb_intra) {
936 81401c1f Juanjo
        /* DC coef */
937
            level = block[0];
938 de6d9b64 Fabrice Bellard
        /* 255 cannot be represented, so we clamp */
939
        if (level > 254) {
940
            level = 254;
941
            block[0] = 254;
942
        }
943 81401c1f Juanjo
        /* 0 cannot be represented also */
944
        else if (!level) {
945
            level = 1;
946
            block[0] = 1;
947
        }
948
            if (level == 128)
949
                put_bits(&s->pb, 8, 0xff);
950
            else
951
                put_bits(&s->pb, 8, level & 0xff);
952
            i = 1;
953 de6d9b64 Fabrice Bellard
    } else {
954 81401c1f Juanjo
            i = 0;
955 de6d9b64 Fabrice Bellard
    }
956
957
    /* AC coefs */
958
    last_index = s->block_last_index[n];
959
    last_non_zero = i - 1;
960
    for (; i <= last_index; i++) {
961
        j = zigzag_direct[i];
962
        level = block[j];
963
        if (level) {
964
            run = i - last_non_zero - 1;
965
            last = (i == last_index);
966
            sign = 0;
967
            slevel = level;
968
            if (level < 0) {
969
                sign = 1;
970
                level = -level;
971
            }
972
            code = get_rl_index(rl, last, run, level);
973
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
974
            if (code == rl->n) {
975
                put_bits(&s->pb, 1, last);
976
                put_bits(&s->pb, 6, run);
977
                put_bits(&s->pb, 8, slevel & 0xff);
978
            } else {
979
                put_bits(&s->pb, 1, sign);
980
            }
981
            last_non_zero = i;
982
        }
983
    }
984
}
985
986
/***************************************************/
987
988 6f91bcd1 Michael Niedermayer
static void mpeg4_stuffing(PutBitContext * pbc)
989
{
990
    int length;
991
    put_bits(pbc, 1, 0);
992
    length= (-get_bit_count(pbc))&7;
993
    put_bits(pbc, length, (1<<length)-1);
994
}
995
996
static void put_string(PutBitContext * pbc, char *s)
997
{
998
    while(*s){
999
        put_bits(pbc, 8, *s);
1000
        s++;
1001
    }
1002
    put_bits(pbc, 8, 0);
1003
}
1004
1005 91029be7 Michael Niedermayer
/* must be called before writing the header */
1006
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1007
    int time_div, time_mod;
1008
1009
    if(s->pict_type==I_TYPE){ //we will encode a vol header
1010
        s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1011
        if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1012
1013
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1014
    }
1015
1016
    s->time= picture_number*(int64_t)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1017
    time_div= s->time/s->time_increment_resolution;
1018
    time_mod= s->time%s->time_increment_resolution;
1019
1020
    if(s->pict_type==B_TYPE){
1021
        s->bp_time= s->last_non_b_time - s->time;
1022
    }else{
1023
        s->last_time_base= s->time_base;
1024
        s->time_base= time_div;
1025
        s->pp_time= s->time - s->last_non_b_time;
1026
        s->last_non_b_time= s->time;
1027
    }
1028
}
1029
1030 10cd5815 Michael Niedermayer
static void mpeg4_encode_vol_header(MpegEncContext * s)
1031 de6d9b64 Fabrice Bellard
{
1032 10cd5815 Michael Niedermayer
    int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1033 4b1f4f23 Juanjo
    char buf[255];
1034 1ff662cc Michael Niedermayer
1035
    s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
1036
1037 10cd5815 Michael Niedermayer
    if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
1038
    put_bits(&s->pb, 16, 0);
1039
    put_bits(&s->pb, 16, 0x100);        /* video obj */
1040
    put_bits(&s->pb, 16, 0);
1041
    put_bits(&s->pb, 16, 0x120);        /* video obj layer */
1042
1043
    put_bits(&s->pb, 1, 0);                /* random access vol */
1044 1ff662cc Michael Niedermayer
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1045 10cd5815 Michael Niedermayer
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1046
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1047
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1048 11ce8834 Michael Niedermayer
    if(s->aspect_ratio_info) 
1049
        put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1050
    else
1051
        put_bits(&s->pb, 4, 1);                /* aspect ratio info= sqare pixel */
1052 1ff662cc Michael Niedermayer
1053
    if(s->low_delay){
1054
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1055 1c2a8c7f Michael Niedermayer
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1056 1ff662cc Michael Niedermayer
        put_bits(&s->pb, 1, s->low_delay);
1057
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1058
    }else{
1059
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1060
    }
1061
1062 10cd5815 Michael Niedermayer
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1063
    put_bits(&s->pb, 1, 1);                /* marker bit */
1064 9dbcbd92 Michael Niedermayer
    
1065
    put_bits(&s->pb, 16, s->time_increment_resolution);
1066 10cd5815 Michael Niedermayer
    if (s->time_increment_bits < 1)
1067
        s->time_increment_bits = 1;
1068
    put_bits(&s->pb, 1, 1);                /* marker bit */
1069
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1070
    put_bits(&s->pb, 1, 1);                /* marker bit */
1071
    put_bits(&s->pb, 13, s->width);        /* vol width */
1072
    put_bits(&s->pb, 1, 1);                /* marker bit */
1073
    put_bits(&s->pb, 13, s->height);        /* vol height */
1074
    put_bits(&s->pb, 1, 1);                /* marker bit */
1075
    put_bits(&s->pb, 1, 0);                /* interlace */
1076
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1077
    if (vo_ver_id == 1) {
1078
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1079
    }else{ /* vo_ver_id == 2 */
1080
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1081
    }
1082
    put_bits(&s->pb, 1, 0);                /* not 8 bit */
1083
    put_bits(&s->pb, 1, 0);                /* quant type= h263 style*/
1084
    if (vo_ver_id != 1)
1085
        put_bits(&s->pb, 1, s->quarter_sample=0);
1086
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1087
    put_bits(&s->pb, 1, 1);                /* resync marker disable */
1088
    put_bits(&s->pb, 1, 0);                /* data partitioned */
1089
    if (vo_ver_id != 1){
1090
        put_bits(&s->pb, 1, 0);                /* newpred */
1091
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1092
    }
1093
    put_bits(&s->pb, 1, 0);                /* scalability */
1094
1095 6f91bcd1 Michael Niedermayer
    mpeg4_stuffing(&s->pb);
1096
    put_bits(&s->pb, 16, 0);
1097
    put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1098 4b1f4f23 Juanjo
    sprintf(buf, "FFmpeg v%s / libavcodec build: %s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1099
    put_string(&s->pb, buf);
1100 49c9325f Michael Niedermayer
1101
    s->no_rounding = 0;
1102 10cd5815 Michael Niedermayer
}
1103
1104
/* write mpeg4 VOP header */
1105
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1106
{
1107 9dbcbd92 Michael Niedermayer
    int time_incr;
1108
    int time_div, time_mod;
1109
    
1110 10cd5815 Michael Niedermayer
    if(s->pict_type==I_TYPE) mpeg4_encode_vol_header(s);
1111 9dbcbd92 Michael Niedermayer
    
1112
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1113
    
1114 10cd5815 Michael Niedermayer
    if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
1115 17592475 Michael Niedermayer
    put_bits(&s->pb, 16, 0);                /* vop header */
1116
    put_bits(&s->pb, 16, 0x1B6);        /* vop header */
1117 de6d9b64 Fabrice Bellard
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1118 9dbcbd92 Michael Niedermayer
1119 91029be7 Michael Niedermayer
    time_div= s->time/s->time_increment_resolution;
1120
    time_mod= s->time%s->time_increment_resolution;
1121 9dbcbd92 Michael Niedermayer
    time_incr= time_div - s->last_time_base;
1122
    while(time_incr--)
1123
        put_bits(&s->pb, 1, 1);
1124
        
1125 de6d9b64 Fabrice Bellard
    put_bits(&s->pb, 1, 0);
1126
1127
    put_bits(&s->pb, 1, 1);        /* marker */
1128 9dbcbd92 Michael Niedermayer
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1129 de6d9b64 Fabrice Bellard
    put_bits(&s->pb, 1, 1);        /* marker */
1130
    put_bits(&s->pb, 1, 1);        /* vop coded */
1131 10cd5815 Michael Niedermayer
    if (    s->pict_type == P_TYPE 
1132
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1133
        s->no_rounding ^= 1;
1134 de6d9b64 Fabrice Bellard
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1135
    }
1136
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1137 10cd5815 Michael Niedermayer
    //FIXME sprite stuff
1138 de6d9b64 Fabrice Bellard
1139
    put_bits(&s->pb, 5, s->qscale);
1140
1141
    if (s->pict_type != I_TYPE)
1142
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1143 10cd5815 Michael Niedermayer
    if (s->pict_type == B_TYPE)
1144
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1145 de6d9b64 Fabrice Bellard
    //    printf("****frame %d\n", picture_number);
1146
}
1147
1148
void h263_dc_scale(MpegEncContext * s)
1149
{
1150 d6231b9e Michael Niedermayer
#if 1
1151
    const static UINT8 y_tab[32]={
1152
    //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
1153
        0, 8, 8, 8, 8,10,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,36,38,40,42,44,46
1154
    };
1155
    const static UINT8 c_tab[32]={
1156
    //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
1157
        0, 8, 8, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,20,21,22,23,24,25
1158
    };
1159
    s->y_dc_scale = y_tab[s->qscale];
1160
    s->c_dc_scale = c_tab[s->qscale];
1161
#else
1162 de6d9b64 Fabrice Bellard
    int quant;
1163
    quant = s->qscale;
1164
    /* luminance */
1165
    if (quant < 5)
1166
        s->y_dc_scale = 8;
1167
    else if (quant > 4 && quant < 9)
1168
        s->y_dc_scale = (2 * quant);
1169
    else if (quant > 8 && quant < 25)
1170
        s->y_dc_scale = (quant + 8);
1171
    else
1172
        s->y_dc_scale = (2 * quant - 16);
1173
    /* chrominance */
1174
    if (quant < 5)
1175
        s->c_dc_scale = 8;
1176
    else if (quant > 4 && quant < 25)
1177
        s->c_dc_scale = ((quant + 13) / 2);
1178
    else
1179
        s->c_dc_scale = (quant - 6);
1180 d6231b9e Michael Niedermayer
#endif
1181 de6d9b64 Fabrice Bellard
}
1182
1183 d6231b9e Michael Niedermayer
static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1184 de6d9b64 Fabrice Bellard
{
1185 4278e7a6 Michael Niedermayer
    int a, b, c, wrap, pred, scale;
1186 de6d9b64 Fabrice Bellard
    UINT16 *dc_val;
1187 d6231b9e Michael Niedermayer
    int dummy;
1188 de6d9b64 Fabrice Bellard
1189
    /* find prediction */
1190
    if (n < 4) {
1191
        scale = s->y_dc_scale;
1192
    } else {
1193
        scale = s->c_dc_scale;
1194
    }
1195 4278e7a6 Michael Niedermayer
    wrap= s->block_wrap[n];
1196
    dc_val = s->dc_val[0] + s->block_index[n];
1197 de6d9b64 Fabrice Bellard
1198
    /* B C
1199
     * A X 
1200
     */
1201 4278e7a6 Michael Niedermayer
    a = dc_val[ - 1];
1202
    b = dc_val[ - 1 - wrap];
1203
    c = dc_val[ - wrap];
1204 de6d9b64 Fabrice Bellard
1205
    if (abs(a - b) < abs(b - c)) {
1206
        pred = c;
1207
        *dir_ptr = 1; /* top */
1208
    } else {
1209
        pred = a;
1210
        *dir_ptr = 0; /* left */
1211
    }
1212
    /* we assume pred is positive */
1213 d6231b9e Michael Niedermayer
#ifdef ARCH_X86
1214
        asm volatile (
1215
                "xorl %%edx, %%edx        \n\t"
1216
                "mul %%ecx                \n\t"
1217
                : "=d" (pred), "=a"(dummy)
1218
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1219
        );
1220
#else
1221 de6d9b64 Fabrice Bellard
    pred = (pred + (scale >> 1)) / scale;
1222 d6231b9e Michael Niedermayer
#endif
1223 de6d9b64 Fabrice Bellard
1224
    /* prepare address for prediction update */
1225 4278e7a6 Michael Niedermayer
    *dc_val_ptr = &dc_val[0];
1226 de6d9b64 Fabrice Bellard
1227
    return pred;
1228
}
1229
1230 d962f6fd Arpi
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1231 de6d9b64 Fabrice Bellard
                   int dir)
1232
{
1233 4278e7a6 Michael Niedermayer
    int i;
1234 de6d9b64 Fabrice Bellard
    INT16 *ac_val, *ac_val1;
1235
1236
    /* find prediction */
1237 4278e7a6 Michael Niedermayer
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1238 de6d9b64 Fabrice Bellard
    ac_val1 = ac_val;
1239
    if (s->ac_pred) {
1240
        if (dir == 0) {
1241
            /* left prediction */
1242
            ac_val -= 16;
1243
            for(i=1;i<8;i++) {
1244 d962f6fd Arpi
                block[block_permute_op(i*8)] += ac_val[i];
1245 de6d9b64 Fabrice Bellard
            }
1246
        } else {
1247
            /* top prediction */
1248 4278e7a6 Michael Niedermayer
            ac_val -= 16 * s->block_wrap[n];
1249 de6d9b64 Fabrice Bellard
            for(i=1;i<8;i++) {
1250 d962f6fd Arpi
                block[block_permute_op(i)] += ac_val[i + 8];
1251 de6d9b64 Fabrice Bellard
            }
1252
        }
1253
    }
1254
    /* left copy */
1255
    for(i=1;i<8;i++)
1256 d962f6fd Arpi
        ac_val1[i] = block[block_permute_op(i * 8)];
1257 de6d9b64 Fabrice Bellard
    /* top copy */
1258
    for(i=1;i<8;i++)
1259 d962f6fd Arpi
        ac_val1[8 + i] = block[block_permute_op(i)];
1260 de6d9b64 Fabrice Bellard
}
1261
1262 d6231b9e Michael Niedermayer
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1263
                              int dir)
1264 de6d9b64 Fabrice Bellard
{
1265 4278e7a6 Michael Niedermayer
    int i;
1266 d6231b9e Michael Niedermayer
    INT16 *ac_val;
1267 de6d9b64 Fabrice Bellard
1268 d6231b9e Michael Niedermayer
    /* find prediction */
1269 4278e7a6 Michael Niedermayer
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1270 d6231b9e Michael Niedermayer
 
1271
    if (dir == 0) {
1272
        /* left prediction */
1273
        ac_val -= 16;
1274
        for(i=1;i<8;i++) {
1275
            block[block_permute_op(i*8)] -= ac_val[i];
1276
        }
1277
    } else {
1278
        /* top prediction */
1279 4278e7a6 Michael Niedermayer
        ac_val -= 16 * s->block_wrap[n];
1280 d6231b9e Michael Niedermayer
        for(i=1;i<8;i++) {
1281
            block[block_permute_op(i)] -= ac_val[i + 8];
1282
        }
1283 de6d9b64 Fabrice Bellard
    }
1284 d6231b9e Michael Niedermayer
}
1285
1286
static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)
1287
{
1288 2a164b25 Michael Niedermayer
#if 1
1289
    level+=256;
1290
    if (n < 4) {
1291
        /* luminance */
1292
        put_bits(&s->pb, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1293
    } else {
1294
        /* chrominance */
1295
        put_bits(&s->pb, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1296
    }
1297
#else
1298 d6231b9e Michael Niedermayer
    int size, v;
1299 de6d9b64 Fabrice Bellard
    /* find number of bits */
1300
    size = 0;
1301
    v = abs(level);
1302
    while (v) {
1303
        v >>= 1;
1304
        size++;
1305
    }
1306
1307
    if (n < 4) {
1308
        /* luminance */
1309
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1310
    } else {
1311
        /* chrominance */
1312
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1313
    }
1314
1315
    /* encode remaining bits */
1316
    if (size > 0) {
1317
        if (level < 0)
1318
            level = (-level) ^ ((1 << size) - 1);
1319
        put_bits(&s->pb, size, level);
1320
        if (size > 8)
1321
            put_bits(&s->pb, 1, 1);
1322
    }
1323 2a164b25 Michael Niedermayer
#endif
1324 de6d9b64 Fabrice Bellard
}
1325
1326 d6231b9e Michael Niedermayer
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table)
1327 de6d9b64 Fabrice Bellard
{
1328
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
1329 d6231b9e Michael Niedermayer
    int code;
1330 de6d9b64 Fabrice Bellard
    const RLTable *rl;
1331
1332
    if (s->mb_intra) {
1333
        /* mpeg4 based DC predictor */
1334 d6231b9e Michael Niedermayer
        mpeg4_encode_dc(s, intra_dc, n);
1335 de6d9b64 Fabrice Bellard
        i = 1;
1336
        rl = &rl_intra;
1337
    } else {
1338
        i = 0;
1339
        rl = &rl_inter;
1340
    }
1341
1342
    /* AC coefs */
1343
    last_index = s->block_last_index[n];
1344
    last_non_zero = i - 1;
1345
    for (; i <= last_index; i++) {
1346 d6231b9e Michael Niedermayer
        j = scan_table[i];
1347 de6d9b64 Fabrice Bellard
        level = block[j];
1348
        if (level) {
1349
            run = i - last_non_zero - 1;
1350
            last = (i == last_index);
1351
            sign = 0;
1352
            slevel = level;
1353
            if (level < 0) {
1354
                sign = 1;
1355
                level = -level;
1356
            }
1357
            code = get_rl_index(rl, last, run, level);
1358
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1359
            if (code == rl->n) {
1360
                int level1, run1;
1361
                level1 = level - rl->max_level[last][run];
1362
                if (level1 < 1) 
1363
                    goto esc2;
1364
                code = get_rl_index(rl, last, run, level1);
1365
                if (code == rl->n) {
1366
                esc2:
1367
                    put_bits(&s->pb, 1, 1);
1368
                    if (level > MAX_LEVEL)
1369
                        goto esc3;
1370
                    run1 = run - rl->max_run[last][level] - 1;
1371
                    if (run1 < 0)
1372
                        goto esc3;
1373
                    code = get_rl_index(rl, last, run1, level);
1374
                    if (code == rl->n) {
1375
                    esc3:
1376
                        /* third escape */
1377
                        put_bits(&s->pb, 1, 1);
1378
                        put_bits(&s->pb, 1, last);
1379
                        put_bits(&s->pb, 6, run);
1380
                        put_bits(&s->pb, 1, 1);
1381
                        put_bits(&s->pb, 12, slevel & 0xfff);
1382
                        put_bits(&s->pb, 1, 1);
1383
                    } else {
1384
                        /* second escape */
1385
                        put_bits(&s->pb, 1, 0);
1386
                        put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1387
                        put_bits(&s->pb, 1, sign);
1388
                    }
1389
                } else {
1390
                    /* first escape */
1391
                    put_bits(&s->pb, 1, 0);
1392
                    put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1393
                    put_bits(&s->pb, 1, sign);
1394
                }
1395
            } else {
1396
                put_bits(&s->pb, 1, sign);
1397
            }
1398
            last_non_zero = i;
1399
        }
1400
    }
1401
}
1402
1403
1404
1405
/***********************************************/
1406
/* decoding */
1407
1408
static VLC intra_MCBPC_vlc;
1409
static VLC inter_MCBPC_vlc;
1410
static VLC cbpy_vlc;
1411
static VLC mv_vlc;
1412
static VLC dc_lum, dc_chrom;
1413 73c8e514 Michael Niedermayer
static VLC sprite_trajectory;
1414 6f91bcd1 Michael Niedermayer
static VLC mb_type_b_vlc;
1415 de6d9b64 Fabrice Bellard
1416
void init_rl(RLTable *rl)
1417
{
1418
    INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1419
    UINT8 index_run[MAX_RUN+1];
1420
    int last, run, level, start, end, i;
1421
1422
    /* compute max_level[], max_run[] and index_run[] */
1423
    for(last=0;last<2;last++) {
1424
        if (last == 0) {
1425
            start = 0;
1426
            end = rl->last;
1427
        } else {
1428
            start = rl->last;
1429
            end = rl->n;
1430
        }
1431
1432
        memset(max_level, 0, MAX_RUN + 1);
1433
        memset(max_run, 0, MAX_LEVEL + 1);
1434
        memset(index_run, rl->n, MAX_RUN + 1);
1435
        for(i=start;i<end;i++) {
1436
            run = rl->table_run[i];
1437
            level = rl->table_level[i];
1438
            if (index_run[run] == rl->n)
1439
                index_run[run] = i;
1440
            if (level > max_level[run])
1441
                max_level[run] = level;
1442
            if (run > max_run[level])
1443
                max_run[level] = run;
1444
        }
1445
        rl->max_level[last] = malloc(MAX_RUN + 1);
1446
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1447
        rl->max_run[last] = malloc(MAX_LEVEL + 1);
1448
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1449
        rl->index_run[last] = malloc(MAX_RUN + 1);
1450
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1451
    }
1452
}
1453
1454
void init_vlc_rl(RLTable *rl)
1455
{
1456
    init_vlc(&rl->vlc, 9, rl->n + 1, 
1457
             &rl->table_vlc[0][1], 4, 2,
1458
             &rl->table_vlc[0][0], 4, 2);
1459
}
1460
1461
/* init vlcs */
1462
1463
/* XXX: find a better solution to handle static init */
1464
void h263_decode_init_vlc(MpegEncContext *s)
1465
{
1466
    static int done = 0;
1467
1468
    if (!done) {
1469
        done = 1;
1470
1471
        init_vlc(&intra_MCBPC_vlc, 6, 8, 
1472
                 intra_MCBPC_bits, 1, 1,
1473
                 intra_MCBPC_code, 1, 1);
1474 96815ce9 Juanjo
        init_vlc(&inter_MCBPC_vlc, 9, 25, 
1475 de6d9b64 Fabrice Bellard
                 inter_MCBPC_bits, 1, 1,
1476
                 inter_MCBPC_code, 1, 1);
1477
        init_vlc(&cbpy_vlc, 6, 16,
1478
                 &cbpy_tab[0][1], 2, 1,
1479
                 &cbpy_tab[0][0], 2, 1);
1480
        init_vlc(&mv_vlc, 9, 33,
1481
                 &mvtab[0][1], 2, 1,
1482
                 &mvtab[0][0], 2, 1);
1483
        init_rl(&rl_inter);
1484
        init_rl(&rl_intra);
1485 d140623f Juanjo
        init_rl(&rl_intra_aic);
1486 de6d9b64 Fabrice Bellard
        init_vlc_rl(&rl_inter);
1487
        init_vlc_rl(&rl_intra);
1488 d140623f Juanjo
        init_vlc_rl(&rl_intra_aic);
1489 de6d9b64 Fabrice Bellard
        init_vlc(&dc_lum, 9, 13,
1490
                 &DCtab_lum[0][1], 2, 1,
1491
                 &DCtab_lum[0][0], 2, 1);
1492
        init_vlc(&dc_chrom, 9, 13,
1493
                 &DCtab_chrom[0][1], 2, 1,
1494
                 &DCtab_chrom[0][0], 2, 1);
1495 73c8e514 Michael Niedermayer
        init_vlc(&sprite_trajectory, 9, 15,
1496
                 &sprite_trajectory_tab[0][1], 4, 2,
1497
                 &sprite_trajectory_tab[0][0], 4, 2);
1498 6f91bcd1 Michael Niedermayer
        init_vlc(&mb_type_b_vlc, 4, 4,
1499
                 &mb_type_b_tab[0][1], 2, 1,
1500
                 &mb_type_b_tab[0][0], 2, 1);
1501 de6d9b64 Fabrice Bellard
    }
1502
}
1503
1504 644d98a4 Juanjo
int h263_decode_gob_header(MpegEncContext *s)
1505 de6d9b64 Fabrice Bellard
{
1506 644d98a4 Juanjo
    unsigned int val, gfid;
1507 102d3908 Juanjo
    
1508 4949028f Juanjo
    /* Check for GOB Start Code */
1509 644d98a4 Juanjo
    val = show_bits(&s->gb, 16);
1510
    if (val == 0) {
1511
        /* We have a GBSC probably with GSTUFF */
1512
        skip_bits(&s->gb, 16); /* Drop the zeros */
1513
        while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1514 4949028f Juanjo
#ifdef DEBUG
1515 644d98a4 Juanjo
        fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1516 102d3908 Juanjo
#endif
1517 644d98a4 Juanjo
        s->gob_number = get_bits(&s->gb, 5); /* GN */
1518
        gfid = get_bits(&s->gb, 2); /* GFID */
1519
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1520 4949028f Juanjo
#ifdef DEBUG
1521 17592475 Michael Niedermayer
        fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1522 4949028f Juanjo
#endif
1523 644d98a4 Juanjo
        return 1;
1524 4949028f Juanjo
    }
1525 644d98a4 Juanjo
    return 0;
1526
            
1527
}
1528
1529 49092244 Michael Niedermayer
static inline void memsetw(short *tab, int val, int n)
1530
{
1531
    int i;
1532
    for(i=0;i<n;i++)
1533
        tab[i] = val;
1534
}
1535
1536
static int mpeg4_resync(MpegEncContext *s)
1537
{
1538
    int state, v, bits;
1539
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1540
    int header_extension=0, mb_num;
1541
    int c_wrap, c_xy, l_wrap, l_xy;
1542 9dbcbd92 Michael Niedermayer
    int time_increment;
1543 49092244 Michael Niedermayer
//printf("resync at %d %d\n", s->mb_x, s->mb_y);
1544
//printf("%X\n", show_bits(&s->gb, 24));
1545
1546
    if( get_bits_count(&s->gb) > s->gb.size*8-32)
1547
        return 0;
1548
1549
    align_get_bits(&s->gb);
1550
    state = 0xff;
1551
    for(;;) {
1552
        v = get_bits(&s->gb, 8);
1553
//printf("%X ", v);
1554
        state = ((state << 8) | v) & 0xffff;
1555
        if (state == 0) break;
1556
        if( get_bits_count(&s->gb) > s->gb.size*8-32){
1557
            printf("resync failed\n");
1558
            return -1;
1559
        }
1560
    }
1561
//printf("%X\n", show_bits(&s->gb, 24));
1562
    bits=0;
1563
    while(!get_bits1(&s->gb) && bits<30) bits++;
1564
    if(s->pict_type == P_TYPE && bits != s->f_code-1)
1565
        printf("marker does not match f_code\n");
1566
    //FIXME check bits for B-framess
1567
//printf("%X\n", show_bits(&s->gb, 24));
1568
1569
    if(s->shape != RECT_SHAPE){
1570
        header_extension= get_bits1(&s->gb);
1571
        //FIXME more stuff here
1572
    }
1573
1574
    mb_num= get_bits(&s->gb, mb_num_bits);
1575
    if(mb_num != s->mb_x + s->mb_y*s->mb_width){
1576
        printf("MB-num change not supported %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width);
1577
//        s->mb_x= mb_num % s->mb_width;
1578
//        s->mb_y= mb_num / s->mb_width;
1579
        //FIXME many vars are wrong now
1580
    } 
1581
1582
    if(s->shape != BIN_ONLY_SHAPE){
1583
        s->qscale= get_bits(&s->gb, 5);
1584
        h263_dc_scale(s);
1585
    }
1586
1587
    if(s->shape == RECT_SHAPE){
1588
        header_extension= get_bits1(&s->gb);
1589
    }
1590
    if(header_extension){
1591
        int time_incr=0;
1592
        printf("header extension not really supported\n");
1593
        while (get_bits1(&s->gb) != 0) 
1594
            time_incr++;
1595
1596
        check_marker(&s->gb, "before time_increment in video packed header");
1597 9dbcbd92 Michael Niedermayer
        time_increment= get_bits(&s->gb, s->time_increment_bits);
1598 49092244 Michael Niedermayer
        if(s->pict_type!=B_TYPE){
1599 9dbcbd92 Michael Niedermayer
            s->last_time_base= s->time_base;
1600 49092244 Michael Niedermayer
            s->time_base+= time_incr;
1601 9dbcbd92 Michael Niedermayer
            s->time= s->time_base*s->time_increment_resolution + time_increment;
1602
            s->pp_time= s->time - s->last_non_b_time;
1603
            s->last_non_b_time= s->time;
1604 49092244 Michael Niedermayer
        }else{
1605 9dbcbd92 Michael Niedermayer
            s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
1606
            s->bp_time= s->last_non_b_time - s->time;
1607 49092244 Michael Niedermayer
        }
1608
        check_marker(&s->gb, "before vop_coding_type in video packed header");
1609
        
1610
        skip_bits(&s->gb, 2); /* vop coding type */
1611
        //FIXME not rect stuff here
1612
1613
        if(s->shape != BIN_ONLY_SHAPE){
1614
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
1615
1616
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){
1617
                mpeg4_decode_sprite_trajectory(s);
1618
            }
1619
1620
            //FIXME reduced res stuff here
1621
            
1622
            if (s->pict_type != I_TYPE) {
1623
                s->f_code = get_bits(&s->gb, 3);        /* fcode_for */
1624
                if(s->f_code==0){
1625
                    printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n");
1626
                    return -1; // makes no sense to continue, as the MV decoding will break very quickly
1627
                }
1628
            }
1629
            if (s->pict_type == B_TYPE) {
1630
                s->b_code = get_bits(&s->gb, 3);
1631
            }       
1632
        }
1633
1634
    }
1635
    //FIXME new-pred stuff
1636
1637
    l_wrap= s->block_wrap[0];
1638
    l_xy= s->mb_y*l_wrap*2;
1639
    c_wrap= s->block_wrap[4];
1640
    c_xy= s->mb_y*c_wrap;
1641
1642
    /* clean DC */
1643
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*3);
1644
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap*2);
1645
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap*2);
1646
1647
    /* clean AC */
1648
    memset(s->ac_val[0] + l_xy, 0, l_wrap*3*16*sizeof(INT16));
1649
    memset(s->ac_val[1] + c_xy, 0, c_wrap*2*16*sizeof(INT16));
1650
    memset(s->ac_val[2] + c_xy, 0, c_wrap*2*16*sizeof(INT16));
1651
1652
    /* clean MV */
1653
    memset(s->motion_val + l_xy, 0, l_wrap*3*2*sizeof(INT16));
1654
//    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
1655
    s->resync_x_pos= s->mb_x;
1656
    s->first_slice_line=1;
1657
1658
    return 0;
1659
}
1660
1661 644d98a4 Juanjo
int h263_decode_mb(MpegEncContext *s,
1662
                   DCTELEM block[6][64])
1663
{
1664
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1665
    INT16 *mot_val;
1666
    static INT8 quant_tab[4] = { -1, -2, 1, 2 };
1667 49c9325f Michael Niedermayer
1668 49092244 Michael Niedermayer
    if(s->resync_marker){
1669
        if(   s->resync_x_pos == s->mb_x+1
1670
           || s->resync_x_pos == s->mb_x){
1671
            /* f*ck mpeg4
1672
               this is here so we dont need to slowdown h263_pred_motion with it */
1673
            if(s->resync_x_pos == s->mb_x+1 && s->mb_x==0){
1674
                int xy= s->block_index[0] - s->block_wrap[0];
1675
                s->motion_val[xy][0]= s->motion_val[xy+2][0];
1676
                s->motion_val[xy][1]= s->motion_val[xy+2][1];
1677
            }
1678
1679
            s->first_slice_line=0; 
1680
            s->resync_x_pos=0; // isnt needed but for cleanness sake ;)
1681
        }
1682
1683
        if(show_aligned_bits(&s->gb, 1, 16) == 0){
1684
            if( mpeg4_resync(s) < 0 ) return -1;
1685
            
1686
        }
1687
    }
1688
1689 73c8e514 Michael Niedermayer
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
1690 612476ef Arpi
        if (get_bits1(&s->gb)) {
1691 de6d9b64 Fabrice Bellard
            /* skip mb */
1692
            s->mb_intra = 0;
1693
            for(i=0;i<6;i++)
1694
                s->block_last_index[i] = -1;
1695
            s->mv_dir = MV_DIR_FORWARD;
1696
            s->mv_type = MV_TYPE_16X16;
1697 44eb4951 Michael Niedermayer
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
1698
                const int a= s->sprite_warping_accuracy;
1699
//                int l = (1 << (s->f_code - 1)) * 32;
1700
1701
                s->mcsel=1;
1702 14ae07d8 Michael Niedermayer
                if(s->divx_version==500 && s->divx_build==413){
1703
                    s->mv[0][0][0] = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
1704
                    s->mv[0][0][1] = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
1705
                }else{
1706
                    s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1707
                    s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1708
                }
1709 44eb4951 Michael Niedermayer
/*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
1710
                else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
1711
                if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
1712
                else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
1713
1714
                s->mb_skiped = 0;
1715
            }else{
1716
                s->mcsel=0;
1717
                s->mv[0][0][0] = 0;
1718
                s->mv[0][0][1] = 0;
1719
                s->mb_skiped = 1;
1720
            }
1721 de6d9b64 Fabrice Bellard
            return 0;
1722
        }
1723
        cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
1724 4949028f Juanjo
        //fprintf(stderr, "\tCBPC: %d", cbpc);
1725 de6d9b64 Fabrice Bellard
        if (cbpc < 0)
1726
            return -1;
1727 96815ce9 Juanjo
        if (cbpc > 20)
1728
            cbpc+=3;
1729
        else if (cbpc == 20)
1730
            fprintf(stderr, "Stuffing !");
1731 4949028f Juanjo
        
1732 de6d9b64 Fabrice Bellard
        dquant = cbpc & 8;
1733
        s->mb_intra = ((cbpc & 4) != 0);
1734 6f91bcd1 Michael Niedermayer
        if (s->mb_intra) goto intra;
1735
        
1736 73c8e514 Michael Niedermayer
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
1737
            s->mcsel= get_bits1(&s->gb);
1738
        else s->mcsel= 0;
1739 de6d9b64 Fabrice Bellard
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
1740
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
1741
        if (dquant) {
1742
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
1743
            if (s->qscale < 1)
1744
                s->qscale = 1;
1745
            else if (s->qscale > 31)
1746
                s->qscale = 31;
1747 49092244 Michael Niedermayer
            h263_dc_scale(s);
1748 de6d9b64 Fabrice Bellard
        }
1749
        s->mv_dir = MV_DIR_FORWARD;
1750
        if ((cbpc & 16) == 0) {
1751
            /* 16x16 motion prediction */
1752
            s->mv_type = MV_TYPE_16X16;
1753
            h263_pred_motion(s, 0, &pred_x, &pred_y);
1754 544286b3 Juanjo
            if (s->umvplus_dec)
1755 6dbd39fe Juanjo
               mx = h263p_decode_umotion(s, pred_x);
1756 73c8e514 Michael Niedermayer
            else if(!s->mcsel)
1757 6f91bcd1 Michael Niedermayer
               mx = h263_decode_motion(s, pred_x, s->f_code);
1758 44eb4951 Michael Niedermayer
            else {
1759
               const int a= s->sprite_warping_accuracy;
1760
//        int l = (1 << (s->f_code - 1)) * 32;
1761 14ae07d8 Michael Niedermayer
                if(s->divx_version==500 && s->divx_build==413){
1762
                    mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
1763
                }else{
1764
                    mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1765
                }
1766
//        if (mx < -l) mx= -l, printf("C");
1767
//        else if (mx >= l) mx= l-1, printf("C");
1768 44eb4951 Michael Niedermayer
            }
1769 de6d9b64 Fabrice Bellard
            if (mx >= 0xffff)
1770
                return -1;
1771 6dbd39fe Juanjo
            
1772 544286b3 Juanjo
            if (s->umvplus_dec)
1773 6dbd39fe Juanjo
               my = h263p_decode_umotion(s, pred_y);
1774 73c8e514 Michael Niedermayer
            else if(!s->mcsel)
1775 6f91bcd1 Michael Niedermayer
               my = h263_decode_motion(s, pred_y, s->f_code);
1776 44eb4951 Michael Niedermayer
            else{
1777
               const int a= s->sprite_warping_accuracy;
1778
//       int l = (1 << (s->f_code - 1)) * 32;
1779 14ae07d8 Michael Niedermayer
                if(s->divx_version==500 && s->divx_build==413){
1780
                    my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
1781
                }else{
1782
                    my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1783
                }
1784
//       if (my < -l) my= -l, printf("C");
1785
//       else if (my >= l) my= l-1, printf("C");
1786 44eb4951 Michael Niedermayer
            }
1787 de6d9b64 Fabrice Bellard
            if (my >= 0xffff)
1788
                return -1;
1789
            s->mv[0][0][0] = mx;
1790
            s->mv[0][0][1] = my;
1791 102d3908 Juanjo
            /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
1792
            fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
1793
            fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
1794 544286b3 Juanjo
            if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1795 6dbd39fe Juanjo
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1796
                           
1797 de6d9b64 Fabrice Bellard
        } else {
1798
            s->mv_type = MV_TYPE_8X8;
1799
            for(i=0;i<4;i++) {
1800
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1801 544286b3 Juanjo
                if (s->umvplus_dec)
1802 6dbd39fe Juanjo
                  mx = h263p_decode_umotion(s, pred_x);
1803
                else
1804 6f91bcd1 Michael Niedermayer
                  mx = h263_decode_motion(s, pred_x, s->f_code);
1805 de6d9b64 Fabrice Bellard
                if (mx >= 0xffff)
1806
                    return -1;
1807 6dbd39fe Juanjo
                
1808 544286b3 Juanjo
                if (s->umvplus_dec)
1809 6dbd39fe Juanjo
                  my = h263p_decode_umotion(s, pred_y);
1810
                else    
1811 6f91bcd1 Michael Niedermayer
                  my = h263_decode_motion(s, pred_y, s->f_code);
1812 de6d9b64 Fabrice Bellard
                if (my >= 0xffff)
1813
                    return -1;
1814
                s->mv[0][i][0] = mx;
1815
                s->mv[0][i][1] = my;
1816 544286b3 Juanjo
                if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1817 6dbd39fe Juanjo
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1818 de6d9b64 Fabrice Bellard
                mot_val[0] = mx;
1819
                mot_val[1] = my;
1820
            }
1821
        }
1822 6f91bcd1 Michael Niedermayer
    } else if(s->pict_type==B_TYPE) {
1823
        int modb1; // first bit of modb
1824
        int modb2; // second bit of modb
1825
        int mb_type;
1826 9dbcbd92 Michael Niedermayer
        uint16_t time_pp;
1827
        uint16_t time_pb;
1828 6f91bcd1 Michael Niedermayer
        int xy;
1829
1830
        s->mb_intra = 0; //B-frames never contain intra blocks
1831
        s->mcsel=0;      //     ...               true gmc blocks
1832
1833
        if(s->mb_x==0){
1834
            s->last_mv[0][0][0]= 
1835
            s->last_mv[0][0][1]= 
1836
            s->last_mv[1][0][0]= 
1837
            s->last_mv[1][0][1]= 0;
1838 91029be7 Michael Niedermayer
//            printf("\n");
1839 6f91bcd1 Michael Niedermayer
        }
1840
1841
        /* if we skipped it in the future P Frame than skip it now too */
1842
        s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
1843
1844
        if(s->mb_skiped){
1845
                /* skip mb */
1846
            for(i=0;i<6;i++)
1847
                s->block_last_index[i] = -1;
1848
1849
            s->mv_dir = MV_DIR_FORWARD;
1850
            s->mv_type = MV_TYPE_16X16;
1851
            s->mv[0][0][0] = 0;
1852
            s->mv[0][0][1] = 0;
1853
            s->mv[1][0][0] = 0;
1854
            s->mv[1][0][1] = 0;
1855 d633c2c0 Michael Niedermayer
//FIXME is this correct?
1856
/*            s->last_mv[0][0][0]=
1857
            s->last_mv[0][0][1]=0;*/
1858 91029be7 Michael Niedermayer
//            printf("S");
1859 6f91bcd1 Michael Niedermayer
            return 0;
1860
        }
1861
1862
        modb1= get_bits1(&s->gb);
1863
        if(modb1==0){
1864
            modb2= get_bits1(&s->gb);
1865
            mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
1866
            if(modb2==0) cbp= get_bits(&s->gb, 6);
1867
            else cbp=0;
1868
            if (mb_type && cbp) {
1869
                if(get_bits1(&s->gb)){
1870
                    s->qscale +=get_bits1(&s->gb)*4 - 2;
1871
                    if (s->qscale < 1)
1872
                        s->qscale = 1;
1873
                    else if (s->qscale > 31)
1874
                        s->qscale = 31;
1875 49092244 Michael Niedermayer
                    h263_dc_scale(s);
1876 6f91bcd1 Michael Niedermayer
                }
1877
            }
1878
        }else{
1879
            mb_type=4; //like 0 but no vectors coded
1880
            cbp=0;
1881
        }
1882
        s->mv_type = MV_TYPE_16X16; // we'll switch to 8x8 only if the last P frame had 8x8 for this MB and mb_type=0 here
1883
        mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
1884
        switch(mb_type)
1885
        {
1886 9dbcbd92 Michael Niedermayer
        case 0: /* direct */
1887 6f91bcd1 Michael Niedermayer
            mx = h263_decode_motion(s, 0, 1);
1888
            my = h263_decode_motion(s, 0, 1);
1889 9dbcbd92 Michael Niedermayer
        case 4: /* direct with mx=my=0 */
1890 6f91bcd1 Michael Niedermayer
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1891 4278e7a6 Michael Niedermayer
            xy= s->block_index[0];
1892 9dbcbd92 Michael Niedermayer
            time_pp= s->pp_time;
1893
            time_pb= time_pp - s->bp_time;
1894 6f91bcd1 Michael Niedermayer
//if(time_pp>3000 )printf("%d %d  ", time_pp, time_pb);
1895
            //FIXME 4MV
1896
            //FIXME avoid divides
1897
            s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
1898
            s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
1899
            s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
1900
                                : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
1901
            s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
1902
                                : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
1903
/*            s->mv[0][0][0] = 
1904
            s->mv[0][0][1] = 
1905
            s->mv[1][0][0] = 
1906
            s->mv[1][0][1] = 1000;*/
1907 91029be7 Michael Niedermayer
//            printf("D");
1908 6f91bcd1 Michael Niedermayer
            break;
1909
        case 1: 
1910
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
1911
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1912
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1913
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1914
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1915
1916
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1917
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1918
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1919
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1920 91029be7 Michael Niedermayer
//            printf("I");
1921 6f91bcd1 Michael Niedermayer
            break;
1922
        case 2: 
1923
            s->mv_dir = MV_DIR_BACKWARD;
1924
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1925
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1926
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1927
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1928 91029be7 Michael Niedermayer
//            printf("B");
1929 6f91bcd1 Michael Niedermayer
            break;
1930
        case 3:
1931
            s->mv_dir = MV_DIR_FORWARD;
1932
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1933
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1934
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1935
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1936 91029be7 Michael Niedermayer
//            printf("F");
1937 6f91bcd1 Michael Niedermayer
            break;
1938
        default: return -1;
1939
        }
1940
    } else { /* I-Frame */
1941
        cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
1942
        if (cbpc < 0)
1943
            return -1;
1944
        dquant = cbpc & 4;
1945
        s->mb_intra = 1;
1946
intra:
1947 de6d9b64 Fabrice Bellard
        s->ac_pred = 0;
1948 d140623f Juanjo
        if (s->h263_pred || s->h263_aic) {
1949 612476ef Arpi
            s->ac_pred = get_bits1(&s->gb);
1950 d140623f Juanjo
            if (s->ac_pred && s->h263_aic)
1951
                s->h263_aic_dir = get_bits1(&s->gb);
1952 de6d9b64 Fabrice Bellard
        }
1953 9e15ad28 Juanjo
        if (s->h263_aic) {
1954
            s->y_dc_scale = 2 * s->qscale;
1955
            s->c_dc_scale = 2 * s->qscale;
1956
        }
1957 de6d9b64 Fabrice Bellard
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
1958
        cbp = (cbpc & 3) | (cbpy << 2);
1959
        if (dquant) {
1960
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
1961
            if (s->qscale < 1)
1962
                s->qscale = 1;
1963
            else if (s->qscale > 31)
1964
                s->qscale = 31;
1965 49092244 Michael Niedermayer
            h263_dc_scale(s);
1966 de6d9b64 Fabrice Bellard
        }
1967
    }
1968
1969
    /* decode each block */
1970
    if (s->h263_pred) {
1971
        for (i = 0; i < 6; i++) {
1972
            if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1973
                return -1;
1974
        }
1975
    } else {
1976
        for (i = 0; i < 6; i++) {
1977
            if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1978
                return -1;
1979
        }
1980
    }
1981
    return 0;
1982
}
1983
1984 6f91bcd1 Michael Niedermayer
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
1985 de6d9b64 Fabrice Bellard
{
1986
    int code, val, sign, shift, l, m;
1987
1988
    code = get_vlc(&s->gb, &mv_vlc);
1989
    if (code < 0)
1990
        return 0xffff;
1991
1992
    if (code == 0)
1993
        return pred;
1994 612476ef Arpi
    sign = get_bits1(&s->gb);
1995 6f91bcd1 Michael Niedermayer
    shift = f_code - 1;
1996 de6d9b64 Fabrice Bellard
    val = (code - 1) << shift;
1997
    if (shift > 0)
1998
        val |= get_bits(&s->gb, shift);
1999
    val++;
2000
    if (sign)
2001
        val = -val;
2002
    val += pred;
2003
    
2004
    /* modulo decoding */
2005
    if (!s->h263_long_vectors) {
2006 6f91bcd1 Michael Niedermayer
        l = (1 << (f_code - 1)) * 32;
2007 de6d9b64 Fabrice Bellard
        m = 2 * l;
2008
        if (val < -l) {
2009
            val += m;
2010
        } else if (val >= l) {
2011
            val -= m;
2012
        }
2013
    } else {
2014
        /* horrible h263 long vector mode */
2015
        if (pred < -31 && val < -63)
2016
            val += 64;
2017
        if (pred > 32 && val > 63)
2018
            val -= 64;
2019 102d3908 Juanjo
        
2020 de6d9b64 Fabrice Bellard
    }
2021
    return val;
2022
}
2023
2024 6dbd39fe Juanjo
/* Decodes RVLC of H.263+ UMV */
2025
static int h263p_decode_umotion(MpegEncContext * s, int pred)
2026
{
2027
   int code = 0, sign;
2028
   
2029
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
2030
      return pred;
2031
   
2032
   code = 2 + get_bits1(&s->gb);
2033
   
2034
   while (get_bits1(&s->gb))
2035
   {
2036
      code <<= 1;
2037
      code += get_bits1(&s->gb);
2038
   }
2039
   sign = code & 1;
2040
   code >>= 1;
2041
   
2042
   code = (sign) ? (pred - code) : (pred + code);
2043
#ifdef DEBUG
2044
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
2045
#endif
2046
   return code;   
2047
2048
}
2049
2050 de6d9b64 Fabrice Bellard
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
2051
                             int n, int coded)
2052
{
2053
    int code, level, i, j, last, run;
2054
    RLTable *rl = &rl_inter;
2055 d140623f Juanjo
    const UINT8 *scan_table;
2056 de6d9b64 Fabrice Bellard
2057 d140623f Juanjo
    scan_table = zigzag_direct;
2058 9e15ad28 Juanjo
    if (s->h263_aic && s->mb_intra) {
2059 d140623f Juanjo
        rl = &rl_intra_aic;
2060
        i = 0;
2061
        if (s->ac_pred) {
2062
            if (s->h263_aic_dir) 
2063
                scan_table = ff_alternate_vertical_scan; /* left */
2064
            else
2065
                scan_table = ff_alternate_horizontal_scan; /* top */
2066
        }
2067
    } else if (s->mb_intra) {
2068
        /* DC coef */
2069 de6d9b64 Fabrice Bellard
        if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
2070
            int component, diff;
2071
            component = (n <= 3 ? 0 : n - 4 + 1);
2072
            level = s->last_dc[component];
2073
            if (s->rv10_first_dc_coded[component]) {
2074
                diff = rv_decode_dc(s, n);
2075
                if (diff == 0xffff)
2076
                    return -1;
2077
                level += diff;
2078
                level = level & 0xff; /* handle wrap round */
2079
                s->last_dc[component] = level;
2080
            } else {
2081
                s->rv10_first_dc_coded[component] = 1;
2082
            }
2083
        } else {
2084
            level = get_bits(&s->gb, 8);
2085
            if (level == 255)
2086
                level = 128;
2087
        }
2088
        block[0] = level;
2089 d140623f Juanjo
        i = 1;
2090 de6d9b64 Fabrice Bellard
    } else {
2091 d140623f Juanjo
        i = 0;
2092 de6d9b64 Fabrice Bellard
    }
2093
    if (!coded) {
2094 9e15ad28 Juanjo
        if (s->mb_intra && s->h263_aic)
2095
            goto not_coded;
2096 de6d9b64 Fabrice Bellard
        s->block_last_index[n] = i - 1;
2097
        return 0;
2098
    }
2099
2100
    for(;;) {
2101
        code = get_vlc(&s->gb, &rl->vlc);
2102
        if (code < 0)
2103
            return -1;
2104
        if (code == rl->n) {
2105
            /* escape */
2106 612476ef Arpi
            last = get_bits1(&s->gb);
2107 de6d9b64 Fabrice Bellard
            run = get_bits(&s->gb, 6);
2108
            level = (INT8)get_bits(&s->gb, 8);
2109
            if (s->h263_rv10 && level == -128) {
2110
                /* XXX: should patch encoder too */
2111
                level = get_bits(&s->gb, 12);
2112
                level = (level << 20) >> 20;
2113
            }
2114
        } else {
2115
            run = rl->table_run[code];
2116
            level = rl->table_level[code];
2117
            last = code >= rl->last;
2118 612476ef Arpi
            if (get_bits1(&s->gb))
2119 de6d9b64 Fabrice Bellard
                level = -level;
2120
        }
2121
        i += run;
2122
        if (i >= 64)
2123
            return -1;
2124 d140623f Juanjo
        j = scan_table[i];
2125 de6d9b64 Fabrice Bellard
        block[j] = level;
2126
        if (last)
2127
            break;
2128
        i++;
2129
    }
2130 9e15ad28 Juanjo
not_coded:    
2131
    if (s->mb_intra && s->h263_aic) {
2132
        h263_pred_acdc(s, block, n);
2133 d6231b9e Michael Niedermayer
        i = 63;
2134 d140623f Juanjo
    }
2135 de6d9b64 Fabrice Bellard
    s->block_last_index[n] = i;
2136
    return 0;
2137
}
2138
2139
static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
2140
{
2141
    int level, pred, code;
2142
    UINT16 *dc_val;
2143
2144
    if (n < 4) 
2145
        code = get_vlc(&s->gb, &dc_lum);
2146
    else 
2147
        code = get_vlc(&s->gb, &dc_chrom);
2148
    if (code < 0)
2149
        return -1;
2150
    if (code == 0) {
2151
        level = 0;
2152
    } else {
2153
        level = get_bits(&s->gb, code);
2154
        if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
2155
            level = - (level ^ ((1 << code) - 1));
2156
        if (code > 8)
2157 612476ef Arpi
            skip_bits1(&s->gb); /* marker */
2158 de6d9b64 Fabrice Bellard
    }
2159
2160
    pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
2161
    level += pred;
2162
    if (level < 0)
2163
        level = 0;
2164
    if (n < 4) {
2165
        *dc_val = level * s->y_dc_scale;
2166
    } else {
2167
        *dc_val = level * s->c_dc_scale;
2168
    }
2169
    return level;
2170
}
2171
2172
static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
2173
                              int n, int coded)
2174
{
2175
    int code, level, i, j, last, run;
2176
    int dc_pred_dir;
2177
    RLTable *rl;
2178
    const UINT8 *scan_table;
2179
2180
    if (s->mb_intra) {
2181
        /* DC coef */
2182
        level = mpeg4_decode_dc(s, n, &dc_pred_dir);
2183
        if (level < 0)
2184
            return -1;
2185
        block[0] = level;
2186
        i = 1;
2187
        if (!coded) 
2188
            goto not_coded;
2189
        rl = &rl_intra;
2190
        if (s->ac_pred) {
2191
            if (dc_pred_dir == 0) 
2192
                scan_table = ff_alternate_vertical_scan; /* left */
2193
            else
2194
                scan_table = ff_alternate_horizontal_scan; /* top */
2195
        } else {
2196
            scan_table = zigzag_direct;
2197
        }
2198
    } else {
2199
        i = 0;
2200
        if (!coded) {
2201
            s->block_last_index[n] = i - 1;
2202
            return 0;
2203
        }
2204
        rl = &rl_inter;
2205
        scan_table = zigzag_direct;
2206
    }
2207
2208
    for(;;) {
2209
        code = get_vlc(&s->gb, &rl->vlc);
2210
        if (code < 0)
2211
            return -1;
2212
        if (code == rl->n) {
2213
            /* escape */
2214 612476ef Arpi
            if (get_bits1(&s->gb) != 0) {
2215
                if (get_bits1(&s->gb) != 0) {
2216 de6d9b64 Fabrice Bellard
                    /* third escape */
2217 612476ef Arpi
                    last = get_bits1(&s->gb);
2218 de6d9b64 Fabrice Bellard
                    run = get_bits(&s->gb, 6);
2219 612476ef Arpi
                    get_bits1(&s->gb); /* marker */
2220 de6d9b64 Fabrice Bellard
                    level = get_bits(&s->gb, 12);
2221
                    level = (level << 20) >> 20; /* sign extend */
2222 612476ef Arpi
                    skip_bits1(&s->gb); /* marker */
2223 de6d9b64 Fabrice Bellard
                } else {
2224
                    /* second escape */
2225
                    code = get_vlc(&s->gb, &rl->vlc);
2226
                    if (code < 0 || code >= rl->n)
2227
                        return -1;
2228
                    run = rl->table_run[code];
2229
                    level = rl->table_level[code];
2230
                    last = code >= rl->last;
2231
                    run += rl->max_run[last][level] + 1;
2232 612476ef Arpi
                    if (get_bits1(&s->gb))
2233 de6d9b64 Fabrice Bellard
                        level = -level;
2234
                }
2235
            } else {
2236
                /* first escape */
2237
                code = get_vlc(&s->gb, &rl->vlc);
2238
                if (code < 0 || code >= rl->n)
2239
                    return -1;
2240
                run = rl->table_run[code];
2241
                level = rl->table_level[code];
2242
                last = code >= rl->last;
2243
                level += rl->max_level[last][run];
2244 612476ef Arpi
                if (get_bits1(&s->gb))
2245 de6d9b64 Fabrice Bellard
                    level = -level;
2246
            }
2247
        } else {
2248
            run = rl->table_run[code];
2249
            level = rl->table_level[code];
2250
            last = code >= rl->last;
2251 612476ef Arpi
            if (get_bits1(&s->gb))
2252 de6d9b64 Fabrice Bellard
                level = -level;
2253
        }
2254
        i += run;
2255
        if (i >= 64)
2256
            return -1;
2257
        j = scan_table[i];
2258
        block[j] = level;
2259
        i++;
2260
        if (last)
2261
            break;
2262
    }
2263
 not_coded:
2264
    if (s->mb_intra) {
2265
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
2266
        if (s->ac_pred) {
2267
            i = 64; /* XXX: not optimal */
2268
        }
2269
    }
2270
    s->block_last_index[n] = i - 1;
2271
    return 0;
2272
}
2273
2274
/* most is hardcoded. should extend to handle all h263 streams */
2275
int h263_decode_picture_header(MpegEncContext *s)
2276
{
2277
    int format, width, height;
2278
2279
    /* picture header */
2280
    if (get_bits(&s->gb, 22) != 0x20)
2281
        return -1;
2282 81401c1f Juanjo
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
2283
    
2284 612476ef Arpi
    if (get_bits1(&s->gb) != 1)
2285 de6d9b64 Fabrice Bellard
        return -1;        /* marker */
2286 612476ef Arpi
    if (get_bits1(&s->gb) != 0)
2287 de6d9b64 Fabrice Bellard
        return -1;        /* h263 id */
2288 612476ef Arpi
    skip_bits1(&s->gb);        /* split screen off */
2289
    skip_bits1(&s->gb);        /* camera  off */
2290
    skip_bits1(&s->gb);        /* freeze picture release off */
2291 de6d9b64 Fabrice Bellard
2292 8547282b Juanjo
    /* Reset GOB number */
2293 102d3908 Juanjo
    s->gob_number = 0;
2294 8547282b Juanjo
        
2295 de6d9b64 Fabrice Bellard
    format = get_bits(&s->gb, 3);
2296
2297 96815ce9 Juanjo
    if (format != 7 && format != 6) {
2298 de6d9b64 Fabrice Bellard
        s->h263_plus = 0;
2299
        /* H.263v1 */
2300
        width = h263_format[format][0];
2301
        height = h263_format[format][1];
2302
        if (!width)
2303
            return -1;
2304 96815ce9 Juanjo
        
2305
        s->width = width;
2306
        s->height = height;
2307 612476ef Arpi
        s->pict_type = I_TYPE + get_bits1(&s->gb);
2308 de6d9b64 Fabrice Bellard
2309 612476ef Arpi
        s->unrestricted_mv = get_bits1(&s->gb); 
2310 de6d9b64 Fabrice Bellard
        s->h263_long_vectors = s->unrestricted_mv;
2311
2312 612476ef Arpi
        if (get_bits1(&s->gb) != 0)
2313 de6d9b64 Fabrice Bellard
            return -1;        /* SAC: off */
2314 96815ce9 Juanjo
        if (get_bits1(&s->gb) != 0) {
2315
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
2316
        }   
2317
        
2318 612476ef Arpi
        if (get_bits1(&s->gb) != 0)
2319 de6d9b64 Fabrice Bellard
            return -1;        /* not PB frame */
2320
2321
        s->qscale = get_bits(&s->gb, 5);
2322 612476ef Arpi
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
2323 de6d9b64 Fabrice Bellard
    } else {
2324 96815ce9 Juanjo
        int ufep;
2325
        
2326 de6d9b64 Fabrice Bellard
        /* H.263v2 */
2327 96815ce9 Juanjo
        s->h263_plus = 1;
2328
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
2329 6dbd39fe Juanjo
        
2330 96815ce9 Juanjo
        if (ufep == 1) {
2331
            /* OPPTYPE */       
2332
            format = get_bits(&s->gb, 3);
2333
            skip_bits(&s->gb,1); /* Custom PCF */
2334
            s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
2335
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
2336
            if (get_bits1(&s->gb) != 0) {
2337
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
2338
            }
2339 d140623f Juanjo
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
2340
                s->h263_aic = 1;
2341
            }
2342
            skip_bits(&s->gb, 7);
2343 96815ce9 Juanjo
            skip_bits(&s->gb, 3); /* Reserved */
2344
        } else if (ufep != 0)
2345
            return -1;
2346
            
2347 6dbd39fe Juanjo
        /* MPPTYPE */
2348 de6d9b64 Fabrice Bellard
        s->pict_type = get_bits(&s->gb, 3) + 1;
2349
        if (s->pict_type != I_TYPE &&
2350
            s->pict_type != P_TYPE)
2351
            return -1;
2352 e7774f11 Juanjo
        skip_bits(&s->gb, 2);
2353
        s->no_rounding = get_bits1(&s->gb);
2354
        //fprintf(stderr, "\nRTYPE: %d", s->no_rounding);
2355
        skip_bits(&s->gb, 4);
2356 6dbd39fe Juanjo
        
2357
        /* Get the picture dimensions */
2358 96815ce9 Juanjo
        if (ufep) {
2359
            if (format == 6) {
2360
                /* Custom Picture Format (CPFMT) */
2361
                skip_bits(&s->gb, 4); /* aspect ratio */
2362
                width = (get_bits(&s->gb, 9) + 1) * 4;
2363
                skip_bits1(&s->gb);
2364
                height = get_bits(&s->gb, 9) * 4;
2365 6dbd39fe Juanjo
#ifdef DEBUG 
2366 96815ce9 Juanjo
                fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);
2367 6dbd39fe Juanjo
#endif            
2368 96815ce9 Juanjo
            }
2369
            else {
2370
                width = h263_format[format][0];
2371
                height = h263_format[format][1];
2372
            }
2373
            if ((width == 0) || (height == 0))
2374
                return -1;
2375
            s->width = width;
2376
            s->height = height;
2377
            if (s->umvplus_dec) {
2378
                skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
2379
            }
2380 6dbd39fe Juanjo
        }
2381
            
2382 de6d9b64 Fabrice Bellard
        s->qscale = get_bits(&s->gb, 5);
2383
    }
2384
    /* PEI */
2385 612476ef Arpi
    while (get_bits1(&s->gb) != 0) {
2386
        skip_bits(&s->gb, 8);
2387 de6d9b64 Fabrice Bellard
    }
2388
    s->f_code = 1;
2389
    return 0;
2390
}
2391
2392 73c8e514 Michael Niedermayer
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
2393
{
2394
    int i;
2395
    int a= 2<<s->sprite_warping_accuracy;
2396
    int rho= 3-s->sprite_warping_accuracy;
2397
    int r=16/a;
2398
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
2399
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
2400
    int sprite_ref[4][2];
2401
    int virtual_ref[2][2];
2402
    int w2, h2;
2403
    int alpha=0, beta=0;
2404
    int w= s->width;
2405
    int h= s->height;
2406 44eb4951 Michael Niedermayer
//printf("SP %d\n", s->sprite_warping_accuracy);
2407 73c8e514 Michael Niedermayer
    for(i=0; i<s->num_sprite_warping_points; i++){
2408
        int length;
2409
        int x=0, y=0;
2410
2411
        length= get_vlc(&s->gb, &sprite_trajectory);
2412
        if(length){
2413
            x= get_bits(&s->gb, length);
2414 44eb4951 Michael Niedermayer
//printf("lx %d %d\n", length, x);
2415 73c8e514 Michael Niedermayer
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
2416
                x = - (x ^ ((1 << length) - 1));
2417
        }
2418 44eb4951 Michael Niedermayer
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
2419 73c8e514 Michael Niedermayer
        
2420
        length= get_vlc(&s->gb, &sprite_trajectory);
2421
        if(length){
2422
            y=get_bits(&s->gb, length);
2423 44eb4951 Michael Niedermayer
//printf("ly %d %d\n", length, y);
2424 73c8e514 Michael Niedermayer
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
2425
                y = - (y ^ ((1 << length) - 1));
2426
        }
2427
        skip_bits1(&s->gb); /* marker bit */
2428 44eb4951 Michael Niedermayer
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
2429 73c8e514 Michael Niedermayer
//if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
2430 44eb4951 Michael Niedermayer
//x=y=0;
2431 73c8e514 Michael Niedermayer
        d[i][0]= x;
2432
        d[i][1]= y;
2433
    }
2434
2435
    while((1<<alpha)<w) alpha++;
2436
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
2437
    w2= 1<<alpha;
2438
    h2= 1<<beta;
2439
2440
// Note, the 4th point isnt used for GMC
2441 6f91bcd1 Michael Niedermayer
    if(s->divx_version==500 && s->divx_build==413){
2442
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
2443
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
2444
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
2445
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
2446
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
2447
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
2448
    } else {
2449
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
2450
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
2451
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
2452
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
2453
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
2454
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
2455
    }
2456 73c8e514 Michael Niedermayer
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
2457
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
2458
    
2459
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
2460
// perhaps it should be reordered to be more readable ...
2461
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
2462
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
2463
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
2464 44eb4951 Michael Niedermayer
        + RDIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
2465 73c8e514 Michael Niedermayer
    virtual_ref[0][1]= 16*vop_ref[0][1] 
2466 44eb4951 Michael Niedermayer
        + RDIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
2467 73c8e514 Michael Niedermayer
    virtual_ref[1][0]= 16*vop_ref[0][0] 
2468 44eb4951 Michael Niedermayer
        + RDIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
2469 73c8e514 Michael Niedermayer
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
2470 44eb4951 Michael Niedermayer
        + RDIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
2471 73c8e514 Michael Niedermayer
2472
    switch(s->num_sprite_warping_points)
2473
    {
2474
        case 0:
2475
            s->sprite_offset[0][0]= 0;
2476
            s->sprite_offset[0][1]= 0;
2477
            s->sprite_offset[1][0]= 0;
2478
            s->sprite_offset[1][1]= 0;
2479
            s->sprite_delta[0][0][0]= a;
2480
            s->sprite_delta[0][0][1]= 0;
2481
            s->sprite_delta[0][1][0]= 0;
2482
            s->sprite_delta[0][1][1]= a;
2483
            s->sprite_delta[1][0][0]= a;
2484
            s->sprite_delta[1][0][1]= 0;
2485
            s->sprite_delta[1][1][0]= 0;
2486
            s->sprite_delta[1][1][1]= a;
2487
            s->sprite_shift[0][0]= 0;
2488
            s->sprite_shift[0][1]= 0;
2489
            s->sprite_shift[1][0]= 0;
2490
            s->sprite_shift[1][1]= 0;
2491
            break;
2492
        case 1: //GMC only
2493
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
2494
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
2495
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
2496
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
2497
            s->sprite_delta[0][0][0]= a;
2498
            s->sprite_delta[0][0][1]= 0;
2499
            s->sprite_delta[0][1][0]= 0;
2500
            s->sprite_delta[0][1][1]= a;
2501
            s->sprite_delta[1][0][0]= a;
2502
            s->sprite_delta[1][0][1]= 0;
2503
            s->sprite_delta[1][1][0]= 0;
2504
            s->sprite_delta[1][1][1]= a;
2505
            s->sprite_shift[0][0]= 0;
2506
            s->sprite_shift[0][1]= 0;
2507
            s->sprite_shift[1][0]= 0;
2508
            s->sprite_shift[1][1]= 0;
2509
            break;
2510
        case 2:
2511
        case 3: //FIXME
2512
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
2513
                                                  + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
2514
                                                    +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
2515
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
2516
                                                  + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
2517
                                                    +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
2518
            s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
2519
                                 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
2520
                                 +2*w2*r*sprite_ref[0][0] - 16*w2);
2521
            s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
2522
                                 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
2523
                                 +2*w2*r*sprite_ref[0][1] - 16*w2);
2524
            s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2525
            s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);
2526
            s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
2527
            s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2528
            s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2529
            s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
2530
            s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
2531
            s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2532
            s->sprite_shift[0][0]= alpha+rho;
2533
            s->sprite_shift[0][1]= alpha+rho;
2534
            s->sprite_shift[1][0]= alpha+rho+2;
2535
            s->sprite_shift[1][1]= alpha+rho+2;
2536
            break;
2537
//        case 3:
2538
            break;
2539
    }
2540 44eb4951 Michael Niedermayer
/*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
2541
printf("%d %d\n", s->sprite_delta[0][0][1], 0);
2542
printf("%d %d\n", s->sprite_delta[0][1][0], 0);
2543
printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
2544
printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
2545
printf("%d %d\n", s->sprite_delta[1][0][1], 0);
2546
printf("%d %d\n", s->sprite_delta[1][1][0], 0);
2547
printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
2548
    /* try to simplify the situation */ 
2549
    if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
2550
       && s->sprite_delta[0][0][1] == 0
2551
       && s->sprite_delta[0][1][0] == 0
2552
       && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
2553
       && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
2554
       && s->sprite_delta[1][0][1] == 0
2555
       && s->sprite_delta[1][1][0] == 0
2556
       && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
2557
    {
2558
        s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
2559
        s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
2560
        s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
2561
        s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
2562
        s->sprite_delta[0][0][0]= a;
2563
        s->sprite_delta[0][0][1]= 0;
2564
        s->sprite_delta[0][1][0]= 0;
2565
        s->sprite_delta[0][1][1]= a;
2566
        s->sprite_delta[1][0][0]= a;
2567
        s->sprite_delta[1][0][1]= 0;
2568
        s->sprite_delta[1][1][0]= 0;
2569
        s->sprite_delta[1][1][1]= a;
2570
        s->sprite_shift[0][0]= 0;
2571
        s->sprite_shift[0][1]= 0;
2572
        s->sprite_shift[1][0]= 0;
2573
        s->sprite_shift[1][1]= 0;
2574
        s->real_sprite_warping_points=1;
2575
    }
2576
    else
2577
        s->real_sprite_warping_points= s->num_sprite_warping_points;
2578 73c8e514 Michael Niedermayer
2579 14ae07d8 Michael Niedermayer
//printf("%d %d %d %d\n", d[0][0], d[0][1], s->sprite_offset[0][0], s->sprite_offset[0][1]);
2580 73c8e514 Michael Niedermayer
}
2581
2582 de6d9b64 Fabrice Bellard
/* decode mpeg4 VOP header */
2583
int mpeg4_decode_picture_header(MpegEncContext * s)
2584
{
2585
    int time_incr, startcode, state, v;
2586 9dbcbd92 Michael Niedermayer
    int time_increment;
2587 f94985d0 Michael Niedermayer
    int vol_control=-1;
2588 de6d9b64 Fabrice Bellard
2589
 redo:
2590
    /* search next start code */
2591
    align_get_bits(&s->gb);
2592
    state = 0xff;
2593
    for(;;) {
2594
        v = get_bits(&s->gb, 8);
2595
        if (state == 0x000001) {
2596
            state = ((state << 8) | v) & 0xffffff;
2597
            startcode = state;
2598
            break;
2599
        }
2600
        state = ((state << 8) | v) & 0xffffff;
2601 c7d5049c Michael Niedermayer
        if( get_bits_count(&s->gb) > s->gb.size*8-32){
2602 eec1c6b9 Michael Niedermayer
            if(s->gb.size>50){
2603
                printf("no VOP startcode found, frame size was=%d\n", s->gb.size);
2604
                return -1;
2605
            }else{
2606
                printf("frame skip\n");
2607
                return FRAME_SKIPED;
2608
            }
2609 10cd5815 Michael Niedermayer
        }
2610 de6d9b64 Fabrice Bellard
    }
2611 cc9ba006 Michael Niedermayer
//printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
2612
    if (startcode == 0x120) { // Video Object Layer
2613 6f91bcd1 Michael Niedermayer
        int width, height, vo_ver_id;
2614 de6d9b64 Fabrice Bellard
2615
        /* vol header */
2616 612476ef Arpi
        skip_bits(&s->gb, 1); /* random access */
2617 1ff662cc Michael Niedermayer
        s->vo_type= get_bits(&s->gb, 8);
2618 d95ecd05 Fabrice Bellard
        if (get_bits1(&s->gb) != 0) { /* is_ol_id */
2619
            vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
2620
            skip_bits(&s->gb, 3); /* vo_priority */
2621
        } else {
2622
            vo_ver_id = 1;
2623
        }
2624 1c2a8c7f Michael Niedermayer
//printf("vo type:%d\n",s->vo_type);
2625 cc9ba006 Michael Niedermayer
        s->aspect_ratio_info= get_bits(&s->gb, 4);
2626
        if(s->aspect_ratio_info == EXTENDET_PAR){
2627
            skip_bits(&s->gb, 8); //par_width
2628
            skip_bits(&s->gb, 8); // par_height
2629
        }
2630 11ce8834 Michael Niedermayer
2631 f94985d0 Michael Niedermayer
        if(vol_control=get_bits1(&s->gb)){ /* vol control parameter */
2632 1ff662cc Michael Niedermayer
            int chroma_format= get_bits(&s->gb, 2);
2633
            if(chroma_format!=1){
2634
                printf("illegal chroma format\n");
2635
            }
2636
            s->low_delay= get_bits1(&s->gb);
2637
            if(get_bits1(&s->gb)){ /* vbv parameters */
2638
                printf("vbv parameters not supported\n");
2639
                return -1;
2640
            }
2641
        }else{
2642
            s->low_delay=0;
2643 cc9ba006 Michael Niedermayer
        }
2644 1ff662cc Michael Niedermayer
2645 d95ecd05 Fabrice Bellard
        s->shape = get_bits(&s->gb, 2); /* vol shape */
2646 49c9325f Michael Niedermayer
        if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
2647 cc9ba006 Michael Niedermayer
        if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
2648
            printf("Gray shape not supported\n");
2649
            skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
2650
        }
2651
2652 612476ef Arpi
        skip_bits1(&s->gb);   /* marker */
2653 de6d9b64 Fabrice Bellard
        
2654 6f91bcd1 Michael Niedermayer
        s->time_increment_resolution = get_bits(&s->gb, 16);
2655
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
2656 d95ecd05 Fabrice Bellard
        if (s->time_increment_bits < 1)
2657
            s->time_increment_bits = 1;
2658 612476ef Arpi
        skip_bits1(&s->gb);   /* marker */
2659 de6d9b64 Fabrice Bellard
2660 d95ecd05 Fabrice Bellard
        if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
2661
            skip_bits(&s->gb, s->time_increment_bits);
2662
        }
2663
2664 cc9ba006 Michael Niedermayer
        if (s->shape != BIN_ONLY_SHAPE) {
2665
            if (s->shape == RECT_SHAPE) {
2666 d95ecd05 Fabrice Bellard
                skip_bits1(&s->gb);   /* marker */
2667
                width = get_bits(&s->gb, 13);
2668
                skip_bits1(&s->gb);   /* marker */
2669
                height = get_bits(&s->gb, 13);
2670
                skip_bits1(&s->gb);   /* marker */
2671 488fa19a Michael Niedermayer
                if(width && height){ /* they should be non zero but who knows ... */
2672
                    s->width = width;
2673
                    s->height = height;
2674 ee6f7861 Michael Niedermayer
//                    printf("width/height: %d %d\n", width, height);
2675 488fa19a Michael Niedermayer
                }
2676 d95ecd05 Fabrice Bellard
            }
2677
            
2678 49c9325f Michael Niedermayer
            if(get_bits1(&s->gb)) printf("interlaced not supported\n");   /* interlaced */
2679 73c8e514 Michael Niedermayer
            if(!get_bits1(&s->gb)) printf("OBMC not supported\n");   /* OBMC Disable */
2680 d95ecd05 Fabrice Bellard
            if (vo_ver_id == 1) {
2681
                s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
2682
            } else {
2683
                s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
2684
            }
2685 73c8e514 Michael Niedermayer
            if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
2686 cc9ba006 Michael Niedermayer
            if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
2687
                if(s->vol_sprite_usage==STATIC_SPRITE){
2688
                    s->sprite_width = get_bits(&s->gb, 13);
2689
                    skip_bits1(&s->gb); /* marker */
2690
                    s->sprite_height= get_bits(&s->gb, 13);
2691
                    skip_bits1(&s->gb); /* marker */
2692
                    s->sprite_left  = get_bits(&s->gb, 13);
2693
                    skip_bits1(&s->gb); /* marker */
2694
                    s->sprite_top   = get_bits(&s->gb, 13);
2695
                    skip_bits1(&s->gb); /* marker */
2696
                }
2697 73c8e514 Michael Niedermayer
                s->num_sprite_warping_points= get_bits(&s->gb, 6);
2698 cc9ba006 Michael Niedermayer
                s->sprite_warping_accuracy = get_bits(&s->gb, 2);
2699
                s->sprite_brightness_change= get_bits1(&s->gb);
2700
                if(s->vol_sprite_usage==STATIC_SPRITE)
2701
                    s->low_latency_sprite= get_bits1(&s->gb);            
2702
            }
2703
            // FIXME sadct disable bit if verid!=1 && shape not rect
2704
            
2705 d95ecd05 Fabrice Bellard
            if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
2706
                s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
2707 49c9325f Michael Niedermayer
                if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
2708 49092244 Michael Niedermayer
                if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
2709 d95ecd05 Fabrice Bellard
            } else {
2710
                s->quant_precision = 5;
2711
            }
2712
            
2713 cc9ba006 Michael Niedermayer
            // FIXME a bunch of grayscale shape things
2714 3bf43d42 Michael Niedermayer
2715
            if(get_bits1(&s->gb)){ /* vol_quant_type */
2716
                int i, j, v;
2717
                /* load default matrixes */
2718
                for(i=0; i<64; i++){
2719
                    v= ff_mpeg4_default_intra_matrix[i];
2720
                    s->intra_matrix[i]= v;
2721
                    s->chroma_intra_matrix[i]= v;
2722
                    
2723
                    v= ff_mpeg4_default_non_intra_matrix[i];
2724 d7e9533a Michael Niedermayer
                    s->inter_matrix[i]= v;
2725
                    s->chroma_inter_matrix[i]= v;
2726 3bf43d42 Michael Niedermayer
                }
2727
2728
                /* load custom intra matrix */
2729
                if(get_bits1(&s->gb)){
2730
                    for(i=0; i<64; i++){
2731
                        v= get_bits(&s->gb, 8);
2732
                        if(v==0) break;
2733
2734
                        j= zigzag_direct[i];
2735
                        s->intra_matrix[j]= v;
2736
                        s->chroma_intra_matrix[j]= v;
2737
                    }
2738
                }
2739
2740
                /* load custom non intra matrix */
2741
                if(get_bits1(&s->gb)){
2742
                    for(i=0; i<64; i++){
2743
                        v= get_bits(&s->gb, 8);
2744
                        if(v==0) break;
2745
2746
                        j= zigzag_direct[i];
2747 d7e9533a Michael Niedermayer
                        s->inter_matrix[j]= v;
2748
                        s->chroma_inter_matrix[j]= v;
2749 3bf43d42 Michael Niedermayer
                    }
2750
2751
                    /* replicate last value */
2752
                    for(; i<64; i++){
2753
                        j= zigzag_direct[i];
2754 d7e9533a Michael Niedermayer
                        s->inter_matrix[j]= v;
2755
                        s->chroma_inter_matrix[j]= v;
2756 3bf43d42 Michael Niedermayer
                    }
2757
                }
2758
2759 9dbf1ddd Michael Niedermayer
                s->dct_unquantize= s->dct_unquantize_mpeg2;
2760 3bf43d42 Michael Niedermayer
2761
                // FIXME a bunch of grayscale shape things
2762
            }else
2763
                s->dct_unquantize= s->dct_unquantize_h263;
2764
2765 cc9ba006 Michael Niedermayer
            if(vo_ver_id != 1)
2766
                 s->quarter_sample= get_bits1(&s->gb);
2767
            else s->quarter_sample=0;
2768 49c9325f Michael Niedermayer
2769
            if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
2770 49092244 Michael Niedermayer
2771
            s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */
2772
2773 cc9ba006 Michael Niedermayer
            s->data_partioning= get_bits1(&s->gb);
2774
            if(s->data_partioning){
2775
                printf("data partitioning not supported\n");
2776
                skip_bits1(&s->gb); // reversible vlc
2777
            }
2778
            
2779
            if(vo_ver_id != 1) {
2780
                s->new_pred= get_bits1(&s->gb);
2781
                if(s->new_pred){
2782
                    printf("new pred not supported\n");
2783
                    skip_bits(&s->gb, 2); /* requested upstream message type */
2784
                    skip_bits1(&s->gb); /* newpred segment type */
2785
                }
2786
                s->reduced_res_vop= get_bits1(&s->gb);
2787
                if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
2788
            }
2789
            else{
2790
                s->new_pred=0;
2791
                s->reduced_res_vop= 0;
2792
            }
2793
2794
            s->scalability= get_bits1(&s->gb);
2795
            if (s->scalability) {
2796 b1563bfe Michael Niedermayer
                printf("scalability not supported\n");
2797 d95ecd05 Fabrice Bellard
            }
2798
        }
2799 cc9ba006 Michael Niedermayer
//printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
2800 de6d9b64 Fabrice Bellard
        goto redo;
2801 cc9ba006 Michael Niedermayer
    } else if (startcode == 0x1b2) { //userdata
2802 44eb4951 Michael Niedermayer
        char buf[256];
2803
        int i;
2804
        int e;
2805
        int ver, build;
2806
2807 cc9ba006 Michael Niedermayer
//printf("user Data %X\n", show_bits(&s->gb, 32));
2808 44eb4951 Michael Niedermayer
        buf[0]= show_bits(&s->gb, 8);
2809
        for(i=1; i<256; i++){
2810
            buf[i]= show_bits(&s->gb, 16)&0xFF;
2811
            if(buf[i]==0) break;
2812
            skip_bits(&s->gb, 8);
2813
        }
2814
        buf[255]=0;
2815
        e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
2816 eec1c6b9 Michael Niedermayer
        if(e!=2)
2817
            e=sscanf(buf, "DivX%db%d", &ver, &build);
2818 44eb4951 Michael Niedermayer
        if(e==2){
2819
            s->divx_version= ver;
2820
            s->divx_build= build;
2821
            if(s->picture_number==0){
2822
                printf("This file was encoded with DivX%d Build%d\n", ver, build);
2823 eec1c6b9 Michael Niedermayer
                if(ver==500 && build==413){
2824 44eb4951 Michael Niedermayer
                    printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
2825 eec1c6b9 Michael Niedermayer
#if 0
2826 44eb4951 Michael Niedermayer
                }else{
2827
                    printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
2828
                           "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
2829 eec1c6b9 Michael Niedermayer
#endif 
2830 44eb4951 Michael Niedermayer
                }
2831
            }
2832
        }
2833
//printf("User Data: %s\n", buf);
2834 cc9ba006 Michael Niedermayer
        goto redo;
2835
    } else if (startcode != 0x1b6) { //VOP
2836 de6d9b64 Fabrice Bellard
        goto redo;
2837
    }
2838
2839
    s->pict_type = get_bits(&s->gb, 2) + 1;        /* pict type: I = 0 , P = 1 */
2840 9dbcbd92 Michael Niedermayer
// printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample); 
2841 6f91bcd1 Michael Niedermayer
    time_incr=0;
2842 612476ef Arpi
    while (get_bits1(&s->gb) != 0) 
2843 de6d9b64 Fabrice Bellard
        time_incr++;
2844
2845 49c9325f Michael Niedermayer
    check_marker(&s->gb, "before time_increment");
2846 9dbcbd92 Michael Niedermayer
    time_increment= get_bits(&s->gb, s->time_increment_bits);
2847
//printf(" type:%d incr:%d increment:%d\n", s->pict_type, time_incr, time_increment);
2848 6f91bcd1 Michael Niedermayer
    if(s->pict_type!=B_TYPE){
2849 9dbcbd92 Michael Niedermayer
        s->last_time_base= s->time_base;
2850 6f91bcd1 Michael Niedermayer
        s->time_base+= time_incr;
2851 9dbcbd92 Michael Niedermayer
        s->time= s->time_base*s->time_increment_resolution + time_increment;
2852
        s->pp_time= s->time - s->last_non_b_time;
2853
        s->last_non_b_time= s->time;
2854 6f91bcd1 Michael Niedermayer
    }else{
2855 9dbcbd92 Michael Niedermayer
        s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
2856
        s->bp_time= s->last_non_b_time - s->time;
2857 8d4c65d1 Michael Niedermayer
        if(s->pp_time <=s->bp_time){
2858
//            printf("messed up order, seeking?, skiping current b frame\n");
2859
            return FRAME_SKIPED;
2860
        }
2861 6f91bcd1 Michael Niedermayer
    }
2862 49c9325f Michael Niedermayer
2863
    if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
2864
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
2865
        for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
2866
            if(get_bits1(&s->gb)) break;
2867
        }
2868
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
2869
    }
2870 de6d9b64 Fabrice Bellard
    /* vop coded */
2871 612476ef Arpi
    if (get_bits1(&s->gb) != 1)
2872 d95ecd05 Fabrice Bellard
        goto redo;
2873 6f91bcd1 Michael Niedermayer
//printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
2874
//s->time, s->last_non_b_time[0], s->last_non_b_time[1]);  
2875 cc9ba006 Michael Niedermayer
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
2876
                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
2877 de6d9b64 Fabrice Bellard
        /* rounding type for motion estimation */
2878 612476ef Arpi
        s->no_rounding = get_bits1(&s->gb);
2879 d95ecd05 Fabrice Bellard
    } else {
2880
        s->no_rounding = 0;
2881 de6d9b64 Fabrice Bellard
    }
2882 cc9ba006 Michael Niedermayer
//FIXME reduced res stuff
2883
2884
     if (s->shape != RECT_SHAPE) {
2885 d95ecd05 Fabrice Bellard
         if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
2886
             int width, height, hor_spat_ref, ver_spat_ref;
2887
 
2888
             width = get_bits(&s->gb, 13);
2889
             skip_bits1(&s->gb);   /* marker */
2890
             height = get_bits(&s->gb, 13);
2891
             skip_bits1(&s->gb);   /* marker */
2892
             hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
2893
             skip_bits1(&s->gb);   /* marker */
2894
             ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */