Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 8f8402e4

History | View | Annotate | Download (130 KB)

1
/*
2
 * H263/MPEG4 backend for ffmpeg encoder and decoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 * H263+ support.
5
 * Copyright (c) 2001 Juan J. Sierralta P.
6
 *
7
 * This library is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2 of the License, or (at your option) any later version.
11
 *
12
 * This library 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 GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library; if not, write to the Free Software
19
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20
 *
21
 * ac prediction encoding & b-frame support by Michael Niedermayer <michaelni@gmx.at>
22
 */
23
 
24
//#define DEBUG
25
#include "common.h"
26
#include "dsputil.h"
27
#include "avcodec.h"
28
#include "mpegvideo.h"
29
#include "h263data.h"
30
#include "mpeg4data.h"
31

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

    
35
#define PRINT_MB_TYPE(a) ;
36
//#define PRINT_MB_TYPE(a) printf(a);
37

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

    
57
extern UINT32 inverse[256];
58

    
59
static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
60
static UINT8 fcode_tab[MAX_MV*2+1];
61
static UINT8 umv_fcode_tab[MAX_MV*2+1];
62

    
63
static UINT16 uni_DCtab_lum  [512][2];
64
static UINT16 uni_DCtab_chrom[512][2];
65

    
66
int h263_get_picture_format(int width, int height)
67
{
68
    int format;
69

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

    
85
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
86
{
87
    int format;
88

    
89
    align_put_bits(&s->pb);
90

    
91
    /* Update the pointer to last GOB */
92
    s->ptr_lastgob = pbBufPtr(&s->pb);
93
    s->gob_number = 0;
94

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

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

    
177
    put_bits(&s->pb, 1, 0);        /* no PEI */
178

    
179
    if(s->h263_aic){
180
         s->y_dc_scale_table= 
181
         s->c_dc_scale_table= h263_aic_dc_scale_table;
182
    }else{
183
        s->y_dc_scale_table=
184
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
185
    }
186
}
187

    
188
int h263_encode_gob_header(MpegEncContext * s, int mb_line)
189
{
190
    int pdif=0;
191
    
192
    /* Check to see if we need to put a new GBSC */
193
    /* for RTP packetization                    */
194
    if (s->rtp_mode) {
195
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
196
        if (pdif >= s->rtp_payload_size) {
197
            /* Bad luck, packet must be cut before */
198
            align_put_bits(&s->pb);
199
            flush_put_bits(&s->pb);
200
            /* Call the RTP callback to send the last GOB */
201
            if (s->rtp_callback) {
202
                pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
203
                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
204
            }
205
            s->ptr_lastgob = pbBufPtr(&s->pb);
206
            put_bits(&s->pb, 17, 1); /* GBSC */
207
            s->gob_number = mb_line / s->gob_index;
208
            put_bits(&s->pb, 5, s->gob_number); /* GN */
209
            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
210
            put_bits(&s->pb, 5, s->qscale); /* GQUANT */
211
            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
212
            return pdif;
213
       } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
214
           /* Cut the packet before we can't */
215
           align_put_bits(&s->pb);
216
           flush_put_bits(&s->pb);
217
           /* Call the RTP callback to send the last GOB */
218
           if (s->rtp_callback) {
219
               pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
220
               s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
221
           }
222
           s->ptr_lastgob = pbBufPtr(&s->pb);
223
           put_bits(&s->pb, 17, 1); /* GBSC */
224
           s->gob_number = mb_line / s->gob_index;
225
           put_bits(&s->pb, 5, s->gob_number); /* GN */
226
           put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
227
           put_bits(&s->pb, 5, s->qscale); /* GQUANT */
228
           //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
229
           return pdif;
230
       }
231
   }
232
   return 0;
233
}
234

    
235
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
236
{
237
    int score0=0, score1=0;
238
    int i, n;
239

    
240
    for(n=0; n<6; n++){
241
        INT16 *ac_val, *ac_val1;
242

    
243
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
244
        ac_val1= ac_val;
245
        if(dir[n]){
246
            ac_val-= s->block_wrap[n]*16;
247
            for(i=1; i<8; i++){
248
                const int level= block[n][block_permute_op(i   )];
249
                score0+= ABS(level);
250
                score1+= ABS(level - ac_val[i+8]);
251
                ac_val1[i  ]=    block[n][block_permute_op(i<<3)];
252
                ac_val1[i+8]= level;
253
            }
254
        }else{
255
            ac_val-= 16;
256
            for(i=1; i<8; i++){
257
                const int level= block[n][block_permute_op(i<<3)];
258
                score0+= ABS(level);
259
                score1+= ABS(level - ac_val[i]);
260
                ac_val1[i  ]= level;
261
                ac_val1[i+8]=    block[n][block_permute_op(i   )];
262
            }
263
        }
264
    }
265

    
266
    return score0 > score1 ? 1 : 0;    
267
}
268

    
269
void mpeg4_encode_mb(MpegEncContext * s,
270
                    DCTELEM block[6][64],
271
                    int motion_x, int motion_y)
272
{
273
    int cbpc, cbpy, i, pred_x, pred_y;
274
    int bits;
275
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
276
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
277
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
278
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
279
    
280
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
281
    if (!s->mb_intra) {
282
        /* compute cbp */
283
        int cbp = 0;
284
        for (i = 0; i < 6; i++) {
285
            if (s->block_last_index[i] >= 0)
286
                cbp |= 1 << (5 - i);
287
        }
288

    
289
        if(s->pict_type==B_TYPE){
290
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
291
            int mb_type=  mb_type_table[s->mv_dir];
292
            
293
            if(s->mb_x==0){
294
                s->last_mv[0][0][0]= 
295
                s->last_mv[0][0][1]= 
296
                s->last_mv[1][0][0]= 
297
                s->last_mv[1][0][1]= 0;
298
            }
299

    
300
            /* nothing to do if this MB was skiped in the next P Frame */
301
            if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){
302
                s->skip_count++;
303
                s->mv[0][0][0]= 
304
                s->mv[0][0][1]= 
305
                s->mv[1][0][0]= 
306
                s->mv[1][0][1]= 0;
307
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
308
                return;
309
            }
310

    
311
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
312
                /* direct MB with MV={0,0} */
313
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
314

    
315
                if(interleaved_stats){
316
                    s->misc_bits++;
317
                    s->last_bits++;
318
                }
319
                s->skip_count++;
320
                return;
321
            }
322
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
323
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
324
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
325
            if(cbp) put_bits(&s->pb, 6, cbp);
326
            
327
            if(cbp && mb_type)
328
                put_bits(&s->pb, 1, 0); /* no q-scale change */
329

    
330
            if(interleaved_stats){
331
                bits= get_bit_count(&s->pb);
332
                s->misc_bits+= bits - s->last_bits;
333
                s->last_bits=bits;
334
            }
335

    
336
            switch(mb_type)
337
            {
338
            case 0: /* direct */
339
                h263_encode_motion(s, motion_x, 1);
340
                h263_encode_motion(s, motion_y, 1);                
341
                break;
342
            case 1: /* bidir */
343
                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
344
                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
345
                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
346
                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
347
                s->last_mv[0][0][0]= s->mv[0][0][0];
348
                s->last_mv[0][0][1]= s->mv[0][0][1];
349
                s->last_mv[1][0][0]= s->mv[1][0][0];
350
                s->last_mv[1][0][1]= s->mv[1][0][1];
351
                break;
352
            case 2: /* backward */
353
                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
354
                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
355
                s->last_mv[1][0][0]= motion_x;
356
                s->last_mv[1][0][1]= motion_y;
357
                break;
358
            case 3: /* forward */
359
                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
360
                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
361
                s->last_mv[0][0][0]= motion_x;
362
                s->last_mv[0][0][1]= motion_y;
363
                break;
364
            default:
365
                printf("unknown mb type\n");
366
                return;
367
            }
368

    
369
            if(interleaved_stats){
370
                bits= get_bit_count(&s->pb);
371
                s->mv_bits+= bits - s->last_bits;
372
                s->last_bits=bits;
373
            }
374

    
375
            /* encode each block */
376
            for (i = 0; i < 6; i++) {
377
                mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, &s->pb);
378
            }
379

    
380
            if(interleaved_stats){
381
                bits= get_bit_count(&s->pb);
382
                s->p_tex_bits+= bits - s->last_bits;
383
                s->last_bits=bits;
384
            }
385
        }else{ /* s->pict_type==B_TYPE */
386
            if ((cbp | motion_x | motion_y) == 0 && s->mv_type==MV_TYPE_16X16) {
387
                /* check if the B frames can skip it too, as we must skip it if we skip here 
388
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
389
                if(s->max_b_frames>0){
390
                    int i;
391
                    int x,y, offset;
392
                    uint8_t *p_pic;
393

    
394
                    x= s->mb_x*16;
395
                    y= s->mb_y*16;
396
                    if(x+16 > s->width)  x= s->width-16;
397
                    if(y+16 > s->height) y= s->height-16;
398

    
399
                    offset= x + y*s->linesize;
400
                    p_pic= s->new_picture[0] + offset;
401
                    
402
                    s->mb_skiped=1;
403
                    for(i=0; i<s->max_b_frames; i++){
404
                        uint8_t *b_pic;
405
                        int diff;
406

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

    
409
                        b_pic= s->coded_order[i+1].picture[0] + offset;
410
                        diff= pix_abs16x16(p_pic, b_pic, s->linesize);
411
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
412
                            s->mb_skiped=0;
413
                            break;
414
                        }
415
                    }
416
                }else
417
                    s->mb_skiped=1; 
418

    
419
                if(s->mb_skiped==1){
420
                    /* skip macroblock */
421
                    put_bits(&s->pb, 1, 1);
422

    
423
                    if(interleaved_stats){
424
                        s->misc_bits++;
425
                        s->last_bits++;
426
                    }
427
                    s->skip_count++;
428
                    return;
429
                }
430
            }
431

    
432
            put_bits(&s->pb, 1, 0);        /* mb coded */
433
            if(s->mv_type==MV_TYPE_16X16){
434
                cbpc = cbp & 3;
435
                put_bits(&s->pb,
436
                        inter_MCBPC_bits[cbpc],
437
                        inter_MCBPC_code[cbpc]);
438
                cbpy = cbp >> 2;
439
                cbpy ^= 0xf;
440
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
441
                    
442
                if(interleaved_stats){
443
                    bits= get_bit_count(&s->pb);
444
                    s->misc_bits+= bits - s->last_bits;
445
                    s->last_bits=bits;
446
                }
447

    
448
                /* motion vectors: 16x16 mode */
449
                h263_pred_motion(s, 0, &pred_x, &pred_y);
450
            
451
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
452
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
453
            }else{
454
                cbpc = (cbp & 3)+16;
455
                put_bits(&s->pb,
456
                        inter_MCBPC_bits[cbpc],
457
                        inter_MCBPC_code[cbpc]);
458
                cbpy = cbp >> 2;
459
                cbpy ^= 0xf;
460
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
461

    
462
                if(interleaved_stats){
463
                    bits= get_bit_count(&s->pb);
464
                    s->misc_bits+= bits - s->last_bits;
465
                    s->last_bits=bits;
466
                }
467

    
468
                for(i=0; i<4; i++){
469
                    /* motion vectors: 8x8 mode*/
470
                    h263_pred_motion(s, i, &pred_x, &pred_y);
471

    
472
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
473
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
474
                }
475
            }
476

    
477
            if(interleaved_stats){ 
478
                bits= get_bit_count(&s->pb);
479
                s->mv_bits+= bits - s->last_bits;
480
                s->last_bits=bits;
481
            }
482

    
483
            /* encode each block */
484
            for (i = 0; i < 6; i++) {
485
                mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, tex_pb);
486
            }
487

    
488
            if(interleaved_stats){
489
                bits= get_bit_count(&s->pb);
490
                s->p_tex_bits+= bits - s->last_bits;
491
                s->last_bits=bits;
492
            }
493
            s->p_count++;
494
        }
495
    } else {
496
        int cbp;
497
        int dc_diff[6];   //dc values with the dc prediction subtracted 
498
        int dir[6];  //prediction direction
499
        int zigzag_last_index[6];
500
        UINT8 *scan_table[6];
501

    
502
        for(i=0; i<6; i++){
503
            const int level= block[i][0];
504
            UINT16 *dc_ptr;
505

    
506
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
507
            if (i < 4) {
508
                *dc_ptr = level * s->y_dc_scale;
509
            } else {
510
                *dc_ptr = level * s->c_dc_scale;
511
            }
512
        }
513

    
514
        s->ac_pred= decide_ac_pred(s, block, dir);
515

    
516
        if(s->ac_pred){
517
            for(i=0; i<6; i++){
518
                UINT8 *st;
519
                int last_index;
520

    
521
                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
522
                if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
523
                else           st = ff_alternate_horizontal_scan; /* top */
524

    
525
                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
526
                    if(block[i][st[last_index]]) break;
527
                zigzag_last_index[i]= s->block_last_index[i];
528
                s->block_last_index[i]= last_index;
529
                scan_table[i]= st;
530
            }
531
        }else{
532
            for(i=0; i<6; i++)
533
                scan_table[i]= zigzag_direct;
534
        }
535

    
536
        /* compute cbp */
537
        cbp = 0;
538
        for (i = 0; i < 6; i++) {
539
            if (s->block_last_index[i] >= 1)
540
                cbp |= 1 << (5 - i);
541
        }
542

    
543
        cbpc = cbp & 3;
544
        if (s->pict_type == I_TYPE) {
545
            put_bits(&s->pb,
546
                intra_MCBPC_bits[cbpc],
547
                intra_MCBPC_code[cbpc]);
548
        } else {
549
            put_bits(&s->pb, 1, 0);        /* mb coded */
550
            put_bits(&s->pb,
551
                inter_MCBPC_bits[cbpc + 4],
552
                inter_MCBPC_code[cbpc + 4]);
553
        }
554
        put_bits(pb2, 1, s->ac_pred);
555
        cbpy = cbp >> 2;
556
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
557

    
558
        if(interleaved_stats){
559
            bits= get_bit_count(&s->pb);
560
            s->misc_bits+= bits - s->last_bits;
561
            s->last_bits=bits;
562
        }
563

    
564
        /* encode each block */
565
        for (i = 0; i < 6; i++) {
566
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
567
        }
568

    
569
        if(interleaved_stats){
570
            bits= get_bit_count(&s->pb);
571
            s->i_tex_bits+= bits - s->last_bits;
572
            s->last_bits=bits;
573
        }
574
        s->i_count++;
575

    
576
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
577
        if(s->ac_pred){
578
            for(i=0; i<6; i++){
579
                int j;    
580
                INT16 *ac_val;
581

    
582
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
583

    
584
                if(dir[i]){
585
                    for(j=1; j<8; j++) 
586
                        block[i][block_permute_op(j   )]= ac_val[j+8];
587
                }else{
588
                    for(j=1; j<8; j++) 
589
                        block[i][block_permute_op(j<<3)]= ac_val[j  ];
590
                }
591
                s->block_last_index[i]= zigzag_last_index[i];
592
            }
593
        }
594
    }
595
}
596

    
597
void h263_encode_mb(MpegEncContext * s,
598
                    DCTELEM block[6][64],
599
                    int motion_x, int motion_y)
600
{
601
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
602
    INT16 pred_dc;
603
    INT16 rec_intradc[6];
604
    UINT16 *dc_ptr[6];
605
           
606
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
607
    if (!s->mb_intra) {
608
        /* compute cbp */
609
        cbp = 0;
610
        for (i = 0; i < 6; i++) {
611
            if (s->block_last_index[i] >= 0)
612
                cbp |= 1 << (5 - i);
613
        }
614
        if ((cbp | motion_x | motion_y) == 0) {
615
            /* skip macroblock */
616
            put_bits(&s->pb, 1, 1);
617
            return;
618
        }
619
        put_bits(&s->pb, 1, 0);        /* mb coded */
620
        cbpc = cbp & 3;
621
        put_bits(&s->pb,
622
                    inter_MCBPC_bits[cbpc],
623
                    inter_MCBPC_code[cbpc]);
624
        cbpy = cbp >> 2;
625
        cbpy ^= 0xf;
626
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
627

    
628
        /* motion vectors: 16x16 mode only now */
629
        h263_pred_motion(s, 0, &pred_x, &pred_y);
630
      
631
        if (!s->umvplus) {  
632
            h263_encode_motion(s, motion_x - pred_x, s->f_code);
633
            h263_encode_motion(s, motion_y - pred_y, s->f_code);
634
        }
635
        else {
636
            h263p_encode_umotion(s, motion_x - pred_x);
637
            h263p_encode_umotion(s, motion_y - pred_y);
638
            if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
639
                /* To prevent Start Code emulation */
640
                put_bits(&s->pb,1,1);
641
        }
642
    } else {
643
        int li = s->h263_aic ? 0 : 1;
644
        
645
        cbp = 0;
646
        for(i=0; i<6; i++) {
647
            /* Predict DC */
648
            if (s->h263_aic && s->mb_intra) {
649
                INT16 level = block[i][0];
650
            
651
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
652
                level -= pred_dc;
653
                /* Quant */
654
                if (level < 0)
655
                    level = (level + (s->qscale >> 1))/(s->y_dc_scale);
656
                else
657
                    level = (level - (s->qscale >> 1))/(s->y_dc_scale);
658
                    
659
                /* AIC can change CBP */
660
                if (level == 0 && s->block_last_index[i] == 0)
661
                    s->block_last_index[i] = -1;
662
                else if (level < -127)
663
                    level = -127;
664
                else if (level > 127)
665
                    level = 127;
666
                
667
                block[i][0] = level;
668
                /* Reconstruction */ 
669
                rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
670
                /* Oddify */
671
                rec_intradc[i] |= 1;
672
                //if ((rec_intradc[i] % 2) == 0)
673
                //    rec_intradc[i]++;
674
                /* Clipping */
675
                if (rec_intradc[i] < 0)
676
                    rec_intradc[i] = 0;
677
                else if (rec_intradc[i] > 2047)
678
                    rec_intradc[i] = 2047;
679
                                
680
                /* Update AC/DC tables */
681
                *dc_ptr[i] = rec_intradc[i];
682
            }
683
            /* compute cbp */
684
            if (s->block_last_index[i] >= li)
685
                cbp |= 1 << (5 - i);
686
        }
687

    
688
        cbpc = cbp & 3;
689
        if (s->pict_type == I_TYPE) {
690
            put_bits(&s->pb,
691
                intra_MCBPC_bits[cbpc],
692
                intra_MCBPC_code[cbpc]);
693
        } else {
694
            put_bits(&s->pb, 1, 0);        /* mb coded */
695
            put_bits(&s->pb,
696
                inter_MCBPC_bits[cbpc + 4],
697
                inter_MCBPC_code[cbpc + 4]);
698
        }
699
        if (s->h263_aic) {
700
            /* XXX: currently, we do not try to use ac prediction */
701
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
702
        }
703
        cbpy = cbp >> 2;
704
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
705
    }
706

    
707
    for(i=0; i<6; i++) {
708
        /* encode each block */
709
        h263_encode_block(s, block[i], i);
710
    
711
        /* Update INTRADC for decoding */
712
        if (s->h263_aic && s->mb_intra) {
713
            block[i][0] = rec_intradc[i];
714
            
715
        }
716
    }
717
}
718

    
719
static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
720
{
721
    int x, y, wrap, a, c, pred_dc, scale;
722
    INT16 *dc_val, *ac_val;
723

    
724
    /* find prediction */
725
    if (n < 4) {
726
        x = 2 * s->mb_x + 1 + (n & 1);
727
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
728
        wrap = s->mb_width * 2 + 2;
729
        dc_val = s->dc_val[0];
730
        ac_val = s->ac_val[0][0];
731
        scale = s->y_dc_scale;
732
    } else {
733
        x = s->mb_x + 1;
734
        y = s->mb_y + 1;
735
        wrap = s->mb_width + 2;
736
        dc_val = s->dc_val[n - 4 + 1];
737
        ac_val = s->ac_val[n - 4 + 1][0];
738
        scale = s->c_dc_scale;
739
    }
740
    /* B C
741
     * A X 
742
     */
743
    a = dc_val[(x - 1) + (y) * wrap];
744
    c = dc_val[(x) + (y - 1) * wrap];
745
    
746
    /* No prediction outside GOB boundary */
747
    if (s->first_slice_line && ((n < 2) || (n > 3)))
748
        c = 1024;
749
    pred_dc = 1024;
750
    /* just DC prediction */
751
    if (a != 1024 && c != 1024)
752
        pred_dc = (a + c) >> 1;
753
    else if (a != 1024)
754
        pred_dc = a;
755
    else
756
        pred_dc = c;
757
    
758
    /* we assume pred is positive */
759
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
760
    *dc_val_ptr = &dc_val[x + y * wrap];
761
    return pred_dc;
762
}
763

    
764

    
765
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
766
{
767
    int x, y, wrap, a, c, pred_dc, scale, i;
768
    INT16 *dc_val, *ac_val, *ac_val1;
769

    
770
    /* find prediction */
771
    if (n < 4) {
772
        x = 2 * s->mb_x + 1 + (n & 1);
773
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
774
        wrap = s->mb_width * 2 + 2;
775
        dc_val = s->dc_val[0];
776
        ac_val = s->ac_val[0][0];
777
        scale = s->y_dc_scale;
778
    } else {
779
        x = s->mb_x + 1;
780
        y = s->mb_y + 1;
781
        wrap = s->mb_width + 2;
782
        dc_val = s->dc_val[n - 4 + 1];
783
        ac_val = s->ac_val[n - 4 + 1][0];
784
        scale = s->c_dc_scale;
785
    }
786
    
787
    ac_val += ((y) * wrap + (x)) * 16;
788
    ac_val1 = ac_val;
789
    
790
    /* B C
791
     * A X 
792
     */
793
    a = dc_val[(x - 1) + (y) * wrap];
794
    c = dc_val[(x) + (y - 1) * wrap];
795
    
796
    /* No prediction outside GOB boundary */
797
    if (s->first_slice_line && ((n < 2) || (n > 3)))
798
        c = 1024;
799
    pred_dc = 1024;
800
    if (s->ac_pred) {
801
        if (s->h263_aic_dir) {
802
            /* left prediction */
803
            if (a != 1024) {
804
                ac_val -= 16;
805
                for(i=1;i<8;i++) {
806
                    block[block_permute_op(i*8)] += ac_val[i];
807
                }
808
                pred_dc = a;
809
            }
810
        } else {
811
            /* top prediction */
812
            if (c != 1024) {
813
                ac_val -= 16 * wrap;
814
                for(i=1;i<8;i++) {
815
                    block[block_permute_op(i)] += ac_val[i + 8];
816
                }
817
                pred_dc = c;
818
            }
819
        }
820
    } else {
821
        /* just DC prediction */
822
        if (a != 1024 && c != 1024)
823
            pred_dc = (a + c) >> 1;
824
        else if (a != 1024)
825
            pred_dc = a;
826
        else
827
            pred_dc = c;
828
    }
829
    
830
    /* we assume pred is positive */
831
    block[0]=block[0]*scale + pred_dc;
832
    
833
    if (block[0] < 0)
834
        block[0] = 0;
835
    else if (!(block[0] & 1))
836
        block[0]++;
837
    
838
    /* Update AC/DC tables */
839
    dc_val[(x) + (y) * wrap] = block[0];
840
    
841
    /* left copy */
842
    for(i=1;i<8;i++)
843
        ac_val1[i] = block[block_permute_op(i * 8)];
844
    /* top copy */
845
    for(i=1;i<8;i++)
846
        ac_val1[8 + i] = block[block_permute_op(i)];
847
}
848

    
849
INT16 *h263_pred_motion(MpegEncContext * s, int block, 
850
                        int *px, int *py)
851
{
852
    int xy, wrap;
853
    INT16 *A, *B, *C, *mot_val;
854
    static const int off[4]= {2, 1, 1, -1};
855

    
856
    wrap = s->block_wrap[0];
857
    xy = s->block_index[block];
858

    
859
    mot_val = s->motion_val[xy];
860

    
861
    A = s->motion_val[xy - 1];
862
    /* special case for first (slice) line */
863
    if ((s->mb_y == 0 || s->first_slice_line) && block<3) {
864
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
865
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
866
        if(block==0){ //most common case
867
            if(s->mb_x  == s->resync_mb_x){ //rare
868
                *px= *py = 0;
869
            }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
870
                C = s->motion_val[xy + off[block] - wrap];
871
                if(s->mb_x==0){
872
                    *px = C[0];
873
                    *py = C[1];
874
                }else{
875
                    *px = mid_pred(A[0], 0, C[0]);
876
                    *py = mid_pred(A[1], 0, C[1]);
877
                }
878
            }else{
879
                *px = A[0];
880
                *py = A[1];
881
            }
882
        }else if(block==1){
883
            if(s->mb_x + 1 == s->resync_mb_x){ //rare
884
                C = s->motion_val[xy + off[block] - wrap];
885
                *px = mid_pred(A[0], 0, C[0]);
886
                *py = mid_pred(A[1], 0, C[1]);
887
            }else{
888
                *px = A[0];
889
                *py = A[1];
890
            }
891
        }else{ /* block==2*/
892
            B = s->motion_val[xy - wrap];
893
            C = s->motion_val[xy + off[block] - wrap];
894
            if(s->mb_x == s->resync_mb_x) //rare
895
                A[0]=A[1]=0;
896
    
897
            *px = mid_pred(A[0], B[0], C[0]);
898
            *py = mid_pred(A[1], B[1], C[1]);
899
        }
900
    } else {
901
        B = s->motion_val[xy - wrap];
902
        C = s->motion_val[xy + off[block] - wrap];
903
        *px = mid_pred(A[0], B[0], C[0]);
904
        *py = mid_pred(A[1], B[1], C[1]);
905
    }
906
    return mot_val;
907
}
908

    
909
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
910
{
911
    int range, l, m, bit_size, sign, code, bits;
912

    
913
    if (val == 0) {
914
        /* zero vector */
915
        code = 0;
916
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
917
    } else {
918
        bit_size = f_code - 1;
919
        range = 1 << bit_size;
920
        /* modulo encoding */
921
        l = range * 32;
922
        m = 2 * l;
923
        if (val < -l) {
924
            val += m;
925
        } else if (val >= l) {
926
            val -= m;
927
        }
928

    
929
        if (val >= 0) {
930
            sign = 0;
931
        } else {
932
            val = -val;
933
            sign = 1;
934
        }
935
        val--;
936
        code = (val >> bit_size) + 1;
937
        bits = val & (range - 1);
938

    
939
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
940
        if (bit_size > 0) {
941
            put_bits(&s->pb, bit_size, bits);
942
        }
943
    }
944
}
945

    
946
/* Encode MV differences on H.263+ with Unrestricted MV mode */
947
static void h263p_encode_umotion(MpegEncContext * s, int val)
948
{
949
    short sval = 0; 
950
    short i = 0;
951
    short n_bits = 0;
952
    short temp_val;
953
    int code = 0;
954
    int tcode;
955
    
956
    if ( val == 0)
957
        put_bits(&s->pb, 1, 1);
958
    else if (val == 1)
959
        put_bits(&s->pb, 3, 0);
960
    else if (val == -1)
961
        put_bits(&s->pb, 3, 2);
962
    else {
963
        
964
        sval = ((val < 0) ? (short)(-val):(short)val);
965
        temp_val = sval;
966
        
967
        while (temp_val != 0) {
968
            temp_val = temp_val >> 1;
969
            n_bits++;
970
        }
971
        
972
        i = n_bits - 1;
973
        while (i > 0) {
974
            tcode = (sval & (1 << (i-1))) >> (i-1);
975
            tcode = (tcode << 1) | 1;
976
            code = (code << 2) | tcode;
977
            i--;
978
        }
979
        code = ((code << 1) | (val < 0)) << 1;
980
        put_bits(&s->pb, (2*n_bits)+1, code);
981
        //printf("\nVal = %d\tCode = %d", sval, code);
982
    }
983
}
984

    
985
static void init_mv_penalty_and_fcode(MpegEncContext *s)
986
{
987
    int f_code;
988
    int mv;
989
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
990
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
991
            int len;
992

    
993
            if(mv==0) len= mvtab[0][1];
994
            else{
995
                int val, bit_size, range, code;
996

    
997
                bit_size = s->f_code - 1;
998
                range = 1 << bit_size;
999

    
1000
                val=mv;
1001
                if (val < 0) 
1002
                    val = -val;
1003
                val--;
1004
                code = (val >> bit_size) + 1;
1005
                if(code<33){
1006
                    len= mvtab[code][1] + 1 + bit_size;
1007
                }else{
1008
                    len= mvtab[32][1] + 2 + bit_size;
1009
                }
1010
            }
1011

    
1012
            mv_penalty[f_code][mv+MAX_MV]= len;
1013
        }
1014
    }
1015

    
1016
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1017
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1018
            fcode_tab[mv+MAX_MV]= f_code;
1019
        }
1020
    }
1021

    
1022
    for(mv=0; mv<MAX_MV*2+1; mv++){
1023
        umv_fcode_tab[mv]= 1;
1024
    }
1025
}
1026

    
1027
static void init_uni_dc_tab(void)
1028
{
1029
    int level, uni_code, uni_len;
1030

    
1031
    for(level=-256; level<256; level++){
1032
        int size, v, l;
1033
        /* find number of bits */
1034
        size = 0;
1035
        v = abs(level);
1036
        while (v) {
1037
            v >>= 1;
1038
            size++;
1039
        }
1040

    
1041
        if (level < 0)
1042
            l= (-level) ^ ((1 << size) - 1);
1043
        else
1044
            l= level;
1045

    
1046
        /* luminance */
1047
        uni_code= DCtab_lum[size][0];
1048
        uni_len = DCtab_lum[size][1];
1049

    
1050
        if (size > 0) {
1051
            uni_code<<=size; uni_code|=l;
1052
            uni_len+=size;
1053
            if (size > 8){
1054
                uni_code<<=1; uni_code|=1;
1055
                uni_len++;
1056
            }
1057
        }
1058
        uni_DCtab_lum[level+256][0]= uni_code;
1059
        uni_DCtab_lum[level+256][1]= uni_len;
1060

    
1061
        /* chrominance */
1062
        uni_code= DCtab_chrom[size][0];
1063
        uni_len = DCtab_chrom[size][1];
1064
        
1065
        if (size > 0) {
1066
            uni_code<<=size; uni_code|=l;
1067
            uni_len+=size;
1068
            if (size > 8){
1069
                uni_code<<=1; uni_code|=1;
1070
                uni_len++;
1071
            }
1072
        }
1073
        uni_DCtab_chrom[level+256][0]= uni_code;
1074
        uni_DCtab_chrom[level+256][1]= uni_len;
1075

    
1076
    }
1077
}
1078

    
1079
void h263_encode_init(MpegEncContext *s)
1080
{
1081
    static int done = 0;
1082

    
1083
    if (!done) {
1084
        done = 1;
1085

    
1086
        init_uni_dc_tab();
1087

    
1088
        init_rl(&rl_inter);
1089
        init_rl(&rl_intra);
1090
        init_rl(&rl_intra_aic);
1091

    
1092
        init_mv_penalty_and_fcode(s);
1093
    }
1094
    s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1095
    
1096
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1097
    switch(s->codec_id){
1098
    case CODEC_ID_MPEG4:
1099
        s->fcode_tab= fcode_tab;
1100
        s->min_qcoeff= -2048;
1101
        s->max_qcoeff=  2047;
1102
        break;
1103
    case CODEC_ID_H263P:
1104
        s->fcode_tab= umv_fcode_tab;
1105
        s->min_qcoeff= -128;
1106
        s->max_qcoeff=  127;
1107
        break;
1108
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1109
    default: //nothing needed default table allready set in mpegvideo.c
1110
        s->min_qcoeff= -128;
1111
        s->max_qcoeff=  127;
1112
        s->y_dc_scale_table=
1113
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1114
    }
1115

    
1116
    /* h263 type bias */
1117
    //FIXME mpeg4 mpeg quantizer    
1118
    s->intra_quant_bias=0;
1119
    s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1120
}
1121

    
1122
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1123
{
1124
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1125
    RLTable *rl;
1126

    
1127
    rl = &rl_inter;
1128
    if (s->mb_intra && !s->h263_aic) {
1129
        /* DC coef */
1130
            level = block[0];
1131
        /* 255 cannot be represented, so we clamp */
1132
        if (level > 254) {
1133
            level = 254;
1134
            block[0] = 254;
1135
        }
1136
        /* 0 cannot be represented also */
1137
        else if (!level) {
1138
            level = 1;
1139
            block[0] = 1;
1140
        }
1141
            if (level == 128)
1142
                put_bits(&s->pb, 8, 0xff);
1143
            else
1144
                put_bits(&s->pb, 8, level & 0xff);
1145
            i = 1;
1146
    } else {
1147
            i = 0;
1148
            if (s->h263_aic && s->mb_intra)
1149
                rl = &rl_intra_aic;
1150
    }
1151
   
1152
    /* AC coefs */
1153
    last_index = s->block_last_index[n];
1154
    last_non_zero = i - 1;
1155
    for (; i <= last_index; i++) {
1156
        j = zigzag_direct[i];
1157
        level = block[j];
1158
        if (level) {
1159
            run = i - last_non_zero - 1;
1160
            last = (i == last_index);
1161
            sign = 0;
1162
            slevel = level;
1163
            if (level < 0) {
1164
                sign = 1;
1165
                level = -level;
1166
            }
1167
            code = get_rl_index(rl, last, run, level);
1168
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1169
            if (code == rl->n) {
1170
                put_bits(&s->pb, 1, last);
1171
                put_bits(&s->pb, 6, run);
1172
                put_bits(&s->pb, 8, slevel & 0xff);
1173
            } else {
1174
                put_bits(&s->pb, 1, sign);
1175
            }
1176
                last_non_zero = i;
1177
            }
1178
    }
1179
}
1180

    
1181
/***************************************************/
1182

    
1183
void ff_mpeg4_stuffing(PutBitContext * pbc)
1184
{
1185
    int length;
1186
    put_bits(pbc, 1, 0);
1187
    length= (-get_bit_count(pbc))&7;
1188
    if(length) put_bits(pbc, length, (1<<length)-1);
1189
}
1190

    
1191
/* must be called before writing the header */
1192
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1193
    int time_div, time_mod;
1194

    
1195
    if(s->pict_type==I_TYPE){ //we will encode a vol header
1196
        s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1197
        if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1198

    
1199
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1200
    }
1201

    
1202
    s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1203
    time_div= s->time/s->time_increment_resolution;
1204
    time_mod= s->time%s->time_increment_resolution;
1205

    
1206
    if(s->pict_type==B_TYPE){
1207
        s->bp_time= s->last_non_b_time - s->time;
1208
    }else{
1209
        s->last_time_base= s->time_base;
1210
        s->time_base= time_div;
1211
        s->pp_time= s->time - s->last_non_b_time;
1212
        s->last_non_b_time= s->time;
1213
    }
1214
}
1215

    
1216
static void mpeg4_encode_vol_header(MpegEncContext * s)
1217
{
1218
    int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1219
    char buf[255];
1220

    
1221
    s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
1222

    
1223
    put_bits(&s->pb, 16, 0);
1224
    put_bits(&s->pb, 16, 0x100);        /* video obj */
1225
    put_bits(&s->pb, 16, 0);
1226
    put_bits(&s->pb, 16, 0x120);        /* video obj layer */
1227

    
1228
    put_bits(&s->pb, 1, 0);                /* random access vol */
1229
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1230
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1231
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1232
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1233
    if(s->aspect_ratio_info) 
1234
        put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1235
    else
1236
        put_bits(&s->pb, 4, 1);                /* aspect ratio info= sqare pixel */
1237

    
1238
    if(s->low_delay){
1239
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1240
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1241
        put_bits(&s->pb, 1, s->low_delay);
1242
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1243
    }else{
1244
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1245
    }
1246

    
1247
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1248
    put_bits(&s->pb, 1, 1);                /* marker bit */
1249
    
1250
    put_bits(&s->pb, 16, s->time_increment_resolution);
1251
    if (s->time_increment_bits < 1)
1252
        s->time_increment_bits = 1;
1253
    put_bits(&s->pb, 1, 1);                /* marker bit */
1254
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1255
    put_bits(&s->pb, 1, 1);                /* marker bit */
1256
    put_bits(&s->pb, 13, s->width);        /* vol width */
1257
    put_bits(&s->pb, 1, 1);                /* marker bit */
1258
    put_bits(&s->pb, 13, s->height);        /* vol height */
1259
    put_bits(&s->pb, 1, 1);                /* marker bit */
1260
    put_bits(&s->pb, 1, 0);                /* interlace */
1261
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1262
    if (vo_ver_id == 1) {
1263
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1264
    }else{ /* vo_ver_id == 2 */
1265
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1266
    }
1267
    put_bits(&s->pb, 1, 0);                /* not 8 bit */
1268
    put_bits(&s->pb, 1, 0);                /* quant type= h263 style*/
1269
    if (vo_ver_id != 1)
1270
        put_bits(&s->pb, 1, s->quarter_sample=0);
1271
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1272
    s->resync_marker= s->rtp_mode;
1273
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1274
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1275
    if(s->data_partitioning){
1276
        put_bits(&s->pb, 1, 0);                /* no rvlc */
1277
    }
1278

    
1279
    if (vo_ver_id != 1){
1280
        put_bits(&s->pb, 1, 0);                /* newpred */
1281
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1282
    }
1283
    put_bits(&s->pb, 1, 0);                /* scalability */
1284

    
1285
    ff_mpeg4_stuffing(&s->pb);
1286
    put_bits(&s->pb, 16, 0);
1287
    put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1288
    sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1289
    put_string(&s->pb, buf);
1290

    
1291
    ff_mpeg4_stuffing(&s->pb);
1292
}
1293

    
1294
/* write mpeg4 VOP header */
1295
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1296
{
1297
    int time_incr;
1298
    int time_div, time_mod;
1299
    
1300
    if(s->pict_type==I_TYPE){
1301
        s->no_rounding=0;
1302
        if(picture_number==0 || !s->strict_std_compliance)
1303
            mpeg4_encode_vol_header(s);
1304
    }
1305
    
1306
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1307
    
1308
    put_bits(&s->pb, 16, 0);                /* vop header */
1309
    put_bits(&s->pb, 16, 0x1B6);        /* vop header */
1310
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1311

    
1312
    time_div= s->time/s->time_increment_resolution;
1313
    time_mod= s->time%s->time_increment_resolution;
1314
    time_incr= time_div - s->last_time_base;
1315
    while(time_incr--)
1316
        put_bits(&s->pb, 1, 1);
1317
        
1318
    put_bits(&s->pb, 1, 0);
1319

    
1320
    put_bits(&s->pb, 1, 1);        /* marker */
1321
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1322
    put_bits(&s->pb, 1, 1);        /* marker */
1323
    put_bits(&s->pb, 1, 1);        /* vop coded */
1324
    if (    s->pict_type == P_TYPE 
1325
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1326
        s->no_rounding ^= 1;
1327
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1328
    }
1329
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1330
    //FIXME sprite stuff
1331

    
1332
    put_bits(&s->pb, 5, s->qscale);
1333

    
1334
    if (s->pict_type != I_TYPE)
1335
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1336
    if (s->pict_type == B_TYPE)
1337
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1338
    //    printf("****frame %d\n", picture_number);
1339

    
1340
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
1341
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1342
}
1343

    
1344
static void h263_dc_scale(MpegEncContext * s)
1345
{
1346
    s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1347
    s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1348
}
1349

    
1350
inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1351
{
1352
    int a, b, c, wrap, pred, scale;
1353
    UINT16 *dc_val;
1354
    int dummy;
1355

    
1356
    /* find prediction */
1357
    if (n < 4) {
1358
        scale = s->y_dc_scale;
1359
    } else {
1360
        scale = s->c_dc_scale;
1361
    }
1362
    wrap= s->block_wrap[n];
1363
    dc_val = s->dc_val[0] + s->block_index[n];
1364

    
1365
    /* B C
1366
     * A X 
1367
     */
1368
    a = dc_val[ - 1];
1369
    b = dc_val[ - 1 - wrap];
1370
    c = dc_val[ - wrap];
1371

    
1372
    if (abs(a - b) < abs(b - c)) {
1373
        pred = c;
1374
        *dir_ptr = 1; /* top */
1375
    } else {
1376
        pred = a;
1377
        *dir_ptr = 0; /* left */
1378
    }
1379
    /* we assume pred is positive */
1380
#ifdef ARCH_X86
1381
        asm volatile (
1382
                "xorl %%edx, %%edx        \n\t"
1383
                "mul %%ecx                \n\t"
1384
                : "=d" (pred), "=a"(dummy)
1385
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1386
        );
1387
#else
1388
    pred = (pred + (scale >> 1)) / scale;
1389
#endif
1390

    
1391
    /* prepare address for prediction update */
1392
    *dc_val_ptr = &dc_val[0];
1393

    
1394
    return pred;
1395
}
1396

    
1397
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1398
                   int dir)
1399
{
1400
    int i;
1401
    INT16 *ac_val, *ac_val1;
1402

    
1403
    /* find prediction */
1404
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1405
    ac_val1 = ac_val;
1406
    if (s->ac_pred) {
1407
        if (dir == 0) {
1408
            /* left prediction */
1409
            ac_val -= 16;
1410
            for(i=1;i<8;i++) {
1411
                block[block_permute_op(i*8)] += ac_val[i];
1412
            }
1413
        } else {
1414
            /* top prediction */
1415
            ac_val -= 16 * s->block_wrap[n];
1416
            for(i=1;i<8;i++) {
1417
                block[block_permute_op(i)] += ac_val[i + 8];
1418
            }
1419
        }
1420
    }
1421
    /* left copy */
1422
    for(i=1;i<8;i++)
1423
        ac_val1[i] = block[block_permute_op(i * 8)];
1424
    /* top copy */
1425
    for(i=1;i<8;i++)
1426
        ac_val1[8 + i] = block[block_permute_op(i)];
1427
}
1428

    
1429
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1430
                              int dir)
1431
{
1432
    int i;
1433
    INT16 *ac_val;
1434

    
1435
    /* find prediction */
1436
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1437
 
1438
    if (dir == 0) {
1439
        /* left prediction */
1440
        ac_val -= 16;
1441
        for(i=1;i<8;i++) {
1442
            block[block_permute_op(i*8)] -= ac_val[i];
1443
        }
1444
    } else {
1445
        /* top prediction */
1446
        ac_val -= 16 * s->block_wrap[n];
1447
        for(i=1;i<8;i++) {
1448
            block[block_permute_op(i)] -= ac_val[i + 8];
1449
        }
1450
    }
1451
}
1452

    
1453
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1454
{
1455
#if 1
1456
//    if(level<-255 || level>255) printf("dc overflow\n");
1457
    level+=256;
1458
    if (n < 4) {
1459
        /* luminance */
1460
        put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1461
    } else {
1462
        /* chrominance */
1463
        put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1464
    }
1465
#else
1466
    int size, v;
1467
    /* find number of bits */
1468
    size = 0;
1469
    v = abs(level);
1470
    while (v) {
1471
        v >>= 1;
1472
        size++;
1473
    }
1474

    
1475
    if (n < 4) {
1476
        /* luminance */
1477
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1478
    } else {
1479
        /* chrominance */
1480
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1481
    }
1482

    
1483
    /* encode remaining bits */
1484
    if (size > 0) {
1485
        if (level < 0)
1486
            level = (-level) ^ ((1 << size) - 1);
1487
        put_bits(&s->pb, size, level);
1488
        if (size > 8)
1489
            put_bits(&s->pb, 1, 1);
1490
    }
1491
#endif
1492
}
1493

    
1494
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
1495
                               UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
1496
{
1497
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
1498
    int code;
1499
    const RLTable *rl;
1500

    
1501
    if (s->mb_intra) {
1502
        /* mpeg4 based DC predictor */
1503
        mpeg4_encode_dc(dc_pb, intra_dc, n);
1504
        i = 1;
1505
        rl = &rl_intra;
1506
    } else {
1507
        i = 0;
1508
        rl = &rl_inter;
1509
    }
1510

    
1511
    /* AC coefs */
1512
    last_index = s->block_last_index[n];
1513
    last_non_zero = i - 1;
1514
    for (; i <= last_index; i++) {
1515
        j = scan_table[i];
1516
        level = block[j];
1517
        if (level) {
1518
            run = i - last_non_zero - 1;
1519
            last = (i == last_index);
1520
            sign = 0;
1521
            slevel = level;
1522
            if (level < 0) {
1523
                sign = 1;
1524
                level = -level;
1525
            }
1526
            code = get_rl_index(rl, last, run, level);
1527
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1528
            if (code == rl->n) {
1529
                int level1, run1;
1530
                level1 = level - rl->max_level[last][run];
1531
                if (level1 < 1) 
1532
                    goto esc2;
1533
                code = get_rl_index(rl, last, run, level1);
1534
                if (code == rl->n) {
1535
                esc2:
1536
                    put_bits(ac_pb, 1, 1);
1537
                    if (level > MAX_LEVEL)
1538
                        goto esc3;
1539
                    run1 = run - rl->max_run[last][level] - 1;
1540
                    if (run1 < 0)
1541
                        goto esc3;
1542
                    code = get_rl_index(rl, last, run1, level);
1543
                    if (code == rl->n) {
1544
                    esc3:
1545
                        /* third escape */
1546
                        put_bits(ac_pb, 1, 1);
1547
                        put_bits(ac_pb, 1, last);
1548
                        put_bits(ac_pb, 6, run);
1549
                        put_bits(ac_pb, 1, 1);
1550
                        put_bits(ac_pb, 12, slevel & 0xfff);
1551
                        put_bits(ac_pb, 1, 1);
1552
                    } else {
1553
                        /* second escape */
1554
                        put_bits(ac_pb, 1, 0);
1555
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1556
                        put_bits(ac_pb, 1, sign);
1557
                    }
1558
                } else {
1559
                    /* first escape */
1560
                    put_bits(ac_pb, 1, 0);
1561
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1562
                    put_bits(ac_pb, 1, sign);
1563
                }
1564
            } else {
1565
                put_bits(ac_pb, 1, sign);
1566
            }
1567
            last_non_zero = i;
1568
        }
1569
    }
1570
}
1571

    
1572

    
1573

    
1574
/***********************************************/
1575
/* decoding */
1576

    
1577
static VLC intra_MCBPC_vlc;
1578
static VLC inter_MCBPC_vlc;
1579
static VLC cbpy_vlc;
1580
static VLC mv_vlc;
1581
static VLC dc_lum, dc_chrom;
1582
static VLC sprite_trajectory;
1583
static VLC mb_type_b_vlc;
1584

    
1585
void init_rl(RLTable *rl)
1586
{
1587
    INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1588
    UINT8 index_run[MAX_RUN+1];
1589
    int last, run, level, start, end, i;
1590

    
1591
    /* compute max_level[], max_run[] and index_run[] */
1592
    for(last=0;last<2;last++) {
1593
        if (last == 0) {
1594
            start = 0;
1595
            end = rl->last;
1596
        } else {
1597
            start = rl->last;
1598
            end = rl->n;
1599
        }
1600

    
1601
        memset(max_level, 0, MAX_RUN + 1);
1602
        memset(max_run, 0, MAX_LEVEL + 1);
1603
        memset(index_run, rl->n, MAX_RUN + 1);
1604
        for(i=start;i<end;i++) {
1605
            run = rl->table_run[i];
1606
            level = rl->table_level[i];
1607
            if (index_run[run] == rl->n)
1608
                index_run[run] = i;
1609
            if (level > max_level[run])
1610
                max_level[run] = level;
1611
            if (run > max_run[level])
1612
                max_run[level] = run;
1613
        }
1614
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
1615
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1616
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1617
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1618
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
1619
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1620
    }
1621
}
1622

    
1623
void init_vlc_rl(RLTable *rl)
1624
{
1625
    init_vlc(&rl->vlc, 9, rl->n + 1, 
1626
             &rl->table_vlc[0][1], 4, 2,
1627
             &rl->table_vlc[0][0], 4, 2);
1628
}
1629

    
1630
/* init vlcs */
1631

    
1632
/* XXX: find a better solution to handle static init */
1633
void h263_decode_init_vlc(MpegEncContext *s)
1634
{
1635
    static int done = 0;
1636

    
1637
    if (!done) {
1638
        done = 1;
1639

    
1640
        init_vlc(&intra_MCBPC_vlc, 6, 8, 
1641
                 intra_MCBPC_bits, 1, 1,
1642
                 intra_MCBPC_code, 1, 1);
1643
        init_vlc(&inter_MCBPC_vlc, 9, 25, 
1644
                 inter_MCBPC_bits, 1, 1,
1645
                 inter_MCBPC_code, 1, 1);
1646
        init_vlc(&cbpy_vlc, 6, 16,
1647
                 &cbpy_tab[0][1], 2, 1,
1648
                 &cbpy_tab[0][0], 2, 1);
1649
        init_vlc(&mv_vlc, 9, 33,
1650
                 &mvtab[0][1], 2, 1,
1651
                 &mvtab[0][0], 2, 1);
1652
        init_rl(&rl_inter);
1653
        init_rl(&rl_intra);
1654
        init_rl(&rl_intra_aic);
1655
        init_vlc_rl(&rl_inter);
1656
        init_vlc_rl(&rl_intra);
1657
        init_vlc_rl(&rl_intra_aic);
1658
        init_vlc(&dc_lum, 9, 13,
1659
                 &DCtab_lum[0][1], 2, 1,
1660
                 &DCtab_lum[0][0], 2, 1);
1661
        init_vlc(&dc_chrom, 9, 13,
1662
                 &DCtab_chrom[0][1], 2, 1,
1663
                 &DCtab_chrom[0][0], 2, 1);
1664
        init_vlc(&sprite_trajectory, 9, 15,
1665
                 &sprite_trajectory_tab[0][1], 4, 2,
1666
                 &sprite_trajectory_tab[0][0], 4, 2);
1667
        init_vlc(&mb_type_b_vlc, 4, 4,
1668
                 &mb_type_b_tab[0][1], 2, 1,
1669
                 &mb_type_b_tab[0][0], 2, 1);
1670
    }
1671
}
1672

    
1673
int h263_decode_gob_header(MpegEncContext *s)
1674
{
1675
    unsigned int val, gfid;
1676
    
1677
    /* Check for GOB Start Code */
1678
    val = show_bits(&s->gb, 16);
1679
    if (val == 0) {
1680
        /* We have a GBSC probably with GSTUFF */
1681
        skip_bits(&s->gb, 16); /* Drop the zeros */
1682
        while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1683
#ifdef DEBUG
1684
        fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1685
#endif
1686
        s->gob_number = get_bits(&s->gb, 5); /* GN */
1687
        gfid = get_bits(&s->gb, 2); /* GFID */
1688
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1689
#ifdef DEBUG
1690
        fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1691
#endif
1692
        return 1;
1693
    }
1694
    return 0;
1695
            
1696
}
1697

    
1698
static inline void memsetw(short *tab, int val, int n)
1699
{
1700
    int i;
1701
    for(i=0;i<n;i++)
1702
        tab[i] = val;
1703
}
1704

    
1705
void ff_mpeg4_init_partitions(MpegEncContext *s)
1706
{
1707
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
1708
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
1709
}
1710

    
1711
void ff_mpeg4_merge_partitions(MpegEncContext *s)
1712
{
1713
    const int pb2_len   = get_bit_count(&s->pb2   );
1714
    const int tex_pb_len= get_bit_count(&s->tex_pb);
1715
    const int bits= get_bit_count(&s->pb);
1716

    
1717
    if(s->pict_type==I_TYPE){
1718
        put_bits(&s->pb, 19, DC_MARKER);
1719
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
1720
        s->i_tex_bits+= tex_pb_len;
1721
    }else{
1722
        put_bits(&s->pb, 17, MOTION_MARKER);
1723
        s->misc_bits+=17 + pb2_len;;
1724
        s->mv_bits+= bits - s->last_bits;
1725
        s->p_tex_bits+= tex_pb_len;
1726
    }
1727

    
1728
    flush_put_bits(&s->pb2);
1729
    flush_put_bits(&s->tex_pb);
1730

    
1731
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
1732
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
1733
    s->last_bits= get_bit_count(&s->pb);
1734
}
1735

    
1736
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
1737
{
1738
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1739

    
1740
    ff_mpeg4_stuffing(&s->pb);
1741
    if(s->pict_type==I_TYPE)
1742
        put_bits(&s->pb, 16, 0);
1743
    else if(s->pict_type==B_TYPE)
1744
        put_bits(&s->pb, MAX(MAX(s->f_code, s->b_code)+15, 17), 0);
1745
    else /* S/P_TYPE */
1746
        put_bits(&s->pb, s->f_code+15, 0);
1747
    put_bits(&s->pb, 1, 1);
1748
    
1749
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
1750
    put_bits(&s->pb, 5, s->qscale);
1751
    put_bits(&s->pb, 1, 0); /* no HEC */
1752
}
1753

    
1754
/**
1755
 * decodes the next video packet and sets s->next_qscale 
1756
 * returns mb_num of the next packet or <0 if something went wrong
1757
 */
1758
static int decode_video_packet_header(MpegEncContext *s, GetBitContext *gb)
1759
{
1760
    int bits;
1761
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1762
    int header_extension=0, mb_num;
1763
//printf("%X\n", show_bits(&gb, 24));
1764
//printf("parse_video_packet_header\n");
1765
//    if(show_aligned_bits(gb, 1, 16) != 0) return -1;
1766
    
1767
    /* is there enough space left for a video packet + header */
1768
    if( get_bits_count(gb) > gb->size*8-20) return -1;
1769

    
1770
//printf("resync at %d %d\n", s->mb_x, s->mb_y);
1771
//    skip_bits(gb, 1);
1772
//    align_get_bits(gb);
1773
    if(get_bits(gb, 16)!=0){
1774
        printf("internal error while decoding video packet header\n");
1775
    }
1776

    
1777
//printf("%X\n", show_bits(gb, 24));
1778
    bits=0;
1779
    while(!get_bits1(gb) && bits<30) bits++;
1780
    if((s->pict_type == P_TYPE || s->pict_type == S_TYPE) && bits != s->f_code-1){
1781
        printf("marker does not match f_code (is: %d should be: %d pos: %d end %d x: %d y: %d)\n", 
1782
               bits+1, s->f_code, get_bits_count(gb), gb->size*8, s->mb_x, s->mb_y);
1783
        return -1;
1784
    }else if(s->pict_type == I_TYPE && bits != 0){
1785
        printf("marker too long\n");
1786
        return -1;
1787
    }else if(s->pict_type == B_TYPE && bits != MAX(MAX(s->f_code, s->b_code)-1, 1)){
1788
        printf("marker does not match f/b_code\n");
1789
        return -1;
1790
    }
1791
//printf("%X\n", show_bits(gb, 24));
1792

    
1793
    if(s->shape != RECT_SHAPE){
1794
        header_extension= get_bits1(gb);
1795
        //FIXME more stuff here
1796
    }
1797

    
1798
    mb_num= get_bits(gb, mb_num_bits);
1799
    if(mb_num < s->mb_x + s->mb_y*s->mb_width || mb_num>=s->mb_num){
1800
        fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_x + s->mb_y*s->mb_width);
1801
        return -1;
1802
    }
1803

    
1804
    if(s->shape != BIN_ONLY_SHAPE){
1805
        s->next_resync_qscale= get_bits(gb, 5);
1806
        if(s->next_resync_qscale==0)
1807
            s->next_resync_qscale= s->qscale;
1808
        if(s->next_resync_qscale==0){
1809
            fprintf(stderr, "qscale==0\n");
1810
            return -1;
1811
        }
1812
    }
1813

    
1814
    if(s->shape == RECT_SHAPE){
1815
        header_extension= get_bits1(gb);
1816
    }
1817
    if(header_extension){
1818
        int time_increment;
1819
        int time_incr=0;
1820
        printf("header extension not supported\n");
1821
        return -1;
1822

    
1823
        while (get_bits1(gb) != 0) 
1824
            time_incr++;
1825

    
1826
        check_marker(gb, "before time_increment in video packed header");
1827
        time_increment= get_bits(gb, s->time_increment_bits);
1828
        if(s->pict_type!=B_TYPE){
1829
            s->last_time_base= s->time_base;
1830
            s->time_base+= time_incr;
1831
            s->time= s->time_base*s->time_increment_resolution + time_increment;
1832
            s->pp_time= s->time - s->last_non_b_time;
1833
            s->last_non_b_time= s->time;
1834
        }else{
1835
            s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
1836
            s->bp_time= s->last_non_b_time - s->time;
1837
        }
1838
        check_marker(gb, "before vop_coding_type in video packed header");
1839
        
1840
        skip_bits(gb, 2); /* vop coding type */
1841
        //FIXME not rect stuff here
1842

    
1843
        if(s->shape != BIN_ONLY_SHAPE){
1844
            skip_bits(gb, 3); /* intra dc vlc threshold */
1845

    
1846
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){
1847
                mpeg4_decode_sprite_trajectory(s);
1848
            }
1849

    
1850
            //FIXME reduced res stuff here
1851
            
1852
            if (s->pict_type != I_TYPE) {
1853
                s->f_code = get_bits(gb, 3);        /* fcode_for */
1854
                if(s->f_code==0){
1855
                    printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n");
1856
                    return -1; // makes no sense to continue, as the MV decoding will break very quickly
1857
                }
1858
            }
1859
            if (s->pict_type == B_TYPE) {
1860
                s->b_code = get_bits(gb, 3);
1861
            }       
1862
        }
1863
    }
1864
    //FIXME new-pred stuff
1865
    
1866
//printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
1867

    
1868
    return mb_num;
1869
}
1870

    
1871
void ff_mpeg4_clean_buffers(MpegEncContext *s)
1872
{
1873
    int c_wrap, c_xy, l_wrap, l_xy;
1874

    
1875
    l_wrap= s->block_wrap[0];
1876
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
1877
    c_wrap= s->block_wrap[4];
1878
    c_xy= s->mb_y*c_wrap + s->mb_x;
1879

    
1880
    /* clean DC */
1881
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
1882
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
1883
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
1884

    
1885
    /* clean AC */
1886
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
1887
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
1888
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
1889

    
1890
    /* clean MV */
1891
    // we cant clear the MVs as they might be needed by a b frame
1892
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
1893
//    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
1894
    s->last_mv[0][0][0]=
1895
    s->last_mv[0][0][1]=
1896
    s->last_mv[1][0][0]=
1897
    s->last_mv[1][0][1]= 0;
1898
}
1899

    
1900
/* searches for the next resync marker clears ac,dc,mc, and sets s->next_resync_gb, s->mb_num_left */
1901
int ff_mpeg4_resync(MpegEncContext *s)
1902
{
1903
    GetBitContext gb;
1904
    
1905
    /* search & parse next resync marker */
1906
    
1907
    gb= s->next_resync_gb;
1908
    align_get_bits(&gb);
1909
//printf("mpeg4_resync %d next:%d \n", get_bits_count(&gb), get_bits_count(&s->next_resync_gb));
1910
    for(;;) {
1911
        int v= show_bits(&gb, 24);
1912
        if( get_bits_count(&gb) >= gb.size*8-24 || v == 1 /* start-code */){
1913
            s->mb_num_left= s->mb_num - s->mb_x - s->mb_y*s->mb_width;
1914
//printf("mpeg4_resync end\n");
1915
            s->gb= s->next_resync_gb; //continue at the next resync marker
1916
            return -1;
1917
        }else if(v>>8 == 0){
1918
            int next;
1919
            s->next_resync_pos= get_bits_count(&gb);
1920
            
1921
            next= decode_video_packet_header(s, &gb);
1922
            if(next >= 0){
1923
                s->mb_num_left= next - s->mb_x - s->mb_y*s->mb_width;
1924
                break;
1925
            }
1926

    
1927
            align_get_bits(&gb);
1928
        }
1929
        skip_bits(&gb, 8);
1930
    }
1931
    s->next_resync_gb=gb;
1932
    
1933
    return 0;
1934
}
1935

    
1936
static inline void init_block_index(MpegEncContext *s)
1937
{
1938
    s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
1939
    s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
1940
    s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
1941
    s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
1942
    s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
1943
    s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
1944
}
1945

    
1946
static inline void update_block_index(MpegEncContext *s)
1947
{
1948
    s->block_index[0]+=2;
1949
    s->block_index[1]+=2;
1950
    s->block_index[2]+=2;
1951
    s->block_index[3]+=2;
1952
    s->block_index[4]++;
1953
    s->block_index[5]++;
1954
}
1955

    
1956
/**
1957
 * decodes the first & second partition
1958
 * returns error type or 0 if no error
1959
 */
1960
int ff_mpeg4_decode_partitions(MpegEncContext *s)
1961
{
1962
    static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
1963
    int mb_num;
1964
    
1965
    /* decode first partition */
1966
    mb_num=0;
1967
    s->first_slice_line=1;
1968
    s->mb_x= s->resync_mb_x;
1969
    for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
1970
        init_block_index(s);
1971
        for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
1972
            const int xy= s->mb_x + s->mb_y*s->mb_width;
1973
            int cbpc;
1974
            int dir=0;
1975
            
1976
            mb_num++;
1977
            update_block_index(s);
1978
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
1979
                s->first_slice_line=0;
1980
            
1981
            if(s->mb_x==0) PRINT_MB_TYPE("\n");
1982

    
1983
            if(s->pict_type==I_TYPE){
1984
                int i;
1985

    
1986
                PRINT_MB_TYPE("I");
1987
                cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
1988
                if (cbpc < 0){
1989
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
1990
                    return DECODING_DESYNC;
1991
                }
1992
                s->cbp_table[xy]= cbpc & 3;
1993
                s->mb_type[xy]= MB_TYPE_INTRA;
1994
                s->mb_intra = 1;
1995

    
1996
                if(cbpc & 4) {
1997
                    s->qscale += quant_tab[get_bits(&s->gb, 2)];
1998
                    if (s->qscale < 1)
1999
                        s->qscale = 1;
2000
                    else if (s->qscale > 31)
2001
                        s->qscale = 31;
2002
                    h263_dc_scale(s);
2003
                }
2004
                s->qscale_table[xy]= s->qscale;
2005

    
2006
                s->mbintra_table[xy]= 1;
2007
                for(i=0; i<6; i++){
2008
                    int dc_pred_dir;
2009
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2010
                    if(dc < 0){
2011
                        fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2012
                        return DECODING_DESYNC;
2013
                    }
2014
                    dir<<=1;
2015
                    if(dc_pred_dir) dir|=1;
2016
                }
2017
                s->pred_dir_table[xy]= dir;
2018
            }else{ /* P/S_TYPE */
2019
                int mx, my, pred_x, pred_y;
2020
                INT16 * const mot_val= s->motion_val[s->block_index[0]];
2021
                const int stride= s->block_wrap[0]*2;
2022

    
2023
                if(get_bits1(&s->gb)){
2024
                    /* skip mb */
2025
                    s->mb_type[xy]= MB_TYPE_SKIPED;
2026
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2027
                        const int a= s->sprite_warping_accuracy;
2028
                        PRINT_MB_TYPE("G");
2029
                        if(s->divx_version==500 && s->divx_build==413){
2030
                            mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2031
                            my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2032
                        }else{
2033
                            mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2034
                            my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2035
                            s->mb_type[xy]= MB_TYPE_GMC | MB_TYPE_SKIPED;
2036
                        }
2037
                    }else{
2038
                        PRINT_MB_TYPE("S");
2039
                        mx = 0;
2040
                        my = 0;
2041
                    }
2042
                    mot_val[0       ]= mot_val[2       ]=
2043
                    mot_val[0+stride]= mot_val[2+stride]= mx;
2044
                    mot_val[1       ]= mot_val[3       ]=
2045
                    mot_val[1+stride]= mot_val[3+stride]= my;
2046

    
2047
                    if(s->mbintra_table[xy])
2048
                        ff_clean_intra_table_entries(s);
2049

    
2050
                    continue;
2051
                }
2052
                cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
2053
                if (cbpc < 0){
2054
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2055
                    return DECODING_DESYNC;
2056
                }
2057
                if (cbpc > 20)
2058
                    cbpc+=3;
2059
                else if (cbpc == 20)
2060
                    fprintf(stderr, "Stuffing !");
2061
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2062
    
2063
                s->mb_intra = ((cbpc & 4) != 0);
2064
        
2065
                if(s->mb_intra){
2066
                    PRINT_MB_TYPE("I");
2067
                    s->mbintra_table[xy]= 1;
2068
                    s->mb_type[xy]= MB_TYPE_INTRA;
2069
                    mot_val[0       ]= mot_val[2       ]= 
2070
                    mot_val[0+stride]= mot_val[2+stride]= 0;
2071
                    mot_val[1       ]= mot_val[3       ]=
2072
                    mot_val[1+stride]= mot_val[3+stride]= 0;
2073
                }else{
2074
                    if(s->mbintra_table[xy])
2075
                        ff_clean_intra_table_entries(s);
2076

    
2077
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2078
                        s->mcsel= get_bits1(&s->gb);
2079
                    else s->mcsel= 0;
2080
        
2081
                    if ((cbpc & 16) == 0) {
2082
                        PRINT_MB_TYPE("P");
2083
                        /* 16x16 motion prediction */
2084
                        s->mb_type[xy]= MB_TYPE_INTER;
2085

    
2086
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
2087
                        if(!s->mcsel)
2088
                           mx = h263_decode_motion(s, pred_x, s->f_code);
2089
                        else {
2090
                            const int a= s->sprite_warping_accuracy;
2091
                            if(s->divx_version==500 && s->divx_build==413){
2092
                                mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2093
                            }else{
2094
                                mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2095
                            }
2096
                        }
2097
                        if (mx >= 0xffff)
2098
                            return DECODING_DESYNC;
2099
            
2100
                        if(!s->mcsel)
2101
                           my = h263_decode_motion(s, pred_y, s->f_code);
2102
                        else{
2103
                           const int a= s->sprite_warping_accuracy;
2104
                            if(s->divx_version==500 && s->divx_build==413){
2105
                                my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2106
                            }else{
2107
                                my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2108
                            }
2109
                        }
2110
                        if (my >= 0xffff)
2111
                            return DECODING_DESYNC;
2112
                        mot_val[0       ]= mot_val[2       ] =
2113
                        mot_val[0+stride]= mot_val[2+stride]= mx;
2114
                        mot_val[1       ]= mot_val[3       ]=
2115
                        mot_val[1+stride]= mot_val[3+stride]= my;
2116
                    } else {
2117
                        int i;
2118
                        PRINT_MB_TYPE("4");
2119
                        s->mb_type[xy]= MB_TYPE_INTER4V;
2120
                        for(i=0;i<4;i++) {
2121
                            INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2122
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2123
                            if (mx >= 0xffff)
2124
                                return DECODING_DESYNC;
2125
                
2126
                            my = h263_decode_motion(s, pred_y, s->f_code);
2127
                            if (my >= 0xffff)
2128
                                return DECODING_DESYNC;
2129
                            mot_val[0] = mx;
2130
                            mot_val[1] = my;
2131
                        }
2132
                    }
2133
                }
2134
            }
2135
        }
2136
        s->mb_x= 0;
2137
    }
2138

    
2139
    if     (s->pict_type==I_TYPE && get_bits(&s->gb, 19)!=DC_MARKER    ) s->decoding_error= DECODING_DESYNC;
2140
    else if(s->pict_type!=I_TYPE && get_bits(&s->gb, 17)!=MOTION_MARKER) s->decoding_error= DECODING_DESYNC;
2141
    if(s->decoding_error== DECODING_DESYNC){
2142
        fprintf(stderr, "marker missing after first partition at %d %d\n", s->mb_x, s->mb_y);
2143
        return DECODING_DESYNC;
2144
    }
2145

    
2146
    /* decode second partition */
2147
    mb_num=0;
2148
    s->mb_x= s->resync_mb_x;
2149
    for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
2150
        init_block_index(s);
2151
        for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
2152
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2153

    
2154
            mb_num++;
2155
            update_block_index(s);
2156
            
2157
            if(s->pict_type==I_TYPE){
2158
                int ac_pred= get_bits1(&s->gb);
2159
                int cbpy = get_vlc(&s->gb, &cbpy_vlc);
2160
                if(cbpy<0){
2161
                    fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2162
                    return DECODING_AC_LOST;
2163
                }
2164
                
2165
                s->cbp_table[xy]|= cbpy<<2;
2166
                s->pred_dir_table[xy]|= ac_pred<<7;
2167
            }else{ /* P || S_TYPE */
2168
                if(s->mb_type[xy]&MB_TYPE_INTRA){          
2169
                    int dir=0,i;
2170
                    int ac_pred = get_bits1(&s->gb);
2171
                    int cbpy = get_vlc(&s->gb, &cbpy_vlc);
2172

    
2173
                    if(cbpy<0){
2174
                        fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2175
                        return DECODING_ACDC_LOST;
2176
                    }
2177
                    
2178
                    if(s->cbp_table[xy] & 8) {
2179
                        s->qscale += quant_tab[get_bits(&s->gb, 2)];
2180
                        if (s->qscale < 1)
2181
                            s->qscale = 1;
2182
                        else if (s->qscale > 31)
2183
                            s->qscale = 31;
2184
                        h263_dc_scale(s);
2185
                    }
2186
                    s->qscale_table[xy]= s->qscale;
2187

    
2188
                    for(i=0; i<6; i++){
2189
                        int dc_pred_dir;
2190
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2191
                        if(dc < 0){
2192
                            fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2193
                            return DECODING_ACDC_LOST;
2194
                        }
2195
                        dir<<=1;
2196
                        if(dc_pred_dir) dir|=1;
2197
                    }
2198
                    s->cbp_table[xy]&= 3; //remove dquant
2199
                    s->cbp_table[xy]|= cbpy<<2;
2200
                    s->pred_dir_table[xy]= dir | (ac_pred<<7);
2201
                }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
2202
                    s->qscale_table[xy]= s->qscale;
2203
                    s->cbp_table[xy]= 0;
2204
                }else{
2205
                    int cbpy = get_vlc(&s->gb, &cbpy_vlc);
2206

    
2207
                    if(cbpy<0){
2208
                        fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2209
                        return DECODING_ACDC_LOST;
2210
                    }
2211
                    
2212
                    if(s->cbp_table[xy] & 8) {
2213
//fprintf(stderr, "dquant\n");
2214
                        s->qscale += quant_tab[get_bits(&s->gb, 2)];
2215
                        if (s->qscale < 1)
2216
                            s->qscale = 1;
2217
                        else if (s->qscale > 31)
2218
                            s->qscale = 31;
2219
                        h263_dc_scale(s);
2220
                    }
2221
                    s->qscale_table[xy]= s->qscale;
2222

    
2223
                    s->cbp_table[xy]&= 3; //remove dquant
2224
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
2225
                }
2226
            }
2227
        }
2228
        s->mb_x= 0;
2229
    }
2230
    
2231

    
2232
    return 0;        
2233
}
2234

    
2235
static int mpeg4_decode_partitioned_mb(MpegEncContext *s,
2236
                   DCTELEM block[6][64])
2237
{
2238
    int cbp, mb_type;
2239
    const int xy= s->mb_x + s->mb_y*s->mb_width;
2240

    
2241
    if(s->mb_x==s->resync_mb_x && s->mb_y==s->resync_mb_y){ //Note resync_mb_{x,y}==0 at the start
2242
        int i;
2243
        int block_index_backup[6];
2244
        int qscale= s->qscale;
2245
        
2246
        for(i=0; i<6; i++) block_index_backup[i]= s->block_index[i];
2247
        
2248
        s->decoding_error= ff_mpeg4_decode_partitions(s);
2249
        
2250
        for(i=0; i<6; i++) s->block_index[i]= block_index_backup[i];
2251
        s->first_slice_line=1;
2252
        s->mb_x= s->resync_mb_x;
2253
        s->mb_y= s->resync_mb_y;
2254
        s->qscale= qscale;
2255
        h263_dc_scale(s);
2256

    
2257
        if(s->decoding_error==DECODING_DESYNC) return -1;
2258
    }
2259
    
2260
    mb_type= s->mb_type[xy];
2261
    if(s->decoding_error)
2262
        cbp=0;
2263
    else 
2264
        cbp = s->cbp_table[xy];
2265

    
2266
    if(s->decoding_error!=DECODING_ACDC_LOST && s->qscale_table[xy] != s->qscale){
2267
        s->qscale= s->qscale_table[xy];
2268
        h263_dc_scale(s);
2269
    }
2270

    
2271
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2272
        int i;
2273
        for(i=0; i<4; i++){
2274
            s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
2275
            s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
2276
        }
2277
        s->mb_intra = mb_type&MB_TYPE_INTRA;
2278

    
2279
        if (mb_type&MB_TYPE_SKIPED) {
2280
            /* skip mb */
2281
            for(i=0;i<6;i++)
2282
                s->block_last_index[i] = -1;
2283
            s->mv_dir = MV_DIR_FORWARD;
2284
            s->mv_type = MV_TYPE_16X16;
2285
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2286
                s->mcsel=1;
2287
                s->mb_skiped = 0;
2288
            }else{
2289
                s->mcsel=0;
2290
                s->mb_skiped = 1;
2291
            }
2292
            return 0;
2293
        }else if(s->mb_intra && s->decoding_error!=DECODING_ACDC_LOST){
2294
            s->ac_pred = s->pred_dir_table[xy]>>7;
2295

    
2296
            /* decode each block */
2297
            for (i = 0; i < 6; i++) {
2298
                int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
2299
                if(ret==DECODING_AC_LOST){
2300
                    fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2301
                    s->decoding_error=DECODING_AC_LOST;
2302
                    cbp=0;
2303
                }else if(ret==DECODING_ACDC_LOST){
2304
                    fprintf(stderr, "dc corrupted at %d %d (trying to continue with mc only)\n", s->mb_x, s->mb_y);
2305
                    s->decoding_error=DECODING_ACDC_LOST;
2306
                    break;
2307
                }
2308
            }
2309
        }else if(!s->mb_intra){
2310
//            s->mcsel= 0; //FIXME do we need to init that
2311
            
2312
            s->mv_dir = MV_DIR_FORWARD;
2313
            if (mb_type&MB_TYPE_INTER4V) {
2314
                s->mv_type = MV_TYPE_8X8;
2315
            } else {
2316
                s->mv_type = MV_TYPE_16X16;
2317
            }
2318
            if(s->decoding_error==0 && cbp){
2319
                /* decode each block */
2320
                for (i = 0; i < 6; i++) {
2321
                    int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
2322
                    if(ret==DECODING_AC_LOST){
2323
                        fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2324
                        s->decoding_error=DECODING_AC_LOST;
2325
                        break;
2326
                    }
2327
                }
2328
            }
2329
        }
2330
    } else { /* I-Frame */
2331
        int i;
2332
        s->mb_intra = 1;
2333
        s->ac_pred = s->pred_dir_table[xy]>>7;
2334
        
2335
        /* decode each block */
2336
        for (i = 0; i < 6; i++) {
2337
            int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
2338
            if(ret==DECODING_AC_LOST){
2339
                fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
2340
                s->decoding_error=DECODING_AC_LOST;
2341
                cbp=0;
2342
            }else if(ret==DECODING_ACDC_LOST){
2343
                fprintf(stderr, "dc corrupted at %d %d\n", s->mb_x, s->mb_y);
2344
                return -1;
2345
            }
2346
        }
2347
    }
2348

    
2349
    return 0;
2350
}
2351

    
2352

    
2353
int h263_decode_mb(MpegEncContext *s,
2354
                   DCTELEM block[6][64])
2355
{
2356
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
2357
    INT16 *mot_val;
2358
    static INT8 quant_tab[4] = { -1, -2, 1, 2 };
2359

    
2360
    if(s->mb_x==0) PRINT_MB_TYPE("\n")
2361

    
2362
    if(s->resync_marker){
2363
        if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
2364
            s->first_slice_line=0; 
2365
        }
2366
    }
2367

    
2368
    if(s->data_partitioning && s->pict_type!=B_TYPE)
2369
        return mpeg4_decode_partitioned_mb(s, block);
2370

    
2371
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2372
        if (get_bits1(&s->gb)) {
2373
            /* skip mb */
2374
            s->mb_intra = 0;
2375
            for(i=0;i<6;i++)
2376
                s->block_last_index[i] = -1;
2377
            s->mv_dir = MV_DIR_FORWARD;
2378
            s->mv_type = MV_TYPE_16X16;
2379
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2380
                const int a= s->sprite_warping_accuracy;
2381
//                int l = (1 << (s->f_code - 1)) * 32;
2382
                PRINT_MB_TYPE("G");
2383
                s->mcsel=1;
2384
                if(s->divx_version==500 && s->divx_build==413){
2385
                    s->mv[0][0][0] = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2386
                    s->mv[0][0][1] = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2387
                }else{
2388
                    s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2389
                    s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2390
                }
2391
/*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
2392
                else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
2393
                if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
2394
                else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
2395

    
2396
                s->mb_skiped = 0;
2397
            }else{
2398
                PRINT_MB_TYPE("S");
2399
                s->mcsel=0;
2400
                s->mv[0][0][0] = 0;
2401
                s->mv[0][0][1] = 0;
2402
                s->mb_skiped = 1;
2403
            }
2404
            return 0;
2405
        }
2406
        cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
2407
        //fprintf(stderr, "\tCBPC: %d", cbpc);
2408
        if (cbpc < 0)
2409
            return -1;
2410
        if (cbpc > 20)
2411
            cbpc+=3;
2412
        else if (cbpc == 20)
2413
            fprintf(stderr, "Stuffing !");
2414
        
2415
        dquant = cbpc & 8;
2416
        s->mb_intra = ((cbpc & 4) != 0);
2417
        if (s->mb_intra) goto intra;
2418
        
2419
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2420
            s->mcsel= get_bits1(&s->gb);
2421
        else s->mcsel= 0;
2422
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
2423
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
2424
        if (dquant) {
2425
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
2426
            if (s->qscale < 1)
2427
                s->qscale = 1;
2428
            else if (s->qscale > 31)
2429
                s->qscale = 31;
2430
            h263_dc_scale(s);
2431
        }
2432
        s->mv_dir = MV_DIR_FORWARD;
2433
        if ((cbpc & 16) == 0) {
2434
            PRINT_MB_TYPE("P");
2435
            /* 16x16 motion prediction */
2436
            s->mv_type = MV_TYPE_16X16;
2437
            h263_pred_motion(s, 0, &pred_x, &pred_y);
2438
            if (s->umvplus_dec)
2439
               mx = h263p_decode_umotion(s, pred_x);
2440
            else if(!s->mcsel)
2441
               mx = h263_decode_motion(s, pred_x, s->f_code);
2442
            else {
2443
               const int a= s->sprite_warping_accuracy;
2444
//        int l = (1 << (s->f_code - 1)) * 32;
2445
                if(s->divx_version==500 && s->divx_build==413){
2446
                    mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2447
                }else{
2448
                    mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2449
                }
2450
//        if (mx < -l) mx= -l, printf("C");
2451
//        else if (mx >= l) mx= l-1, printf("C");
2452
            }
2453
            if (mx >= 0xffff)
2454
                return -1;
2455
            
2456
            if (s->umvplus_dec)
2457
               my = h263p_decode_umotion(s, pred_y);
2458
            else if(!s->mcsel)
2459
               my = h263_decode_motion(s, pred_y, s->f_code);
2460
            else{
2461
               const int a= s->sprite_warping_accuracy;
2462
//       int l = (1 << (s->f_code - 1)) * 32;
2463
                if(s->divx_version==500 && s->divx_build==413){
2464
                    my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2465
                }else{
2466
                    my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2467
                }
2468
//       if (my < -l) my= -l, printf("C");
2469
//       else if (my >= l) my= l-1, printf("C");
2470
            }
2471
            if (my >= 0xffff)
2472
                return -1;
2473
            s->mv[0][0][0] = mx;
2474
            s->mv[0][0][1] = my;
2475
            /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
2476
            fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
2477
            fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
2478
            if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2479
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
2480
                           
2481
        } else {
2482
            PRINT_MB_TYPE("4");
2483
            s->mv_type = MV_TYPE_8X8;
2484
            for(i=0;i<4;i++) {
2485
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
2486
                if (s->umvplus_dec)
2487
                  mx = h263p_decode_umotion(s, pred_x);
2488
                else
2489
                  mx = h263_decode_motion(s, pred_x, s->f_code);
2490
                if (mx >= 0xffff)
2491
                    return -1;
2492
                
2493
                if (s->umvplus_dec)
2494
                  my = h263p_decode_umotion(s, pred_y);
2495
                else    
2496
                  my = h263_decode_motion(s, pred_y, s->f_code);
2497
                if (my >= 0xffff)
2498
                    return -1;
2499
                s->mv[0][i][0] = mx;
2500
                s->mv[0][i][1] = my;
2501
                if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2502
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
2503
                mot_val[0] = mx;
2504
                mot_val[1] = my;
2505
            }
2506
        }
2507
    } else if(s->pict_type==B_TYPE) {
2508
        int modb1; // first bit of modb
2509
        int modb2; // second bit of modb
2510
        int mb_type;
2511
        uint16_t time_pp;
2512
        uint16_t time_pb;
2513
        int xy;
2514

    
2515
        s->mb_intra = 0; //B-frames never contain intra blocks
2516
        s->mcsel=0;      //     ...               true gmc blocks
2517

    
2518
        if(s->mb_x==0){
2519
            s->last_mv[0][0][0]= 
2520
            s->last_mv[0][0][1]= 
2521
            s->last_mv[1][0][0]= 
2522
            s->last_mv[1][0][1]= 0;
2523
        }
2524

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

    
2528
        if(s->mb_skiped){
2529
                /* skip mb */
2530
            for(i=0;i<6;i++)
2531
                s->block_last_index[i] = -1;
2532

    
2533
            s->mv_dir = MV_DIR_FORWARD;
2534
            s->mv_type = MV_TYPE_16X16;
2535
            s->mv[0][0][0] = 0;
2536
            s->mv[0][0][1] = 0;
2537
            s->mv[1][0][0] = 0;
2538
            s->mv[1][0][1] = 0;
2539
//FIXME is this correct?
2540
/*            s->last_mv[0][0][0]=
2541
            s->last_mv[0][0][1]=0;*/
2542
            PRINT_MB_TYPE("s")
2543
            return 0;
2544
        }
2545

    
2546
        modb1= get_bits1(&s->gb);
2547
        if(modb1==0){
2548
            modb2= get_bits1(&s->gb);
2549
            mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
2550
            if(modb2==0) cbp= get_bits(&s->gb, 6);
2551
            else cbp=0;
2552
            if (mb_type && cbp) {
2553
                if(get_bits1(&s->gb)){
2554
                    s->qscale +=get_bits1(&s->gb)*4 - 2;
2555
                    if (s->qscale < 1)
2556
                        s->qscale = 1;
2557
                    else if (s->qscale > 31)
2558
                        s->qscale = 31;
2559
                    h263_dc_scale(s);
2560
                }
2561
            }
2562
        }else{
2563
            mb_type=4; //like 0 but no vectors coded
2564
            cbp=0;
2565
        }
2566
        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
2567
        mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
2568
        switch(mb_type)
2569
        {
2570
        case 0: /* direct */
2571
            mx = h263_decode_motion(s, 0, 1);
2572
            my = h263_decode_motion(s, 0, 1);
2573
        case 4: /* direct with mx=my=0 */
2574
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2575
            xy= s->block_index[0];
2576
            time_pp= s->pp_time;
2577
            time_pb= time_pp - s->bp_time;
2578
//if(time_pp>3000 )printf("%d %d  ", time_pp, time_pb);
2579
            //FIXME 4MV
2580
            //FIXME avoid divides
2581
            s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
2582
            s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
2583
            s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
2584
                                : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
2585
            s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
2586
                                : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
2587
/*            s->mv[0][0][0] = 
2588
            s->mv[0][0][1] = 
2589
            s->mv[1][0][0] = 
2590
            s->mv[1][0][1] = 1000;*/
2591
            PRINT_MB_TYPE("D");
2592
            break;
2593
        case 1: 
2594
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2595
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
2596
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
2597
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
2598
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
2599

    
2600
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
2601
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
2602
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
2603
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
2604
            PRINT_MB_TYPE("i");
2605
            break;
2606
        case 2: 
2607
            s->mv_dir = MV_DIR_BACKWARD;
2608
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
2609
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
2610
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
2611
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
2612
            PRINT_MB_TYPE("B");
2613
            break;
2614
        case 3:
2615
            s->mv_dir = MV_DIR_FORWARD;
2616
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
2617
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
2618
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
2619
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
2620
            PRINT_MB_TYPE("F");
2621
            break;
2622
        default: 
2623
            printf("illegal MB_type\n");
2624
            return -1;
2625
        }
2626
    } else { /* I-Frame */
2627
        cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
2628
        if (cbpc < 0)
2629
            return -1;
2630
        dquant = cbpc & 4;
2631
        s->mb_intra = 1;
2632
intra:
2633
        PRINT_MB_TYPE("I");
2634
        s->ac_pred = 0;
2635
        if (s->h263_pred || s->h263_aic) {
2636
            s->ac_pred = get_bits1(&s->gb);
2637
            if (s->ac_pred && s->h263_aic)
2638
                s->h263_aic_dir = get_bits1(&s->gb);
2639
        }
2640
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
2641
        if(cbpy<0) return -1;
2642
        cbp = (cbpc & 3) | (cbpy << 2);
2643
        if (dquant) {
2644
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
2645
            if (s->qscale < 1)
2646
                s->qscale = 1;
2647
            else if (s->qscale > 31)
2648
                s->qscale = 31;
2649
            h263_dc_scale(s);
2650
        }
2651
    }
2652

    
2653
    /* decode each block */
2654
    if (s->h263_pred) {
2655
        for (i = 0; i < 6; i++) {
2656
            if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
2657
                return -1;
2658
        }
2659
    } else {
2660
        for (i = 0; i < 6; i++) {
2661
            if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
2662
                return -1;
2663
        }
2664
    }
2665
    return 0;
2666
}
2667

    
2668
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
2669
{
2670
    int code, val, sign, shift, l, m;
2671

    
2672
    code = get_vlc(&s->gb, &mv_vlc);
2673
    if (code < 0)
2674
        return 0xffff;
2675

    
2676
    if (code == 0)
2677
        return pred;
2678
    sign = get_bits1(&s->gb);
2679
    shift = f_code - 1;
2680
    val = (code - 1) << shift;
2681
    if (shift > 0)
2682
        val |= get_bits(&s->gb, shift);
2683
    val++;
2684
    if (sign)
2685
        val = -val;
2686
    val += pred;
2687

    
2688
    /* modulo decoding */
2689
    if (!s->h263_long_vectors) {
2690
        l = (1 << (f_code - 1)) * 32;
2691
        m = 2 * l;
2692
        if (val < -l) {
2693
            val += m;
2694
        } else if (val >= l) {
2695
            val -= m;
2696
        }
2697
    } else {
2698
        /* horrible h263 long vector mode */
2699
        if (pred < -31 && val < -63)
2700
            val += 64;
2701
        if (pred > 32 && val > 63)
2702
            val -= 64;
2703
        
2704
    }
2705
    return val;
2706
}
2707

    
2708
/* Decodes RVLC of H.263+ UMV */
2709
static int h263p_decode_umotion(MpegEncContext * s, int pred)
2710
{
2711
   int code = 0, sign;
2712
   
2713
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
2714
      return pred;
2715
   
2716
   code = 2 + get_bits1(&s->gb);
2717
   
2718
   while (get_bits1(&s->gb))
2719
   {
2720
      code <<= 1;
2721
      code += get_bits1(&s->gb);
2722
   }
2723
   sign = code & 1;
2724
   code >>= 1;
2725
   
2726
   code = (sign) ? (pred - code) : (pred + code);
2727
#ifdef DEBUG
2728
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
2729
#endif
2730
   return code;   
2731

    
2732
}
2733

    
2734
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
2735
                             int n, int coded)
2736
{
2737
    int code, level, i, j, last, run;
2738
    RLTable *rl = &rl_inter;
2739
    const UINT8 *scan_table;
2740

    
2741
    scan_table = zigzag_direct;
2742
    if (s->h263_aic && s->mb_intra) {
2743
        rl = &rl_intra_aic;
2744
        i = 0;
2745
        if (s->ac_pred) {
2746
            if (s->h263_aic_dir) 
2747
                scan_table = ff_alternate_vertical_scan; /* left */
2748
            else
2749
                scan_table = ff_alternate_horizontal_scan; /* top */
2750
        }
2751
    } else if (s->mb_intra) {
2752
        /* DC coef */
2753
        if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
2754
            int component, diff;
2755
            component = (n <= 3 ? 0 : n - 4 + 1);
2756
            level = s->last_dc[component];
2757
            if (s->rv10_first_dc_coded[component]) {
2758
                diff = rv_decode_dc(s, n);
2759
                if (diff == 0xffff)
2760
                    return -1;
2761
                level += diff;
2762
                level = level & 0xff; /* handle wrap round */
2763
                s->last_dc[component] = level;
2764
            } else {
2765
                s->rv10_first_dc_coded[component] = 1;
2766
            }
2767
        } else {
2768
            level = get_bits(&s->gb, 8);
2769
            if (level == 255)
2770
                level = 128;
2771
        }
2772
        block[0] = level;
2773
        i = 1;
2774
    } else {
2775
        i = 0;
2776
    }
2777
    if (!coded) {
2778
        if (s->mb_intra && s->h263_aic)
2779
            goto not_coded;
2780
        s->block_last_index[n] = i - 1;
2781
        return 0;
2782
    }
2783

    
2784
    for(;;) {
2785
        code = get_vlc(&s->gb, &rl->vlc);
2786
        if (code < 0)
2787
            return -1;
2788
        if (code == rl->n) {
2789
            /* escape */
2790
            last = get_bits1(&s->gb);
2791
            run = get_bits(&s->gb, 6);
2792
            level = (INT8)get_bits(&s->gb, 8);
2793
            if (s->h263_rv10 && level == -128) {
2794
                /* XXX: should patch encoder too */
2795
                level = get_bits(&s->gb, 12);
2796
                level = (level << 20) >> 20;
2797
            }
2798
        } else {
2799
            run = rl->table_run[code];
2800
            level = rl->table_level[code];
2801
            last = code >= rl->last;
2802
            if (get_bits1(&s->gb))
2803
                level = -level;
2804
        }
2805
        i += run;
2806
        if (i >= 64)
2807
            return -1;
2808
        j = scan_table[i];
2809
        block[j] = level;
2810
        if (last)
2811
            break;
2812
        i++;
2813
    }
2814
not_coded:    
2815
    if (s->mb_intra && s->h263_aic) {
2816
        h263_pred_acdc(s, block, n);
2817
        i = 63;
2818
    }
2819
    s->block_last_index[n] = i;
2820
    return 0;
2821
}
2822

    
2823
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
2824
{
2825
    int level, pred, code;
2826
    UINT16 *dc_val;
2827

    
2828
    if (n < 4) 
2829
        code = get_vlc(&s->gb, &dc_lum);
2830
    else 
2831
        code = get_vlc(&s->gb, &dc_chrom);
2832
    if (code < 0 || code > 9 /* && s->nbit<9 */){
2833
        fprintf(stderr, "illegal dc vlc\n");
2834
        return -1;
2835
    }
2836
    if (code == 0) {
2837
        level = 0;
2838
    } else {
2839
        level = get_bits(&s->gb, code);
2840
        if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
2841
            level = - (level ^ ((1 << code) - 1));
2842
        if (code > 8){
2843
            if(get_bits1(&s->gb)==0){ /* marker */
2844
                fprintf(stderr, "dc marker bit missing\n");
2845
                return -1;
2846
            }
2847
        }
2848
    }
2849

    
2850
    pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
2851
    level += pred;
2852
    if (level < 0)
2853
        level = 0;
2854
    if (n < 4) {
2855
        *dc_val = level * s->y_dc_scale;
2856
    } else {
2857
        *dc_val = level * s->c_dc_scale;
2858
    }
2859
    return level;
2860
}
2861

    
2862
/**
2863
 * decode a block
2864
 * returns 0 if everything went ok
2865
 * returns DECODING_AC_LOST   if an error was detected during AC decoding
2866
 * returns DECODING_ACDC_LOST if an error was detected during DC decoding
2867
 */
2868
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
2869
                              int n, int coded)
2870
{
2871
    int code, level, i, j, last, run;
2872
    int dc_pred_dir;
2873
    RLTable *rl;
2874
    const UINT8 *scan_table;
2875

    
2876
    if (s->mb_intra) {
2877
        /* DC coef */
2878
        if(s->data_partitioning && s->pict_type!=B_TYPE){
2879
            level = s->dc_val[0][ s->block_index[n] ];
2880
            if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
2881
            else    level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
2882
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
2883
        }else{
2884
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
2885
            if (level < 0)
2886
                return DECODING_ACDC_LOST;
2887
        }
2888
        block[0] = level;
2889
        i = 1;
2890
        if (!coded) 
2891
            goto not_coded;
2892
        rl = &rl_intra;
2893
        if (s->ac_pred) {
2894
            if (dc_pred_dir == 0) 
2895
                scan_table = ff_alternate_vertical_scan; /* left */
2896
            else
2897
                scan_table = ff_alternate_horizontal_scan; /* top */
2898
        } else {
2899
            scan_table = zigzag_direct;
2900
        }
2901
    } else {
2902
        i = 0;
2903
        if (!coded) {
2904
            s->block_last_index[n] = i - 1;
2905
            return 0;
2906
        }
2907
        rl = &rl_inter;
2908
        scan_table = zigzag_direct;
2909
    }
2910

    
2911
    for(;;) {
2912
        code = get_vlc(&s->gb, &rl->vlc);
2913
        if (code < 0)
2914
            return DECODING_AC_LOST;
2915
        if (code == rl->n) {
2916
            /* escape */
2917
            if (get_bits1(&s->gb) != 0) {
2918
                if (get_bits1(&s->gb) != 0) {
2919
                    /* third escape */
2920
                    last = get_bits1(&s->gb);
2921
                    run = get_bits(&s->gb, 6);
2922
                    if(get_bits1(&s->gb)==0){
2923
                        fprintf(stderr, "1. marker bit missing in 3. esc\n");
2924
                        return DECODING_AC_LOST;
2925
                    }
2926
                    level = get_bits(&s->gb, 12);
2927
                    level = (level << 20) >> 20; /* sign extend */
2928
                    if(get_bits1(&s->gb)==0){
2929
                        fprintf(stderr, "2. marker bit missing in 3. esc\n");
2930
                        return DECODING_AC_LOST;
2931
                    }
2932
                    if(level>512 || level<-512){ //FIXME check that QP=1 is ok with this too
2933
                        fprintf(stderr, "|level| overflow in 3. esc\n");
2934
                        return DECODING_AC_LOST;
2935
                    }
2936
#if 1 
2937
                    {
2938
                        const int abs_level= ABS(level);
2939
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN && s->error_resilience>=0){
2940
                            const int run1= run - rl->max_run[last][abs_level] - 1;
2941
                            if(abs_level <= rl->max_level[last][run]){
2942
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
2943
                                return DECODING_AC_LOST;
2944
                            }
2945
                            if(abs_level <= rl->max_level[last][run]*2){
2946
                                fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
2947
                                return DECODING_AC_LOST;
2948
                            }
2949
                            if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
2950
                                fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
2951
                                return DECODING_AC_LOST;
2952
                            }
2953
                        }
2954
                    }
2955
#endif
2956
                } else {
2957
                    /* second escape */
2958
                    code = get_vlc(&s->gb, &rl->vlc);
2959
                    if (code < 0 || code >= rl->n)
2960
                        return DECODING_AC_LOST;
2961
                    run = rl->table_run[code];
2962
                    level = rl->table_level[code];
2963
                    last = code >= rl->last;
2964
                    run += rl->max_run[last][level] + 1;
2965
                    if (get_bits1(&s->gb))
2966
                        level = -level;
2967
                }
2968
            } else {
2969
                /* first escape */
2970
                code = get_vlc(&s->gb, &rl->vlc);
2971
                if (code < 0 || code >= rl->n)
2972
                    return DECODING_AC_LOST;
2973
                run = rl->table_run[code];
2974
                level = rl->table_level[code];
2975
                last = code >= rl->last;
2976
                level += rl->max_level[last][run];
2977
                if (get_bits1(&s->gb))
2978
                    level = -level;
2979
            }
2980
        } else {
2981
            run = rl->table_run[code];
2982
            level = rl->table_level[code];
2983
            last = code >= rl->last;
2984
            if (get_bits1(&s->gb))
2985
                level = -level;
2986
        }
2987
        i += run;
2988
        if (i >= 64)
2989
            return DECODING_AC_LOST;
2990
        j = scan_table[i];
2991
        block[j] = level;
2992
        i++;
2993
        if (last)
2994
            break;
2995
    }
2996
 not_coded:
2997
    if (s->mb_intra) {
2998
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
2999
        if (s->ac_pred) {
3000
            i = 64; /* XXX: not optimal */
3001
        }
3002
    }
3003
    s->block_last_index[n] = i - 1;
3004
    return 0;
3005
}
3006

    
3007
/* most is hardcoded. should extend to handle all h263 streams */
3008
int h263_decode_picture_header(MpegEncContext *s)
3009
{
3010
    int format, width, height;
3011

    
3012
    /* picture start code */
3013
    if (get_bits(&s->gb, 22) != 0x20) {
3014
        fprintf(stderr, "Bad picture start code\n");
3015
        return -1;
3016
    }
3017
    /* temporal reference */
3018
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3019

    
3020
    /* PTYPE starts here */    
3021
    if (get_bits1(&s->gb) != 1) {
3022
        /* marker */
3023
        fprintf(stderr, "Bad marker\n");
3024
        return -1;
3025
    }
3026
    if (get_bits1(&s->gb) != 0) {
3027
        fprintf(stderr, "Bad H263 id\n");
3028
        return -1;        /* h263 id */
3029
    }
3030
    skip_bits1(&s->gb);        /* split screen off */
3031
    skip_bits1(&s->gb);        /* camera  off */
3032
    skip_bits1(&s->gb);        /* freeze picture release off */
3033

    
3034
    /* Reset GOB number */
3035
    s->gob_number = 0;
3036
        
3037
    format = get_bits(&s->gb, 3);
3038
    /*
3039
        0    forbidden
3040
        1    sub-QCIF
3041
        10   QCIF
3042
        7        extended PTYPE (PLUSPTYPE)
3043
    */
3044

    
3045
    if (format != 7 && format != 6) {
3046
        s->h263_plus = 0;
3047
        /* H.263v1 */
3048
        width = h263_format[format][0];
3049
        height = h263_format[format][1];
3050
        if (!width)
3051
            return -1;
3052
        
3053
        s->width = width;
3054
        s->height = height;
3055
        s->pict_type = I_TYPE + get_bits1(&s->gb);
3056

    
3057
        s->unrestricted_mv = get_bits1(&s->gb); 
3058
        s->h263_long_vectors = s->unrestricted_mv;
3059

    
3060
        if (get_bits1(&s->gb) != 0) {
3061
            fprintf(stderr, "H263 SAC not supported\n");
3062
            return -1;        /* SAC: off */
3063
        }
3064
        if (get_bits1(&s->gb) != 0) {
3065
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3066
        }   
3067
        
3068
        if (get_bits1(&s->gb) != 0) {
3069
            fprintf(stderr, "H263 PB frame not supported\n");
3070
            return -1;        /* not PB frame */
3071
        }
3072
        s->qscale = get_bits(&s->gb, 5);
3073
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
3074
    } else {
3075
        int ufep;
3076
        
3077
        /* H.263v2 */
3078
        s->h263_plus = 1;
3079
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3080

    
3081
        /* ufep other than 0 and 1 are reserved */        
3082
        if (ufep == 1) {
3083
            /* OPPTYPE */       
3084
            format = get_bits(&s->gb, 3);
3085
            dprintf("ufep=1, format: %d\n", format);
3086
            skip_bits(&s->gb,1); /* Custom PCF */
3087
            s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3088
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3089
            if (get_bits1(&s->gb) != 0) {
3090
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3091
            }
3092
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3093
                s->h263_aic = 1;
3094
            }
3095
            
3096
            skip_bits(&s->gb, 7);
3097
            /* these are the 7 bits: (in order of appearence  */
3098
            /* Deblocking Filter */
3099
            /* Slice Structured */
3100
            /* Reference Picture Selection */
3101
            /* Independent Segment Decoding */
3102
            /* Alternative Inter VLC */
3103
            /* Modified Quantization */
3104
            /* Prevent start code emulation */
3105

    
3106
            skip_bits(&s->gb, 3); /* Reserved */
3107
        } else if (ufep != 0) {
3108
            fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3109
            return -1;
3110
        }
3111
            
3112
        /* MPPTYPE */
3113
        s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3114
        dprintf("pict_type: %d\n", s->pict_type);
3115
        if (s->pict_type != I_TYPE &&
3116
            s->pict_type != P_TYPE)
3117
            return -1;
3118
        skip_bits(&s->gb, 2);
3119
        s->no_rounding = get_bits1(&s->gb);
3120
        dprintf("RTYPE: %d\n", s->no_rounding);
3121
        skip_bits(&s->gb, 4);
3122
        
3123
        /* Get the picture dimensions */
3124
        if (ufep) {
3125
            if (format == 6) {
3126
                /* Custom Picture Format (CPFMT) */
3127
                s->aspect_ratio_info = get_bits(&s->gb, 4);
3128
                dprintf("aspect: %d\n", s->aspect_ratio_info);
3129
                /* aspect ratios:
3130
                0 - forbidden
3131
                1 - 1:1
3132
                2 - 12:11 (CIF 4:3)
3133
                3 - 10:11 (525-type 4:3)
3134
                4 - 16:11 (CIF 16:9)
3135
                5 - 40:33 (525-type 16:9)
3136
                6-14 - reserved
3137
                */
3138
                width = (get_bits(&s->gb, 9) + 1) * 4;
3139
                skip_bits1(&s->gb);
3140
                height = get_bits(&s->gb, 9) * 4;
3141
                dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
3142
                if (s->aspect_ratio_info == EXTENDED_PAR) {
3143
                    /* aspected dimensions */
3144
                    skip_bits(&s->gb, 8); /* width */
3145
                    skip_bits(&s->gb, 8); /* height */
3146
                }
3147
            } else {
3148
                width = h263_format[format][0];
3149
                height = h263_format[format][1];
3150
            }
3151
            if ((width == 0) || (height == 0))
3152
                return -1;
3153
            s->width = width;
3154
            s->height = height;
3155
            if (s->umvplus_dec) {
3156
                skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
3157
            }
3158
        }
3159
            
3160
        s->qscale = get_bits(&s->gb, 5);
3161
    }
3162
    /* PEI */
3163
    while (get_bits1(&s->gb) != 0) {
3164
        skip_bits(&s->gb, 8);
3165
    }
3166
    s->f_code = 1;
3167
    
3168
    if(s->h263_aic){
3169
         s->y_dc_scale_table= 
3170
         s->c_dc_scale_table= h263_aic_dc_scale_table;
3171
    }else{
3172
        s->y_dc_scale_table=
3173
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
3174
    }
3175

    
3176
    return 0;
3177
}
3178

    
3179
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
3180
{
3181
    int i;
3182
    int a= 2<<s->sprite_warping_accuracy;
3183
    int rho= 3-s->sprite_warping_accuracy;
3184
    int r=16/a;
3185
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
3186
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
3187
    int sprite_ref[4][2];
3188
    int virtual_ref[2][2];
3189
    int w2, h2;
3190
    int alpha=0, beta=0;
3191
    int w= s->width;
3192
    int h= s->height;
3193
//printf("SP %d\n", s->sprite_warping_accuracy);
3194
    for(i=0; i<s->num_sprite_warping_points; i++){
3195
        int length;
3196
        int x=0, y=0;
3197

    
3198
        length= get_vlc(&s->gb, &sprite_trajectory);
3199
        if(length){
3200
            x= get_bits(&s->gb, length);
3201
//printf("lx %d %d\n", length, x);
3202
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
3203
                x = - (x ^ ((1 << length) - 1));
3204
        }
3205
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
3206
        
3207
        length= get_vlc(&s->gb, &sprite_trajectory);
3208
        if(length){
3209
            y=get_bits(&s->gb, length);
3210
//printf("ly %d %d\n", length, y);
3211
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
3212
                y = - (y ^ ((1 << length) - 1));
3213
        }
3214
        skip_bits1(&s->gb); /* marker bit */
3215
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
3216
//if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
3217
//x=y=0;
3218
        d[i][0]= x;
3219
        d[i][1]= y;
3220
    }
3221

    
3222
    while((1<<alpha)<w) alpha++;
3223
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
3224
    w2= 1<<alpha;
3225
    h2= 1<<beta;
3226

    
3227
// Note, the 4th point isnt used for GMC
3228
    if(s->divx_version==500 && s->divx_build==413){
3229
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
3230
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
3231
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
3232
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
3233
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
3234
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
3235
    } else {
3236
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
3237
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
3238
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
3239
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
3240
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
3241
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
3242
    }
3243
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
3244
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
3245
    
3246
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
3247
// perhaps it should be reordered to be more readable ...
3248
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
3249
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
3250
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
3251
        + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
3252
    virtual_ref[0][1]= 16*vop_ref[0][1] 
3253
        + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
3254
    virtual_ref[1][0]= 16*vop_ref[0][0] 
3255
        + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
3256
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
3257
        + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
3258

    
3259
    switch(s->num_sprite_warping_points)
3260
    {
3261
        case 0:
3262
            s->sprite_offset[0][0]= 0;
3263
            s->sprite_offset[0][1]= 0;
3264
            s->sprite_offset[1][0]= 0;
3265
            s->sprite_offset[1][1]= 0;
3266
            s->sprite_delta[0][0][0]= a;
3267
            s->sprite_delta[0][0][1]= 0;
3268
            s->sprite_delta[0][1][0]= 0;
3269
            s->sprite_delta[0][1][1]= a;
3270
            s->sprite_delta[1][0][0]= a;
3271
            s->sprite_delta[1][0][1]= 0;
3272
            s->sprite_delta[1][1][0]= 0;
3273
            s->sprite_delta[1][1][1]= a;
3274
            s->sprite_shift[0][0]= 0;
3275
            s->sprite_shift[0][1]= 0;
3276
            s->sprite_shift[1][0]= 0;
3277
            s->sprite_shift[1][1]= 0;
3278
            break;
3279
        case 1: //GMC only
3280
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
3281
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
3282
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
3283
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
3284
            s->sprite_delta[0][0][0]= a;
3285
            s->sprite_delta[0][0][1]= 0;
3286
            s->sprite_delta[0][1][0]= 0;
3287
            s->sprite_delta[0][1][1]= a;
3288
            s->sprite_delta[1][0][0]= a;
3289
            s->sprite_delta[1][0][1]= 0;
3290
            s->sprite_delta[1][1][0]= 0;
3291
            s->sprite_delta[1][1][1]= a;
3292
            s->sprite_shift[0][0]= 0;
3293
            s->sprite_shift[0][1]= 0;
3294
            s->sprite_shift[1][0]= 0;
3295
            s->sprite_shift[1][1]= 0;
3296
            break;
3297
        case 2:
3298
        case 3: //FIXME
3299
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
3300
                                                  + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
3301
                                                    +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
3302
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
3303
                                                  + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
3304
                                                    +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
3305
            s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
3306
                                 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
3307
                                 +2*w2*r*sprite_ref[0][0] - 16*w2);
3308
            s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
3309
                                 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
3310
                                 +2*w2*r*sprite_ref[0][1] - 16*w2);
3311
            s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3312
            s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);
3313
            s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
3314
            s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3315
            s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
3316
            s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
3317
            s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
3318
            s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
3319
            s->sprite_shift[0][0]= alpha+rho;
3320
            s->sprite_shift[0][1]= alpha+rho;
3321
            s->sprite_shift[1][0]= alpha+rho+2;
3322
            s->sprite_shift[1][1]= alpha+rho+2;
3323
            break;
3324
//        case 3:
3325
            break;
3326
    }
3327
/*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
3328
printf("%d %d\n", s->sprite_delta[0][0][1], 0);
3329
printf("%d %d\n", s->sprite_delta[0][1][0], 0);
3330
printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
3331
printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
3332
printf("%d %d\n", s->sprite_delta[1][0][1], 0);
3333
printf("%d %d\n", s->sprite_delta[1][1][0], 0);
3334
printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
3335
    /* try to simplify the situation */ 
3336
    if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
3337
       && s->sprite_delta[0][0][1] == 0
3338
       && s->sprite_delta[0][1][0] == 0
3339
       && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
3340
       && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
3341
       && s->sprite_delta[1][0][1] == 0
3342
       && s->sprite_delta[1][1][0] == 0
3343
       && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
3344
    {
3345
        s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
3346
        s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
3347
        s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
3348
        s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
3349
        s->sprite_delta[0][0][0]= a;
3350
        s->sprite_delta[0][0][1]= 0;
3351
        s->sprite_delta[0][1][0]= 0;
3352
        s->sprite_delta[0][1][1]= a;
3353
        s->sprite_delta[1][0][0]= a;
3354
        s->sprite_delta[1][0][1]= 0;
3355
        s->sprite_delta[1][1][0]= 0;
3356
        s->sprite_delta[1][1][1]= a;
3357
        s->sprite_shift[0][0]= 0;
3358
        s->sprite_shift[0][1]= 0;
3359
        s->sprite_shift[1][0]= 0;
3360
        s->sprite_shift[1][1]= 0;
3361
        s->real_sprite_warping_points=1;
3362
    }
3363
    else
3364
        s->real_sprite_warping_points= s->num_sprite_warping_points;
3365

    
3366
//printf("%d %d %d %d\n", d[0][0], d[0][1], s->sprite_offset[0][0], s->sprite_offset[0][1]);
3367
}
3368

    
3369
/* decode mpeg4 VOP header */
3370
int mpeg4_decode_picture_header(MpegEncContext * s)
3371
{
3372
    int time_incr, startcode, state, v;
3373
    int time_increment;
3374

    
3375
 redo:
3376
    /* search next start code */
3377
    align_get_bits(&s->gb);
3378
    state = 0xff;
3379
    for(;;) {
3380
        v = get_bits(&s->gb, 8);
3381
        if (state == 0x000001) {
3382
            state = ((state << 8) | v) & 0xffffff;
3383
            startcode = state;
3384
            break;
3385
        }
3386
        state = ((state << 8) | v) & 0xffffff;
3387
        if( get_bits_count(&s->gb) > s->gb.size*8-32){
3388
            if(s->gb.size>50){
3389
                printf("no VOP startcode found, frame size was=%d\n", s->gb.size);
3390
                return -1;
3391
            }else{
3392
                printf("frame skip\n");
3393
                return FRAME_SKIPED;
3394
            }
3395
        }
3396
    }
3397
//printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
3398
    if (startcode == 0x120) { // Video Object Layer
3399
        int width, height, vo_ver_id;
3400

    
3401
        /* vol header */
3402
        skip_bits(&s->gb, 1); /* random access */
3403
        s->vo_type= get_bits(&s->gb, 8);
3404
        if (get_bits1(&s->gb) != 0) { /* is_ol_id */
3405
            vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
3406
            skip_bits(&s->gb, 3); /* vo_priority */
3407
        } else {
3408
            vo_ver_id = 1;
3409
        }
3410
//printf("vo type:%d\n",s->vo_type);
3411
        s->aspect_ratio_info= get_bits(&s->gb, 4);
3412
        if(s->aspect_ratio_info == EXTENDED_PAR){
3413
            skip_bits(&s->gb, 8); //par_width
3414
            skip_bits(&s->gb, 8); // par_height
3415
        }
3416

    
3417
        if ((s->vol_control_parameters=get_bits1(&s->gb))) { /* vol control parameter */
3418
            int chroma_format= get_bits(&s->gb, 2);
3419
            if(chroma_format!=1){
3420
                printf("illegal chroma format\n");
3421
            }
3422
            s->low_delay= get_bits1(&s->gb);
3423
            if(get_bits1(&s->gb)){ /* vbv parameters */
3424
                printf("vbv parameters not supported\n");
3425
                return -1;
3426
            }
3427
        }else{
3428
            s->low_delay=0;
3429
        }
3430

    
3431
        s->shape = get_bits(&s->gb, 2); /* vol shape */
3432
        if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
3433
        if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
3434
            printf("Gray shape not supported\n");
3435
            skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
3436
        }
3437

    
3438
        skip_bits1(&s->gb);   /* marker */
3439
        
3440
        s->time_increment_resolution = get_bits(&s->gb, 16);
3441
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
3442
        if (s->time_increment_bits < 1)
3443
            s->time_increment_bits = 1;
3444
        skip_bits1(&s->gb);   /* marker */
3445

    
3446
        if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
3447
            skip_bits(&s->gb, s->time_increment_bits);
3448
        }
3449

    
3450
        if (s->shape != BIN_ONLY_SHAPE) {
3451
            if (s->shape == RECT_SHAPE) {
3452
                skip_bits1(&s->gb);   /* marker */
3453
                width = get_bits(&s->gb, 13);
3454
                skip_bits1(&s->gb);   /* marker */
3455
                height = get_bits(&s->gb, 13);
3456
                skip_bits1(&s->gb);   /* marker */
3457
                if(width && height){ /* they should be non zero but who knows ... */
3458
                    s->width = width;
3459
                    s->height = height;
3460
//                    printf("width/height: %d %d\n", width, height);
3461
                }
3462
            }
3463
            
3464
            if(get_bits1(&s->gb)) printf("interlaced not supported\n");   /* interlaced */
3465
            if(!get_bits1(&s->gb)) printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
3466
            if (vo_ver_id == 1) {
3467
                s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
3468
            } else {
3469
                s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
3470
            }
3471
            if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
3472
            if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
3473
                if(s->vol_sprite_usage==STATIC_SPRITE){
3474
                    s->sprite_width = get_bits(&s->gb, 13);
3475
                    skip_bits1(&s->gb); /* marker */
3476
                    s->sprite_height= get_bits(&s->gb, 13);
3477
                    skip_bits1(&s->gb); /* marker */
3478
                    s->sprite_left  = get_bits(&s->gb, 13);
3479
                    skip_bits1(&s->gb); /* marker */
3480
                    s->sprite_top   = get_bits(&s->gb, 13);
3481
                    skip_bits1(&s->gb); /* marker */
3482
                }
3483
                s->num_sprite_warping_points= get_bits(&s->gb, 6);
3484
                s->sprite_warping_accuracy = get_bits(&s->gb, 2);
3485
                s->sprite_brightness_change= get_bits1(&s->gb);
3486
                if(s->vol_sprite_usage==STATIC_SPRITE)
3487
                    s->low_latency_sprite= get_bits1(&s->gb);            
3488
            }
3489
            // FIXME sadct disable bit if verid!=1 && shape not rect
3490
            
3491
            if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
3492
                s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
3493
                if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
3494
                if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
3495
            } else {
3496
                s->quant_precision = 5;
3497
            }
3498
            
3499
            // FIXME a bunch of grayscale shape things
3500

    
3501
            if(get_bits1(&s->gb)){ /* vol_quant_type */
3502
                int i, j, v;
3503
                /* load default matrixes */
3504
                for(i=0; i<64; i++){
3505
                    v= ff_mpeg4_default_intra_matrix[i];
3506
                    s->intra_matrix[i]= v;
3507
                    s->chroma_intra_matrix[i]= v;
3508
                    
3509
                    v= ff_mpeg4_default_non_intra_matrix[i];
3510
                    s->inter_matrix[i]= v;
3511
                    s->chroma_inter_matrix[i]= v;
3512
                }
3513

    
3514
                /* load custom intra matrix */
3515
                if(get_bits1(&s->gb)){
3516
                    for(i=0; i<64; i++){
3517
                        v= get_bits(&s->gb, 8);
3518
                        if(v==0) break;
3519

    
3520
                        j= zigzag_direct[i];
3521
                        s->intra_matrix[j]= v;
3522
                        s->chroma_intra_matrix[j]= v;
3523
                    }
3524
                }
3525

    
3526
                /* load custom non intra matrix */
3527
                if(get_bits1(&s->gb)){
3528
                    for(i=0; i<64; i++){
3529
                        v= get_bits(&s->gb, 8);
3530
                        if(v==0) break;
3531

    
3532
                        j= zigzag_direct[i];
3533
                        s->inter_matrix[j]= v;
3534
                        s->chroma_inter_matrix[j]= v;
3535
                    }
3536

    
3537
                    /* replicate last value */
3538
                    for(; i<64; i++){
3539
                        j= zigzag_direct[i];
3540
                        s->inter_matrix[j]= v;
3541
                        s->chroma_inter_matrix[j]= v;
3542
                    }
3543
                }
3544

    
3545
                s->dct_unquantize= s->dct_unquantize_mpeg2;
3546

    
3547
                // FIXME a bunch of grayscale shape things
3548
            }else
3549
                s->dct_unquantize= s->dct_unquantize_h263;
3550

    
3551
            if(vo_ver_id != 1)
3552
                 s->quarter_sample= get_bits1(&s->gb);
3553
            else s->quarter_sample=0;
3554

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

    
3557
            s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */
3558

    
3559
            s->data_partitioning= get_bits1(&s->gb);
3560
            if(s->data_partitioning){
3561
                s->rvlc= get_bits1(&s->gb);
3562
                if(s->rvlc){
3563
                    printf("reversible vlc not supported\n");
3564
                }
3565
            }
3566
            
3567
            if(vo_ver_id != 1) {
3568
                s->new_pred= get_bits1(&s->gb);
3569
                if(s->new_pred){
3570
                    printf("new pred not supported\n");
3571
                    skip_bits(&s->gb, 2); /* requested upstream message type */
3572
                    skip_bits1(&s->gb); /* newpred segment type */
3573
                }
3574
                s->reduced_res_vop= get_bits1(&s->gb);
3575
                if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
3576
            }
3577
            else{
3578
                s->new_pred=0;
3579
                s->reduced_res_vop= 0;
3580
            }
3581

    
3582
            s->scalability= get_bits1(&s->gb);
3583
            if (s->scalability) {
3584
                printf("scalability not supported\n");
3585
            }
3586
        }
3587
//printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
3588
        goto redo;
3589
    } else if (startcode == 0x1b2) { //userdata
3590
        char buf[256];
3591
        int i;
3592
        int e;
3593
        int ver, build;
3594

    
3595
//printf("user Data %X\n", show_bits(&s->gb, 32));
3596
        buf[0]= show_bits(&s->gb, 8);
3597
        for(i=1; i<256; i++){
3598
            buf[i]= show_bits(&s->gb, 16)&0xFF;
3599
            if(buf[i]==0) break;
3600
            skip_bits(&s->gb, 8);
3601
        }
3602
        buf[255]=0;
3603
        e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
3604
        if(e!=2)
3605
            e=sscanf(buf, "DivX%db%d", &ver, &build);
3606
        if(e==2){
3607
            s->divx_version= ver;
3608
            s->divx_build= build;
3609
            if(s->picture_number==0){
3610
                printf("This file was encoded with DivX%d Build%d\n", ver, build);
3611
                if(ver==500 && build==413){
3612
                    printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
3613
#if 0
3614
                }else{
3615
                    printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
3616
                           "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
3617
#endif
3618
                }
3619
            }
3620
        }
3621
//printf("User Data: %s\n", buf);
3622
        goto redo;
3623
    } else if (startcode != 0x1b6) { //VOP
3624
        goto redo;
3625
    }
3626

    
3627
    s->pict_type = get_bits(&s->gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
3628
//if(s->pict_type!=I_TYPE) return FRAME_SKIPED;
3629
    if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
3630
        printf("low_delay flag set, but shouldnt, clearing it\n");
3631
        s->low_delay=0;
3632
    }
3633
// printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample); 
3634
//printf("%d", s->pict_type);
3635
    time_incr=0;
3636
    while (get_bits1(&s->gb) != 0) 
3637
        time_incr++;
3638

    
3639
    check_marker(&s->gb, "before time_increment");
3640
    time_increment= get_bits(&s->gb, s->time_increment_bits);
3641
//printf(" type:%d incr:%d increment:%d\n", s->pict_type, time_incr, time_increment);
3642
    if(s->pict_type!=B_TYPE){
3643
        s->last_time_base= s->time_base;
3644
        s->time_base+= time_incr;
3645
        s->time= s->time_base*s->time_increment_resolution + time_increment;
3646
        s->pp_time= s->time - s->last_non_b_time;
3647
        s->last_non_b_time= s->time;
3648
    }else{
3649
        s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
3650
        s->bp_time= s->last_non_b_time - s->time;
3651
        if(s->pp_time <=s->bp_time){
3652
//            printf("messed up order, seeking?, skiping current b frame\n");
3653
            return FRAME_SKIPED;
3654
        }
3655
    }
3656

    
3657
    if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
3658
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
3659
        for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
3660
            if(get_bits1(&s->gb)) break;
3661
        }
3662
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
3663
    }
3664
    /* vop coded */
3665
    if (get_bits1(&s->gb) != 1)
3666
        goto redo;
3667
//printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
3668
//s->time, s->last_non_b_time[0], s->last_non_b_time[1]);  
3669
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
3670
                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
3671
        /* rounding type for motion estimation */
3672
        s->no_rounding = get_bits1(&s->gb);
3673
    } else {
3674
        s->no_rounding = 0;
3675
    }
3676
//FIXME reduced res stuff
3677

    
3678
     if (s->shape != RECT_SHAPE) {
3679
         if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
3680
             int width, height, hor_spat_ref, ver_spat_ref;
3681
 
3682
             width = get_bits(&s->gb, 13);
3683
             skip_bits1(&s->gb);   /* marker */
3684
             height = get_bits(&s->gb, 13);
3685
             skip_bits1(&s->gb);   /* marker */
3686
             hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
3687
             skip_bits1(&s->gb);   /* marker */
3688
             ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
3689
         }
3690
         skip_bits1(&s->gb); /* change_CR_disable */
3691
 
3692
         if (get_bits1(&s->gb) != 0) {
3693
             skip_bits(&s->gb, 8); /* constant_alpha_value */
3694
         }
3695
     }
3696
//FIXME complexity estimation stuff
3697
     
3698
     if (s->shape != BIN_ONLY_SHAPE) {
3699
         int t;
3700
         t=get_bits(&s->gb, 3); /* intra dc VLC threshold */
3701
//printf("threshold %d\n", t);
3702
         //FIXME interlaced specific bits
3703
     }
3704

    
3705
     if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
3706
         if(s->num_sprite_warping_points){
3707
             mpeg4_decode_sprite_trajectory(s);
3708
         }
3709
         if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
3710
         if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
3711
     }
3712

    
3713
     if (s->shape != BIN_ONLY_SHAPE) {
3714
         /* note: we do not use quant_precision to avoid problem if no
3715
            MPEG4 vol header as it is found on some old opendivx
3716
            movies */
3717
         s->qscale = get_bits(&s->gb, 5);
3718
         if(s->qscale==0){
3719
             printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
3720
             return -1; // makes no sense to continue, as there is nothing left from the image then
3721
         }
3722
  
3723
         if (s->pict_type != I_TYPE) {
3724
             s->f_code = get_bits(&s->gb, 3);        /* fcode_for */
3725
             if(s->f_code==0){
3726
                 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
3727
                 return -1; // makes no sense to continue, as the MV decoding will break very quickly
3728
             }
3729
         }
3730
         if (s->pict_type == B_TYPE) {
3731
             s->b_code = get_bits(&s->gb, 3);
3732
//printf("b-code %d\n", s->b_code);
3733
         }
3734
//printf("quant:%d fcode:%d bcode:%d type:%d\n", s->qscale, s->f_code, s->b_code, s->pict_type);
3735
         if(!s->scalability){
3736
             if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
3737
                 skip_bits1(&s->gb); // vop shape coding type
3738
             }
3739
         }
3740
     }
3741
     /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
3742
     // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
3743
     if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
3744
         printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
3745
         s->low_delay=1;
3746
     }
3747

    
3748
     s->picture_number++; // better than pic number==0 allways ;)
3749
//printf("done\n");
3750

    
3751
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
3752
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
3753

    
3754
     return 0;
3755
}
3756

    
3757
/* don't understand why they choose a different header ! */
3758
int intel_h263_decode_picture_header(MpegEncContext *s)
3759
{
3760
    int format;
3761

    
3762
    /* picture header */
3763
    if (get_bits(&s->gb, 22) != 0x20) {
3764
        fprintf(stderr, "Bad picture start code\n");
3765
        return -1;
3766
    }
3767
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3768

    
3769
    if (get_bits1(&s->gb) != 1) {
3770
        fprintf(stderr, "Bad marker\n");
3771
        return -1;        /* marker */
3772
    }
3773
    if (get_bits1(&s->gb) != 0) {
3774
        fprintf(stderr, "Bad H263 id\n");
3775
        return -1;        /* h263 id */
3776
    }
3777
    skip_bits1(&s->gb);        /* split screen off */
3778
    skip_bits1(&s->gb);        /* camera  off */
3779
    skip_bits1(&s->gb);        /* freeze picture release off */
3780

    
3781
    format = get_bits(&s->gb, 3);
3782
    if (format != 7) {
3783
        fprintf(stderr, "Intel H263 free format not supported\n");
3784
        return -1;
3785
    }
3786
    s->h263_plus = 0;
3787

    
3788
    s->pict_type = I_TYPE + get_bits1(&s->gb);
3789
    
3790
    s->unrestricted_mv = get_bits1(&s->gb); 
3791
    s->h263_long_vectors = s->unrestricted_mv;
3792

    
3793
    if (get_bits1(&s->gb) != 0) {
3794
        fprintf(stderr, "SAC not supported\n");
3795
        return -1;        /* SAC: off */
3796
    }
3797
    if (get_bits1(&s->gb) != 0) {
3798
        fprintf(stderr, "Advanced Prediction Mode not supported\n");
3799
        return -1;        /* advanced prediction mode: off */
3800
    }
3801
    if (get_bits1(&s->gb) != 0) {
3802
        fprintf(stderr, "PB frame mode no supported\n");
3803
        return -1;        /* PB frame mode */
3804
    }
3805

    
3806
    /* skip unknown header garbage */
3807
    skip_bits(&s->gb, 41);
3808

    
3809
    s->qscale = get_bits(&s->gb, 5);
3810
    skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
3811

    
3812
    /* PEI */
3813
    while (get_bits1(&s->gb) != 0) {
3814
        skip_bits(&s->gb, 8);
3815
    }
3816
    s->f_code = 1;
3817
    return 0;
3818
}
3819