Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ f56dd362

History | View | Annotate | Download (155 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, error resilience, optimizations,
22
 * qpel decoding, gmc decoding, interlaced decoding, 
23
 * by Michael Niedermayer <michaelni@gmx.at>
24
 */
25
 
26
//#define DEBUG
27
#include "common.h"
28
#include "dsputil.h"
29
#include "avcodec.h"
30
#include "mpegvideo.h"
31
#include "h263data.h"
32
#include "mpeg4data.h"
33

    
34
//#undef NDEBUG
35
//#include <assert.h>
36

    
37
#if 1
38
#define PRINT_MB_TYPE(a) {}
39
#else
40
#define PRINT_MB_TYPE(a) printf(a)
41
#endif
42

    
43
#define INTRA_MCBPC_VLC_BITS 6
44
#define INTER_MCBPC_VLC_BITS 6
45
#define CBPY_VLC_BITS 6
46
#define MV_VLC_BITS 9
47
#define DC_VLC_BITS 9
48
#define SPRITE_TRAJ_VLC_BITS 6
49
#define MB_TYPE_B_VLC_BITS 4
50
#define TEX_VLC_BITS 9
51

    
52
#ifdef CONFIG_ENCODERS
53
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
54
                              int n);
55
static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
56
static void h263p_encode_umotion(MpegEncContext * s, int val);
57
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
58
                               int n, int dc, UINT8 *scan_table, 
59
                               PutBitContext *dc_pb, PutBitContext *ac_pb);
60
#endif
61

    
62
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
63
static int h263p_decode_umotion(MpegEncContext * s, int pred);
64
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
65
                             int n, int coded);
66
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
67
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
68
                              int n, int coded, int intra);
69
static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
70
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
71
                              int dir);
72
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
73
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
74

    
75
extern UINT32 inverse[256];
76

    
77
static UINT16 uni_DCtab_lum  [512][2];
78
static UINT16 uni_DCtab_chrom[512][2];
79

    
80
#ifdef CONFIG_ENCODERS
81
static UINT16 (*mv_penalty)[MAX_MV*2+1]= NULL;
82
static UINT8 fcode_tab[MAX_MV*2+1];
83
static UINT8 umv_fcode_tab[MAX_MV*2+1];
84

    
85
static UINT32 uni_mpeg4_intra_rl_bits[64*64*2*2];
86
static UINT8  uni_mpeg4_intra_rl_len [64*64*2*2];
87
static UINT32 uni_mpeg4_inter_rl_bits[64*64*2*2];
88
static UINT8  uni_mpeg4_inter_rl_len [64*64*2*2];
89
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
90
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
91

    
92
/* mpeg4
93
inter
94
max level: 24/6
95
max run: 53/63
96

97
intra
98
max level: 53/16
99
max run: 29/41
100
*/
101
#endif
102

    
103

    
104
int h263_get_picture_format(int width, int height)
105
{
106
    int format;
107

    
108
    if (width == 128 && height == 96)
109
        format = 1;
110
    else if (width == 176 && height == 144)
111
        format = 2;
112
    else if (width == 352 && height == 288)
113
        format = 3;
114
    else if (width == 704 && height == 576)
115
        format = 4;
116
    else if (width == 1408 && height == 1152)
117
        format = 5;
118
    else
119
        format = 7;
120
    return format;
121
}
122

    
123
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
124
{
125
    int format;
126

    
127
    align_put_bits(&s->pb);
128

    
129
    /* Update the pointer to last GOB */
130
    s->ptr_lastgob = pbBufPtr(&s->pb);
131
    s->gob_number = 0;
132

    
133
    put_bits(&s->pb, 22, 0x20); /* PSC */
134
    put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / 
135
                         s->frame_rate) & 0xff);
136

    
137
    put_bits(&s->pb, 1, 1);        /* marker */
138
    put_bits(&s->pb, 1, 0);        /* h263 id */
139
    put_bits(&s->pb, 1, 0);        /* split screen off */
140
    put_bits(&s->pb, 1, 0);        /* camera  off */
141
    put_bits(&s->pb, 1, 0);        /* freeze picture release off */
142
    
143
    format = h263_get_picture_format(s->width, s->height);
144
    if (!s->h263_plus) {
145
        /* H.263v1 */
146
        put_bits(&s->pb, 3, format);
147
        put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
148
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
149
        of H.263v1 UMV implies to check the predicted MV after
150
        calculation of the current MB to see if we're on the limits */
151
        put_bits(&s->pb, 1, 0);        /* unrestricted motion vector: off */
152
        put_bits(&s->pb, 1, 0);        /* SAC: off */
153
        put_bits(&s->pb, 1, 0);        /* advanced prediction mode: off */
154
        put_bits(&s->pb, 1, 0);        /* not PB frame */
155
        put_bits(&s->pb, 5, s->qscale);
156
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
157
    } else {
158
        /* H.263v2 */
159
        /* H.263 Plus PTYPE */
160
        put_bits(&s->pb, 3, 7);
161
        put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
162
        if (format == 7)
163
            put_bits(&s->pb,3,6); /* Custom Source Format */
164
        else
165
            put_bits(&s->pb, 3, format);
166
            
167
        put_bits(&s->pb,1,0); /* Custom PCF: off */
168
        s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
169
        put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
170
        put_bits(&s->pb,1,0); /* SAC: off */
171
        put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
172
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
173
        put_bits(&s->pb,1,0); /* Deblocking Filter: off */
174
        put_bits(&s->pb,1,0); /* Slice Structured: off */
175
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
176
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
177
        put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
178
        put_bits(&s->pb,1,0); /* Modified Quantization: off */
179
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
180
        put_bits(&s->pb,3,0); /* Reserved */
181
                
182
        put_bits(&s->pb, 3, s->pict_type == P_TYPE);
183
                
184
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
185
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
186
        if (s->pict_type == I_TYPE)
187
            s->no_rounding = 0;
188
        else
189
            s->no_rounding ^= 1;
190
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
191
        put_bits(&s->pb,2,0); /* Reserved */
192
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
193
                
194
        /* This should be here if PLUSPTYPE */
195
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
196
                
197
                if (format == 7) {
198
            /* Custom Picture Format (CPFMT) */
199
                
200
            if (s->aspect_ratio_info)
201
                put_bits(&s->pb,4,s->aspect_ratio_info);
202
            else
203
                put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
204
            put_bits(&s->pb,9,(s->width >> 2) - 1);
205
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
206
            put_bits(&s->pb,9,(s->height >> 2));
207
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
208
            {
209
                put_bits(&s->pb, 8, s->aspected_width);
210
                put_bits(&s->pb, 8, s->aspected_height);
211
            }
212
        }
213
        
214
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
215
        if (s->umvplus)
216
            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
217
        put_bits(&s->pb, 5, s->qscale);
218
    }
219

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

    
222
    if(s->h263_aic){
223
         s->y_dc_scale_table= 
224
         s->c_dc_scale_table= h263_aic_dc_scale_table;
225
    }else{
226
        s->y_dc_scale_table=
227
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
228
    }
229
}
230

    
231
/**
232
 * Encodes a group of blocks header.
233
 */
234
int h263_encode_gob_header(MpegEncContext * s, int mb_line)
235
{
236
           align_put_bits(&s->pb);
237
           flush_put_bits(&s->pb);
238
           /* Call the RTP callback to send the last GOB */
239
           if (s->rtp_callback) {
240
               int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
241
               s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
242
           }
243
           put_bits(&s->pb, 17, 1); /* GBSC */
244
           s->gob_number = mb_line / s->gob_index;
245
           put_bits(&s->pb, 5, s->gob_number); /* GN */
246
           put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
247
           put_bits(&s->pb, 5, s->qscale); /* GQUANT */
248
           //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
249
    return 0;
250
}
251

    
252
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
253
{
254
    int score0=0, score1=0;
255
    int i, n;
256

    
257
    for(n=0; n<6; n++){
258
        INT16 *ac_val, *ac_val1;
259

    
260
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
261
        ac_val1= ac_val;
262
        if(dir[n]){
263
            const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
264
            /* top prediction */
265
            ac_val-= s->block_wrap[n]*16;
266
            if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
267
                /* same qscale */
268
                for(i=1; i<8; i++){
269
                    const int level= block[n][s->idct_permutation[i   ]];
270
                    score0+= ABS(level);
271
                    score1+= ABS(level - ac_val[i+8]);
272
                    ac_val1[i  ]=    block[n][s->idct_permutation[i<<3]];
273
                    ac_val1[i+8]= level;
274
                }
275
            }else{
276
                /* different qscale, we must rescale */
277
                for(i=1; i<8; i++){
278
                    const int level= block[n][s->idct_permutation[i   ]];
279
                    score0+= ABS(level);
280
                    score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale));
281
                    ac_val1[i  ]=    block[n][s->idct_permutation[i<<3]];
282
                    ac_val1[i+8]= level;
283
                }
284
            }
285
        }else{
286
            const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
287
            /* left prediction */
288
            ac_val-= 16;
289
            if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
290
                /* same qscale */
291
                for(i=1; i<8; i++){
292
                    const int level= block[n][s->idct_permutation[i<<3]];
293
                    score0+= ABS(level);
294
                    score1+= ABS(level - ac_val[i]);
295
                    ac_val1[i  ]= level;
296
                    ac_val1[i+8]=    block[n][s->idct_permutation[i   ]];
297
                }
298
            }else{
299
                /* different qscale, we must rescale */
300
                for(i=1; i<8; i++){
301
                    const int level= block[n][s->idct_permutation[i<<3]];
302
                    score0+= ABS(level);
303
                    score1+= ABS(level - ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale));
304
                    ac_val1[i  ]= level;
305
                    ac_val1[i+8]=    block[n][s->idct_permutation[i   ]];
306
                }
307
            }
308
        }
309
    }
310

    
311
    return score0 > score1 ? 1 : 0;    
312
}
313

    
314
/**
315
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
316
 */
317
void ff_clean_h263_qscales(MpegEncContext *s){
318
    int i;
319
    
320
    for(i=1; i<s->mb_num; i++){
321
        if(s->qscale_table[i] - s->qscale_table[i-1] >2)
322
            s->qscale_table[i]= s->qscale_table[i-1]+2;
323
    }
324
    for(i=s->mb_num-2; i>=0; i--){
325
        if(s->qscale_table[i] - s->qscale_table[i+1] >2)
326
            s->qscale_table[i]= s->qscale_table[i+1]+2;
327
    }
328
}
329

    
330
/**
331
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
332
 */
333
void ff_clean_mpeg4_qscales(MpegEncContext *s){
334
    int i;
335
    
336
    ff_clean_h263_qscales(s);
337
    
338
    for(i=1; i<s->mb_num; i++){
339
        if(s->qscale_table[i] != s->qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_INTER4V)){
340
            s->mb_type[i]&= ~MB_TYPE_INTER4V;
341
            s->mb_type[i]|= MB_TYPE_INTER;
342
        }
343
    }
344

    
345
    if(s->pict_type== B_TYPE){
346
        int odd=0;
347
        /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
348
           for the actual adaptive quantization */
349
        
350
        for(i=0; i<s->mb_num; i++){
351
            odd += s->qscale_table[i]&1;
352
        }
353
        
354
        if(2*odd > s->mb_num) odd=1;
355
        else                  odd=0;
356
        
357
        for(i=0; i<s->mb_num; i++){
358
            if((s->qscale_table[i]&1) != odd)
359
                s->qscale_table[i]++;
360
            if(s->qscale_table[i] > 31)
361
                s->qscale_table[i]= 31;
362
        }            
363
    
364
        for(i=1; i<s->mb_num; i++){
365
            if(s->qscale_table[i] != s->qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_DIRECT)){
366
                s->mb_type[i]&= ~MB_TYPE_DIRECT;
367
                s->mb_type[i]|= MB_TYPE_BIDIR;
368
            }
369
        }
370
    }
371
}
372

    
373
#ifdef CONFIG_ENCODERS
374
void mpeg4_encode_mb(MpegEncContext * s,
375
                    DCTELEM block[6][64],
376
                    int motion_x, int motion_y)
377
{
378
    int cbpc, cbpy, i, pred_x, pred_y;
379
    int bits;
380
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
381
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
382
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
383
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
384
    const int dquant_code[5]= {1,0,9,2,3};
385
    
386
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
387
    if (!s->mb_intra) {
388
        /* compute cbp */
389
        int cbp = 0;
390
        for (i = 0; i < 6; i++) {
391
            if (s->block_last_index[i] >= 0)
392
                cbp |= 1 << (5 - i);
393
        }
394

    
395
        if(s->pict_type==B_TYPE){
396
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
397
            int mb_type=  mb_type_table[s->mv_dir];
398
            
399
            if(s->mb_x==0){
400
                s->last_mv[0][0][0]= 
401
                s->last_mv[0][0][1]= 
402
                s->last_mv[1][0][0]= 
403
                s->last_mv[1][0][1]= 0;
404
            }
405
            
406
            assert(s->dquant>=-2 && s->dquant<=2);
407
            assert((s->dquant&1)==0);
408
            assert(mb_type>=0);
409

    
410
            /* nothing to do if this MB was skiped in the next P Frame */
411
            if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){ //FIXME avoid DCT & ...
412
                s->skip_count++;
413
                s->mv[0][0][0]= 
414
                s->mv[0][0][1]= 
415
                s->mv[1][0][0]= 
416
                s->mv[1][0][1]= 0;
417
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
418
                s->qscale -= s->dquant;
419
                return;
420
            }
421

    
422
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
423
                /* direct MB with MV={0,0} */
424
                assert(s->dquant==0);
425
                
426
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
427

    
428
                if(interleaved_stats){
429
                    s->misc_bits++;
430
                    s->last_bits++;
431
                }
432
                s->skip_count++;
433
                return;
434
            }
435
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
436
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
437
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
438
            if(cbp) put_bits(&s->pb, 6, cbp);
439
            
440
            if(cbp && mb_type){
441
                if(s->dquant)
442
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
443
                else
444
                    put_bits(&s->pb, 1, 0);
445
            }else
446
                s->qscale -= s->dquant;
447
            
448
            if(!s->progressive_sequence){
449
                if(cbp)
450
                    put_bits(&s->pb, 1, s->interlaced_dct);
451
                if(mb_type) // not diect mode
452
                    put_bits(&s->pb, 1, 0); // no interlaced ME yet
453
            }
454

    
455
            if(interleaved_stats){
456
                bits= get_bit_count(&s->pb);
457
                s->misc_bits+= bits - s->last_bits;
458
                s->last_bits=bits;
459
            }
460

    
461
            switch(mb_type)
462
            {
463
            case 0: /* direct */
464
                h263_encode_motion(s, motion_x, 1);
465
                h263_encode_motion(s, motion_y, 1);                
466
                s->b_count++;
467
                s->f_count++;
468
                break;
469
            case 1: /* bidir */
470
                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
471
                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
472
                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
473
                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
474
                s->last_mv[0][0][0]= s->mv[0][0][0];
475
                s->last_mv[0][0][1]= s->mv[0][0][1];
476
                s->last_mv[1][0][0]= s->mv[1][0][0];
477
                s->last_mv[1][0][1]= s->mv[1][0][1];
478
                s->b_count++;
479
                s->f_count++;
480
                break;
481
            case 2: /* backward */
482
                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
483
                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
484
                s->last_mv[1][0][0]= motion_x;
485
                s->last_mv[1][0][1]= motion_y;
486
                s->b_count++;
487
                break;
488
            case 3: /* forward */
489
                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
490
                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
491
                s->last_mv[0][0][0]= motion_x;
492
                s->last_mv[0][0][1]= motion_y;
493
                s->f_count++;
494
                break;
495
            default:
496
                printf("unknown mb type\n");
497
                return;
498
            }
499

    
500
            if(interleaved_stats){
501
                bits= get_bit_count(&s->pb);
502
                s->mv_bits+= bits - s->last_bits;
503
                s->last_bits=bits;
504
            }
505

    
506
            /* encode each block */
507
            for (i = 0; i < 6; i++) {
508
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
509
            }
510

    
511
            if(interleaved_stats){
512
                bits= get_bit_count(&s->pb);
513
                s->p_tex_bits+= bits - s->last_bits;
514
                s->last_bits=bits;
515
            }
516
        }else{ /* s->pict_type==B_TYPE */
517
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
518
                /* check if the B frames can skip it too, as we must skip it if we skip here 
519
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
520
                if(s->max_b_frames>0){
521
                    int i;
522
                    int x,y, offset;
523
                    uint8_t *p_pic;
524

    
525
                    x= s->mb_x*16;
526
                    y= s->mb_y*16;
527
                    if(x+16 > s->width)  x= s->width-16;
528
                    if(y+16 > s->height) y= s->height-16;
529

    
530
                    offset= x + y*s->linesize;
531
                    p_pic= s->new_picture[0] + offset;
532
                    
533
                    s->mb_skiped=1;
534
                    for(i=0; i<s->max_b_frames; i++){
535
                        uint8_t *b_pic;
536
                        int diff;
537

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

    
540
                        b_pic= s->coded_order[i+1].picture[0] + offset;
541
                        diff= pix_abs16x16(p_pic, b_pic, s->linesize);
542
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
543
                            s->mb_skiped=0;
544
                            break;
545
                        }
546
                    }
547
                }else
548
                    s->mb_skiped=1; 
549

    
550
                if(s->mb_skiped==1){
551
                    /* skip macroblock */
552
                    put_bits(&s->pb, 1, 1);
553

    
554
                    if(interleaved_stats){
555
                        s->misc_bits++;
556
                        s->last_bits++;
557
                    }
558
                    s->skip_count++;
559
                    return;
560
                }
561
            }
562

    
563
            put_bits(&s->pb, 1, 0);        /* mb coded */
564
            if(s->mv_type==MV_TYPE_16X16){
565
                cbpc = cbp & 3;
566
                if(s->dquant) cbpc+= 8;
567
                put_bits(&s->pb,
568
                        inter_MCBPC_bits[cbpc],
569
                        inter_MCBPC_code[cbpc]);
570

    
571
                cbpy = cbp >> 2;
572
                cbpy ^= 0xf;
573
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
574
                if(s->dquant)
575
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
576

    
577
                if(!s->progressive_sequence){
578
                    if(cbp)
579
                        put_bits(pb2, 1, s->interlaced_dct);
580
                    put_bits(pb2, 1, 0); // no interlaced ME yet
581
                }
582
                    
583
                if(interleaved_stats){
584
                    bits= get_bit_count(&s->pb);
585
                    s->misc_bits+= bits - s->last_bits;
586
                    s->last_bits=bits;
587
                }
588

    
589
                /* motion vectors: 16x16 mode */
590
                h263_pred_motion(s, 0, &pred_x, &pred_y);
591
            
592
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
593
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
594
            }else{
595
                cbpc = (cbp & 3)+16;
596
                put_bits(&s->pb,
597
                        inter_MCBPC_bits[cbpc],
598
                        inter_MCBPC_code[cbpc]);
599
                cbpy = cbp >> 2;
600
                cbpy ^= 0xf;
601
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
602

    
603
                if(!s->progressive_sequence){
604
                    if(cbp)
605
                        put_bits(pb2, 1, s->interlaced_dct);
606
                }
607
    
608
                if(interleaved_stats){
609
                    bits= get_bit_count(&s->pb);
610
                    s->misc_bits+= bits - s->last_bits;
611
                    s->last_bits=bits;
612
                }
613

    
614
                for(i=0; i<4; i++){
615
                    /* motion vectors: 8x8 mode*/
616
                    h263_pred_motion(s, i, &pred_x, &pred_y);
617

    
618
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
619
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
620
                }
621
            }
622

    
623
            if(interleaved_stats){ 
624
                bits= get_bit_count(&s->pb);
625
                s->mv_bits+= bits - s->last_bits;
626
                s->last_bits=bits;
627
            }
628

    
629
            /* encode each block */
630
            for (i = 0; i < 6; i++) {
631
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
632
            }
633

    
634
            if(interleaved_stats){
635
                bits= get_bit_count(&s->pb);
636
                s->p_tex_bits+= bits - s->last_bits;
637
                s->last_bits=bits;
638
            }
639
            s->f_count++;
640
        }
641
    } else {
642
        int cbp;
643
        int dc_diff[6];   //dc values with the dc prediction subtracted 
644
        int dir[6];  //prediction direction
645
        int zigzag_last_index[6];
646
        UINT8 *scan_table[6];
647

    
648
        for(i=0; i<6; i++){
649
            const int level= block[i][0];
650
            UINT16 *dc_ptr;
651

    
652
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
653
            if (i < 4) {
654
                *dc_ptr = level * s->y_dc_scale;
655
            } else {
656
                *dc_ptr = level * s->c_dc_scale;
657
            }
658
        }
659

    
660
        s->ac_pred= decide_ac_pred(s, block, dir);
661

    
662
        if(s->ac_pred){
663
            for(i=0; i<6; i++){
664
                UINT8 *st;
665
                int last_index;
666

    
667
                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
668
                if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
669
                else           st = s->intra_h_scantable.permutated; /* top */
670

    
671
                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
672
                    if(block[i][st[last_index]]) break;
673
                zigzag_last_index[i]= s->block_last_index[i];
674
                s->block_last_index[i]= last_index;
675
                scan_table[i]= st;
676
            }
677
        }else{
678
            for(i=0; i<6; i++)
679
                scan_table[i]= s->intra_scantable.permutated;
680
        }
681

    
682
        /* compute cbp */
683
        cbp = 0;
684
        for (i = 0; i < 6; i++) {
685
            if (s->block_last_index[i] >= 1)
686
                cbp |= 1 << (5 - i);
687
        }
688

    
689
        cbpc = cbp & 3;
690
        if (s->pict_type == I_TYPE) {
691
            if(s->dquant) cbpc+=4;
692
            put_bits(&s->pb,
693
                intra_MCBPC_bits[cbpc],
694
                intra_MCBPC_code[cbpc]);
695
        } else {
696
            if(s->dquant) cbpc+=8;
697
            put_bits(&s->pb, 1, 0);        /* mb coded */
698
            put_bits(&s->pb,
699
                inter_MCBPC_bits[cbpc + 4],
700
                inter_MCBPC_code[cbpc + 4]);
701
        }
702
        put_bits(pb2, 1, s->ac_pred);
703
        cbpy = cbp >> 2;
704
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
705
        if(s->dquant)
706
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
707

    
708
        if(!s->progressive_sequence){
709
            put_bits(dc_pb, 1, s->interlaced_dct);
710
        }
711

    
712
        if(interleaved_stats){
713
            bits= get_bit_count(&s->pb);
714
            s->misc_bits+= bits - s->last_bits;
715
            s->last_bits=bits;
716
        }
717

    
718
        /* encode each block */
719
        for (i = 0; i < 6; i++) {
720
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
721
        }
722

    
723
        if(interleaved_stats){
724
            bits= get_bit_count(&s->pb);
725
            s->i_tex_bits+= bits - s->last_bits;
726
            s->last_bits=bits;
727
        }
728
        s->i_count++;
729

    
730
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
731
        if(s->ac_pred){
732
            for(i=0; i<6; i++){
733
                int j;    
734
                INT16 *ac_val;
735

    
736
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
737

    
738
                if(dir[i]){
739
                    for(j=1; j<8; j++) 
740
                        block[i][s->idct_permutation[j   ]]= ac_val[j+8];
741
                }else{
742
                    for(j=1; j<8; j++) 
743
                        block[i][s->idct_permutation[j<<3]]= ac_val[j  ];
744
                }
745
                s->block_last_index[i]= zigzag_last_index[i];
746
            }
747
        }
748
    }
749
}
750

    
751
void h263_encode_mb(MpegEncContext * s,
752
                    DCTELEM block[6][64],
753
                    int motion_x, int motion_y)
754
{
755
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
756
    INT16 pred_dc;
757
    INT16 rec_intradc[6];
758
    UINT16 *dc_ptr[6];
759
    const int dquant_code[5]= {1,0,9,2,3};
760
           
761
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
762
    if (!s->mb_intra) {
763
        /* compute cbp */
764
        cbp = 0;
765
        for (i = 0; i < 6; i++) {
766
            if (s->block_last_index[i] >= 0)
767
                cbp |= 1 << (5 - i);
768
        }
769
        if ((cbp | motion_x | motion_y | s->dquant) == 0) {
770
            /* skip macroblock */
771
            put_bits(&s->pb, 1, 1);
772
            return;
773
        }
774
        put_bits(&s->pb, 1, 0);        /* mb coded */
775
        cbpc = cbp & 3;
776
        if(s->dquant) cbpc+= 8;
777
        put_bits(&s->pb,
778
                    inter_MCBPC_bits[cbpc],
779
                    inter_MCBPC_code[cbpc]);
780
        cbpy = cbp >> 2;
781
        cbpy ^= 0xf;
782
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
783
        if(s->dquant)
784
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
785

    
786
        /* motion vectors: 16x16 mode only now */
787
        h263_pred_motion(s, 0, &pred_x, &pred_y);
788
      
789
        if (!s->umvplus) {  
790
            h263_encode_motion(s, motion_x - pred_x, s->f_code);
791
            h263_encode_motion(s, motion_y - pred_y, s->f_code);
792
        }
793
        else {
794
            h263p_encode_umotion(s, motion_x - pred_x);
795
            h263p_encode_umotion(s, motion_y - pred_y);
796
            if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
797
                /* To prevent Start Code emulation */
798
                put_bits(&s->pb,1,1);
799
        }
800
    } else {
801
        int li = s->h263_aic ? 0 : 1;
802
        
803
        cbp = 0;
804
        for(i=0; i<6; i++) {
805
            /* Predict DC */
806
            if (s->h263_aic && s->mb_intra) {
807
                INT16 level = block[i][0];
808
            
809
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
810
                level -= pred_dc;
811
                /* Quant */
812
                if (level < 0)
813
                    level = (level + (s->qscale >> 1))/(s->y_dc_scale);
814
                else
815
                    level = (level - (s->qscale >> 1))/(s->y_dc_scale);
816
                    
817
                /* AIC can change CBP */
818
                if (level == 0 && s->block_last_index[i] == 0)
819
                    s->block_last_index[i] = -1;
820
                else if (level < -127)
821
                    level = -127;
822
                else if (level > 127)
823
                    level = 127;
824
                
825
                block[i][0] = level;
826
                /* Reconstruction */ 
827
                rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
828
                /* Oddify */
829
                rec_intradc[i] |= 1;
830
                //if ((rec_intradc[i] % 2) == 0)
831
                //    rec_intradc[i]++;
832
                /* Clipping */
833
                if (rec_intradc[i] < 0)
834
                    rec_intradc[i] = 0;
835
                else if (rec_intradc[i] > 2047)
836
                    rec_intradc[i] = 2047;
837
                                
838
                /* Update AC/DC tables */
839
                *dc_ptr[i] = rec_intradc[i];
840
            }
841
            /* compute cbp */
842
            if (s->block_last_index[i] >= li)
843
                cbp |= 1 << (5 - i);
844
        }
845

    
846
        cbpc = cbp & 3;
847
        if (s->pict_type == I_TYPE) {
848
            if(s->dquant) cbpc+=4;
849
            put_bits(&s->pb,
850
                intra_MCBPC_bits[cbpc],
851
                intra_MCBPC_code[cbpc]);
852
        } else {
853
            if(s->dquant) cbpc+=8;
854
            put_bits(&s->pb, 1, 0);        /* mb coded */
855
            put_bits(&s->pb,
856
                inter_MCBPC_bits[cbpc + 4],
857
                inter_MCBPC_code[cbpc + 4]);
858
        }
859
        if (s->h263_aic) {
860
            /* XXX: currently, we do not try to use ac prediction */
861
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
862
        }
863
        cbpy = cbp >> 2;
864
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
865
        if(s->dquant)
866
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
867
    }
868

    
869
    for(i=0; i<6; i++) {
870
        /* encode each block */
871
        h263_encode_block(s, block[i], i);
872
    
873
        /* Update INTRADC for decoding */
874
        if (s->h263_aic && s->mb_intra) {
875
            block[i][0] = rec_intradc[i];
876
            
877
        }
878
    }
879
}
880
#endif
881

    
882
static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
883
{
884
    int x, y, wrap, a, c, pred_dc, scale;
885
    INT16 *dc_val, *ac_val;
886

    
887
    /* find prediction */
888
    if (n < 4) {
889
        x = 2 * s->mb_x + 1 + (n & 1);
890
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
891
        wrap = s->mb_width * 2 + 2;
892
        dc_val = s->dc_val[0];
893
        ac_val = s->ac_val[0][0];
894
        scale = s->y_dc_scale;
895
    } else {
896
        x = s->mb_x + 1;
897
        y = s->mb_y + 1;
898
        wrap = s->mb_width + 2;
899
        dc_val = s->dc_val[n - 4 + 1];
900
        ac_val = s->ac_val[n - 4 + 1][0];
901
        scale = s->c_dc_scale;
902
    }
903
    /* B C
904
     * A X 
905
     */
906
    a = dc_val[(x - 1) + (y) * wrap];
907
    c = dc_val[(x) + (y - 1) * wrap];
908
    
909
    /* No prediction outside GOB boundary */
910
    if (s->first_slice_line && ((n < 2) || (n > 3)))
911
        c = 1024;
912
    pred_dc = 1024;
913
    /* just DC prediction */
914
    if (a != 1024 && c != 1024)
915
        pred_dc = (a + c) >> 1;
916
    else if (a != 1024)
917
        pred_dc = a;
918
    else
919
        pred_dc = c;
920
    
921
    /* we assume pred is positive */
922
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
923
    *dc_val_ptr = &dc_val[x + y * wrap];
924
    return pred_dc;
925
}
926

    
927

    
928
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
929
{
930
    int x, y, wrap, a, c, pred_dc, scale, i;
931
    INT16 *dc_val, *ac_val, *ac_val1;
932

    
933
    /* find prediction */
934
    if (n < 4) {
935
        x = 2 * s->mb_x + 1 + (n & 1);
936
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
937
        wrap = s->mb_width * 2 + 2;
938
        dc_val = s->dc_val[0];
939
        ac_val = s->ac_val[0][0];
940
        scale = s->y_dc_scale;
941
    } else {
942
        x = s->mb_x + 1;
943
        y = s->mb_y + 1;
944
        wrap = s->mb_width + 2;
945
        dc_val = s->dc_val[n - 4 + 1];
946
        ac_val = s->ac_val[n - 4 + 1][0];
947
        scale = s->c_dc_scale;
948
    }
949
    
950
    ac_val += ((y) * wrap + (x)) * 16;
951
    ac_val1 = ac_val;
952
    
953
    /* B C
954
     * A X 
955
     */
956
    a = dc_val[(x - 1) + (y) * wrap];
957
    c = dc_val[(x) + (y - 1) * wrap];
958
    
959
    /* No prediction outside GOB boundary */
960
    if (s->first_slice_line && ((n < 2) || (n > 3)))
961
        c = 1024;
962
    pred_dc = 1024;
963
    if (s->ac_pred) {
964
        if (s->h263_aic_dir) {
965
            /* left prediction */
966
            if (a != 1024) {
967
                ac_val -= 16;
968
                for(i=1;i<8;i++) {
969
                    block[s->idct_permutation[i<<3]] += ac_val[i];
970
                }
971
                pred_dc = a;
972
            }
973
        } else {
974
            /* top prediction */
975
            if (c != 1024) {
976
                ac_val -= 16 * wrap;
977
                for(i=1;i<8;i++) {
978
                    block[s->idct_permutation[i   ]] += ac_val[i + 8];
979
                }
980
                pred_dc = c;
981
            }
982
        }
983
    } else {
984
        /* just DC prediction */
985
        if (a != 1024 && c != 1024)
986
            pred_dc = (a + c) >> 1;
987
        else if (a != 1024)
988
            pred_dc = a;
989
        else
990
            pred_dc = c;
991
    }
992
    
993
    /* we assume pred is positive */
994
    block[0]=block[0]*scale + pred_dc;
995
    
996
    if (block[0] < 0)
997
        block[0] = 0;
998
    else if (!(block[0] & 1))
999
        block[0]++;
1000
    
1001
    /* Update AC/DC tables */
1002
    dc_val[(x) + (y) * wrap] = block[0];
1003
    
1004
    /* left copy */
1005
    for(i=1;i<8;i++)
1006
        ac_val1[i    ] = block[s->idct_permutation[i<<3]];
1007
    /* top copy */
1008
    for(i=1;i<8;i++)
1009
        ac_val1[8 + i] = block[s->idct_permutation[i   ]];
1010
}
1011

    
1012
INT16 *h263_pred_motion(MpegEncContext * s, int block, 
1013
                        int *px, int *py)
1014
{
1015
    int xy, wrap;
1016
    INT16 *A, *B, *C, *mot_val;
1017
    static const int off[4]= {2, 1, 1, -1};
1018

    
1019
    wrap = s->block_wrap[0];
1020
    xy = s->block_index[block];
1021

    
1022
    mot_val = s->motion_val[xy];
1023

    
1024
    A = s->motion_val[xy - 1];
1025
    /* special case for first (slice) line */
1026
    if (s->first_slice_line && block<3) {
1027
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1028
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1029
        if(block==0){ //most common case
1030
            if(s->mb_x  == s->resync_mb_x){ //rare
1031
                *px= *py = 0;
1032
            }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1033
                C = s->motion_val[xy + off[block] - wrap];
1034
                if(s->mb_x==0){
1035
                    *px = C[0];
1036
                    *py = C[1];
1037
                }else{
1038
                    *px = mid_pred(A[0], 0, C[0]);
1039
                    *py = mid_pred(A[1], 0, C[1]);
1040
                }
1041
            }else{
1042
                *px = A[0];
1043
                *py = A[1];
1044
            }
1045
        }else if(block==1){
1046
            if(s->mb_x + 1 == s->resync_mb_x){ //rare
1047
                C = s->motion_val[xy + off[block] - wrap];
1048
                *px = mid_pred(A[0], 0, C[0]);
1049
                *py = mid_pred(A[1], 0, C[1]);
1050
            }else{
1051
                *px = A[0];
1052
                *py = A[1];
1053
            }
1054
        }else{ /* block==2*/
1055
            B = s->motion_val[xy - wrap];
1056
            C = s->motion_val[xy + off[block] - wrap];
1057
            if(s->mb_x == s->resync_mb_x) //rare
1058
                A[0]=A[1]=0;
1059
    
1060
            *px = mid_pred(A[0], B[0], C[0]);
1061
            *py = mid_pred(A[1], B[1], C[1]);
1062
        }
1063
    } else {
1064
        B = s->motion_val[xy - wrap];
1065
        C = s->motion_val[xy + off[block] - wrap];
1066
        *px = mid_pred(A[0], B[0], C[0]);
1067
        *py = mid_pred(A[1], B[1], C[1]);
1068
    }
1069
    return mot_val;
1070
}
1071

    
1072
#ifdef CONFIG_ENCODERS
1073
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1074
{
1075
    int range, l, bit_size, sign, code, bits;
1076

    
1077
    if (val == 0) {
1078
        /* zero vector */
1079
        code = 0;
1080
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1081
    } else {
1082
        bit_size = f_code - 1;
1083
        range = 1 << bit_size;
1084
        /* modulo encoding */
1085
        l = range * 32;
1086
#if 1
1087
        val+= l;
1088
        val&= 2*l-1;
1089
        val-= l;
1090
        sign = val>>31;
1091
        val= (val^sign)-sign;
1092
        sign&=1;
1093
#else
1094
        if (val < -l) {
1095
            val += 2*l;
1096
        } else if (val >= l) {
1097
            val -= 2*l;
1098
        }
1099

    
1100
        assert(val>=-l && val<l);
1101

    
1102
        if (val >= 0) {
1103
            sign = 0;
1104
        } else {
1105
            val = -val;
1106
            sign = 1;
1107
        }
1108
#endif
1109
        val--;
1110
        code = (val >> bit_size) + 1;
1111
        bits = val & (range - 1);
1112

    
1113
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1114
        if (bit_size > 0) {
1115
            put_bits(&s->pb, bit_size, bits);
1116
        }
1117
    }
1118

    
1119
}
1120

    
1121
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1122
static void h263p_encode_umotion(MpegEncContext * s, int val)
1123
{
1124
    short sval = 0; 
1125
    short i = 0;
1126
    short n_bits = 0;
1127
    short temp_val;
1128
    int code = 0;
1129
    int tcode;
1130
    
1131
    if ( val == 0)
1132
        put_bits(&s->pb, 1, 1);
1133
    else if (val == 1)
1134
        put_bits(&s->pb, 3, 0);
1135
    else if (val == -1)
1136
        put_bits(&s->pb, 3, 2);
1137
    else {
1138
        
1139
        sval = ((val < 0) ? (short)(-val):(short)val);
1140
        temp_val = sval;
1141
        
1142
        while (temp_val != 0) {
1143
            temp_val = temp_val >> 1;
1144
            n_bits++;
1145
        }
1146
        
1147
        i = n_bits - 1;
1148
        while (i > 0) {
1149
            tcode = (sval & (1 << (i-1))) >> (i-1);
1150
            tcode = (tcode << 1) | 1;
1151
            code = (code << 2) | tcode;
1152
            i--;
1153
        }
1154
        code = ((code << 1) | (val < 0)) << 1;
1155
        put_bits(&s->pb, (2*n_bits)+1, code);
1156
        //printf("\nVal = %d\tCode = %d", sval, code);
1157
    }
1158
}
1159

    
1160
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1161
{
1162
    int f_code;
1163
    int mv;
1164
    
1165
    if(mv_penalty==NULL)
1166
        mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1167
    
1168
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1169
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1170
            int len;
1171

    
1172
            if(mv==0) len= mvtab[0][1];
1173
            else{
1174
                int val, bit_size, range, code;
1175

    
1176
                bit_size = s->f_code - 1;
1177
                range = 1 << bit_size;
1178

    
1179
                val=mv;
1180
                if (val < 0) 
1181
                    val = -val;
1182
                val--;
1183
                code = (val >> bit_size) + 1;
1184
                if(code<33){
1185
                    len= mvtab[code][1] + 1 + bit_size;
1186
                }else{
1187
                    len= mvtab[32][1] + 2 + bit_size;
1188
                }
1189
            }
1190

    
1191
            mv_penalty[f_code][mv+MAX_MV]= len;
1192
        }
1193
    }
1194

    
1195
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1196
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1197
            fcode_tab[mv+MAX_MV]= f_code;
1198
        }
1199
    }
1200

    
1201
    for(mv=0; mv<MAX_MV*2+1; mv++){
1202
        umv_fcode_tab[mv]= 1;
1203
    }
1204
}
1205
#endif
1206

    
1207
static void init_uni_dc_tab(void)
1208
{
1209
    int level, uni_code, uni_len;
1210

    
1211
    for(level=-256; level<256; level++){
1212
        int size, v, l;
1213
        /* find number of bits */
1214
        size = 0;
1215
        v = abs(level);
1216
        while (v) {
1217
            v >>= 1;
1218
            size++;
1219
        }
1220

    
1221
        if (level < 0)
1222
            l= (-level) ^ ((1 << size) - 1);
1223
        else
1224
            l= level;
1225

    
1226
        /* luminance */
1227
        uni_code= DCtab_lum[size][0];
1228
        uni_len = DCtab_lum[size][1];
1229

    
1230
        if (size > 0) {
1231
            uni_code<<=size; uni_code|=l;
1232
            uni_len+=size;
1233
            if (size > 8){
1234
                uni_code<<=1; uni_code|=1;
1235
                uni_len++;
1236
            }
1237
        }
1238
        uni_DCtab_lum[level+256][0]= uni_code;
1239
        uni_DCtab_lum[level+256][1]= uni_len;
1240

    
1241
        /* chrominance */
1242
        uni_code= DCtab_chrom[size][0];
1243
        uni_len = DCtab_chrom[size][1];
1244
        
1245
        if (size > 0) {
1246
            uni_code<<=size; uni_code|=l;
1247
            uni_len+=size;
1248
            if (size > 8){
1249
                uni_code<<=1; uni_code|=1;
1250
                uni_len++;
1251
            }
1252
        }
1253
        uni_DCtab_chrom[level+256][0]= uni_code;
1254
        uni_DCtab_chrom[level+256][1]= uni_len;
1255

    
1256
    }
1257
}
1258

    
1259
#ifdef CONFIG_ENCODERS
1260
static void init_uni_mpeg4_rl_tab(RLTable *rl, UINT32 *bits_tab, UINT8 *len_tab){
1261
    int slevel, run, last;
1262
    
1263
    assert(MAX_LEVEL >= 64);
1264
    assert(MAX_RUN   >= 63);
1265

    
1266
    for(slevel=-64; slevel<64; slevel++){
1267
        if(slevel==0) continue;
1268
        for(run=0; run<64; run++){
1269
            for(last=0; last<=1; last++){
1270
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1271
                int level= slevel < 0 ? -slevel : slevel;
1272
                int sign= slevel < 0 ? 1 : 0;
1273
                int bits, len, code;
1274
                int level1, run1;
1275
                
1276
                len_tab[index]= 100;
1277
                     
1278
                /* ESC0 */
1279
                code= get_rl_index(rl, last, run, level);
1280
                bits= rl->table_vlc[code][0];
1281
                len=  rl->table_vlc[code][1];
1282
                bits=bits*2+sign; len++;
1283
                
1284
                if(code!=rl->n && len < len_tab[index]){
1285
                    bits_tab[index]= bits;
1286
                    len_tab [index]= len;
1287
                }
1288
#if 1
1289
                /* ESC1 */
1290
                bits= rl->table_vlc[rl->n][0];
1291
                len=  rl->table_vlc[rl->n][1];
1292
                bits=bits*2;    len++; //esc1
1293
                level1= level - rl->max_level[last][run];
1294
                if(level1>0){
1295
                    code= get_rl_index(rl, last, run, level1);
1296
                    bits<<= rl->table_vlc[code][1];
1297
                    len  += rl->table_vlc[code][1];
1298
                    bits += rl->table_vlc[code][0];
1299
                    bits=bits*2+sign; len++;
1300
                
1301
                    if(code!=rl->n && len < len_tab[index]){
1302
                        bits_tab[index]= bits;
1303
                        len_tab [index]= len;
1304
                    }
1305
                }
1306
#endif 
1307
#if 1
1308
                /* ESC2 */
1309
                bits= rl->table_vlc[rl->n][0];
1310
                len=  rl->table_vlc[rl->n][1];
1311
                bits=bits*4+2;    len+=2; //esc2
1312
                run1 = run - rl->max_run[last][level] - 1;
1313
                if(run1>=0){
1314
                    code= get_rl_index(rl, last, run1, level);
1315
                    bits<<= rl->table_vlc[code][1];
1316
                    len  += rl->table_vlc[code][1];
1317
                    bits += rl->table_vlc[code][0];
1318
                    bits=bits*2+sign; len++;
1319
                
1320
                    if(code!=rl->n && len < len_tab[index]){
1321
                        bits_tab[index]= bits;
1322
                        len_tab [index]= len;
1323
                    }
1324
                }
1325
#endif           
1326
                /* ESC3 */        
1327
                bits= rl->table_vlc[rl->n][0];
1328
                len = rl->table_vlc[rl->n][1];
1329
                bits=bits*4+3;    len+=2; //esc3
1330
                bits=bits*2+last; len++;
1331
                bits=bits*64+run; len+=6;
1332
                bits=bits*2+1;    len++;  //marker
1333
                bits=bits*4096+(slevel&0xfff); len+=12;
1334
                bits=bits*2+1;    len++;  //marker
1335
                
1336
                if(len < len_tab[index]){
1337
                    bits_tab[index]= bits;
1338
                    len_tab [index]= len;
1339
                }
1340
            }
1341
        }
1342
    }
1343
}
1344

    
1345
void h263_encode_init(MpegEncContext *s)
1346
{
1347
    static int done = 0;
1348

    
1349
    if (!done) {
1350
        done = 1;
1351

    
1352
        init_uni_dc_tab();
1353

    
1354
        init_rl(&rl_inter);
1355
        init_rl(&rl_intra);
1356
        init_rl(&rl_intra_aic);
1357
        
1358
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1359
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1360

    
1361
        init_mv_penalty_and_fcode(s);
1362
    }
1363
    s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1364
    
1365
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1366
    switch(s->codec_id){
1367
    case CODEC_ID_MPEG4:
1368
        s->fcode_tab= fcode_tab;
1369
        s->min_qcoeff= -2048;
1370
        s->max_qcoeff=  2047;
1371
        break;
1372
    case CODEC_ID_H263P:
1373
        s->fcode_tab= umv_fcode_tab;
1374
        s->min_qcoeff= -128;
1375
        s->max_qcoeff=  127;
1376
        break;
1377
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1378
    default: //nothing needed default table allready set in mpegvideo.c
1379
        s->min_qcoeff= -128;
1380
        s->max_qcoeff=  127;
1381
        s->y_dc_scale_table=
1382
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1383
    }
1384

    
1385
    if(s->mpeg_quant){
1386
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1387
        s->inter_quant_bias= 0;
1388
    }else{
1389
        s->intra_quant_bias=0;
1390
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1391
    }
1392
}
1393

    
1394
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1395
{
1396
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1397
    RLTable *rl;
1398

    
1399
    rl = &rl_inter;
1400
    if (s->mb_intra && !s->h263_aic) {
1401
        /* DC coef */
1402
            level = block[0];
1403
        /* 255 cannot be represented, so we clamp */
1404
        if (level > 254) {
1405
            level = 254;
1406
            block[0] = 254;
1407
        }
1408
        /* 0 cannot be represented also */
1409
        else if (!level) {
1410
            level = 1;
1411
            block[0] = 1;
1412
        }
1413
            if (level == 128)
1414
                put_bits(&s->pb, 8, 0xff);
1415
            else
1416
                put_bits(&s->pb, 8, level & 0xff);
1417
            i = 1;
1418
    } else {
1419
            i = 0;
1420
            if (s->h263_aic && s->mb_intra)
1421
                rl = &rl_intra_aic;
1422
    }
1423
   
1424
    /* AC coefs */
1425
    last_index = s->block_last_index[n];
1426
    last_non_zero = i - 1;
1427
    for (; i <= last_index; i++) {
1428
        j = s->intra_scantable.permutated[i];
1429
        level = block[j];
1430
        if (level) {
1431
            run = i - last_non_zero - 1;
1432
            last = (i == last_index);
1433
            sign = 0;
1434
            slevel = level;
1435
            if (level < 0) {
1436
                sign = 1;
1437
                level = -level;
1438
            }
1439
            code = get_rl_index(rl, last, run, level);
1440
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1441
            if (code == rl->n) {
1442
                put_bits(&s->pb, 1, last);
1443
                put_bits(&s->pb, 6, run);
1444
                put_bits(&s->pb, 8, slevel & 0xff);
1445
            } else {
1446
                put_bits(&s->pb, 1, sign);
1447
            }
1448
                last_non_zero = i;
1449
            }
1450
    }
1451
}
1452
#endif
1453

    
1454
/***************************************************/
1455
/**
1456
 * add mpeg4 stuffing bits (01...1)
1457
 */
1458
void ff_mpeg4_stuffing(PutBitContext * pbc)
1459
{
1460
    int length;
1461
    put_bits(pbc, 1, 0);
1462
    length= (-get_bit_count(pbc))&7;
1463
    if(length) put_bits(pbc, length, (1<<length)-1);
1464
}
1465

    
1466
/* must be called before writing the header */
1467
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1468
    int time_div, time_mod;
1469

    
1470
    if(s->pict_type==I_TYPE){ //we will encode a vol header
1471
        s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1472
        if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1473

    
1474
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1475
    }
1476
    
1477
    if(s->avctx->pts)
1478
        s->time= (s->avctx->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1479
    else
1480
        s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1481
    time_div= s->time/s->time_increment_resolution;
1482
    time_mod= s->time%s->time_increment_resolution;
1483

    
1484
    if(s->pict_type==B_TYPE){
1485
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1486
    }else{
1487
        s->last_time_base= s->time_base;
1488
        s->time_base= time_div;
1489
        s->pp_time= s->time - s->last_non_b_time;
1490
        s->last_non_b_time= s->time;
1491
    }
1492
}
1493

    
1494
static void mpeg4_encode_vol_header(MpegEncContext * s)
1495
{
1496
    int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1497
    char buf[255];
1498

    
1499
    s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
1500

    
1501
    put_bits(&s->pb, 16, 0);
1502
    put_bits(&s->pb, 16, 0x100);        /* video obj */
1503
    put_bits(&s->pb, 16, 0);
1504
    put_bits(&s->pb, 16, 0x120);        /* video obj layer */
1505

    
1506
    put_bits(&s->pb, 1, 0);                /* random access vol */
1507
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1508
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1509
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1510
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1511
    if(s->aspect_ratio_info) 
1512
        put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1513
    else
1514
        put_bits(&s->pb, 4, 1);                /* aspect ratio info= sqare pixel */
1515
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1516
    {
1517
        put_bits(&s->pb, 8, s->aspected_width);
1518
        put_bits(&s->pb, 8, s->aspected_height);
1519
    }
1520

    
1521
    if(s->low_delay){
1522
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1523
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1524
        put_bits(&s->pb, 1, s->low_delay);
1525
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1526
    }else{
1527
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1528
    }
1529

    
1530
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1531
    put_bits(&s->pb, 1, 1);                /* marker bit */
1532
    
1533
    put_bits(&s->pb, 16, s->time_increment_resolution);
1534
    if (s->time_increment_bits < 1)
1535
        s->time_increment_bits = 1;
1536
    put_bits(&s->pb, 1, 1);                /* marker bit */
1537
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1538
    put_bits(&s->pb, 1, 1);                /* marker bit */
1539
    put_bits(&s->pb, 13, s->width);        /* vol width */
1540
    put_bits(&s->pb, 1, 1);                /* marker bit */
1541
    put_bits(&s->pb, 13, s->height);        /* vol height */
1542
    put_bits(&s->pb, 1, 1);                /* marker bit */
1543
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1544
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1545
    if (vo_ver_id == 1) {
1546
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1547
    }else{ /* vo_ver_id == 2 */
1548
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1549
    }
1550
    
1551
    s->quant_precision=5;
1552
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
1553
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
1554
    if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1555

    
1556
    if (vo_ver_id != 1)
1557
        put_bits(&s->pb, 1, s->quarter_sample=0);
1558
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1559
    s->resync_marker= s->rtp_mode;
1560
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1561
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1562
    if(s->data_partitioning){
1563
        put_bits(&s->pb, 1, 0);                /* no rvlc */
1564
    }
1565

    
1566
    if (vo_ver_id != 1){
1567
        put_bits(&s->pb, 1, 0);                /* newpred */
1568
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1569
    }
1570
    put_bits(&s->pb, 1, 0);                /* scalability */
1571
    
1572
    ff_mpeg4_stuffing(&s->pb);
1573

    
1574
    /* user data */
1575
    if(!ff_bit_exact){
1576
        put_bits(&s->pb, 16, 0);
1577
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1578
        sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1579
        put_string(&s->pb, buf);
1580
        ff_mpeg4_stuffing(&s->pb);
1581
    }
1582
}
1583

    
1584
/* write mpeg4 VOP header */
1585
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1586
{
1587
    int time_incr;
1588
    int time_div, time_mod;
1589
    
1590
    if(s->pict_type==I_TYPE){
1591
        s->no_rounding=0;
1592
        if(picture_number==0 || !s->strict_std_compliance)
1593
            mpeg4_encode_vol_header(s);
1594
    }
1595
    
1596
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1597

    
1598
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1599
    
1600
    put_bits(&s->pb, 16, 0);                /* vop header */
1601
    put_bits(&s->pb, 16, 0x1B6);        /* vop header */
1602
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1603

    
1604
    time_div= s->time/s->time_increment_resolution;
1605
    time_mod= s->time%s->time_increment_resolution;
1606
    time_incr= time_div - s->last_time_base;
1607
    while(time_incr--)
1608
        put_bits(&s->pb, 1, 1);
1609
        
1610
    put_bits(&s->pb, 1, 0);
1611

    
1612
    put_bits(&s->pb, 1, 1);        /* marker */
1613
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1614
    put_bits(&s->pb, 1, 1);        /* marker */
1615
    put_bits(&s->pb, 1, 1);        /* vop coded */
1616
    if (    s->pict_type == P_TYPE 
1617
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1618
        s->no_rounding ^= 1;
1619
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1620
    }
1621
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1622
    if(!s->progressive_sequence){
1623
         put_bits(&s->pb, 1, s->top_field_first);
1624
         put_bits(&s->pb, 1, s->alternate_scan);
1625
    }
1626
    //FIXME sprite stuff
1627

    
1628
    put_bits(&s->pb, 5, s->qscale);
1629

    
1630
    if (s->pict_type != I_TYPE)
1631
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1632
    if (s->pict_type == B_TYPE)
1633
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1634
    //    printf("****frame %d\n", picture_number);
1635

    
1636
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
1637
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1638
     s->h_edge_pos= s->width;
1639
     s->v_edge_pos= s->height;
1640
}
1641

    
1642
/**
1643
 * change qscale by given dquant and update qscale dependant variables.
1644
 */
1645
static void change_qscale(MpegEncContext * s, int dquant)
1646
{
1647
    s->qscale += dquant;
1648

    
1649
    if (s->qscale < 1)
1650
        s->qscale = 1;
1651
    else if (s->qscale > 31)
1652
        s->qscale = 31;
1653

    
1654
    s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1655
    s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1656
}
1657

    
1658
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1659
{
1660
    int a, b, c, wrap, pred, scale;
1661
    UINT16 *dc_val;
1662
    int dummy;
1663

    
1664
    /* find prediction */
1665
    if (n < 4) {
1666
        scale = s->y_dc_scale;
1667
    } else {
1668
        scale = s->c_dc_scale;
1669
    }
1670
    wrap= s->block_wrap[n];
1671
    dc_val = s->dc_val[0] + s->block_index[n];
1672

    
1673
    /* B C
1674
     * A X 
1675
     */
1676
    a = dc_val[ - 1];
1677
    b = dc_val[ - 1 - wrap];
1678
    c = dc_val[ - wrap];
1679

    
1680
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
1681
    if(s->first_slice_line && n!=3){
1682
        if(n!=2) b=c= 1024;
1683
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
1684
    }
1685
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
1686
        if(n==0 || n==4 || n==5)
1687
            b=1024;
1688
    }
1689

    
1690
    if (abs(a - b) < abs(b - c)) {
1691
        pred = c;
1692
        *dir_ptr = 1; /* top */
1693
    } else {
1694
        pred = a;
1695
        *dir_ptr = 0; /* left */
1696
    }
1697
    /* we assume pred is positive */
1698
#ifdef ARCH_X86
1699
        asm volatile (
1700
                "xorl %%edx, %%edx        \n\t"
1701
                "mul %%ecx                \n\t"
1702
                : "=d" (pred), "=a"(dummy)
1703
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1704
        );
1705
#else
1706
    pred = (pred + (scale >> 1)) / scale;
1707
#endif
1708

    
1709
    /* prepare address for prediction update */
1710
    *dc_val_ptr = &dc_val[0];
1711

    
1712
    return pred;
1713
}
1714

    
1715
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1716
                   int dir)
1717
{
1718
    int i;
1719
    INT16 *ac_val, *ac_val1;
1720

    
1721
    /* find prediction */
1722
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1723
    ac_val1 = ac_val;
1724
    if (s->ac_pred) {
1725
        if (dir == 0) {
1726
            const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1727
            /* left prediction */
1728
            ac_val -= 16;
1729
            
1730
            if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
1731
                /* same qscale */
1732
                for(i=1;i<8;i++) {
1733
                    block[s->idct_permutation[i<<3]] += ac_val[i];
1734
                }
1735
            }else{
1736
                /* different qscale, we must rescale */
1737
                for(i=1;i<8;i++) {
1738
                    block[s->idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale);
1739
                }
1740
            }
1741
        } else {
1742
            const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1743
            /* top prediction */
1744
            ac_val -= 16 * s->block_wrap[n];
1745

    
1746
            if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
1747
                /* same qscale */
1748
                for(i=1;i<8;i++) {
1749
                    block[s->idct_permutation[i]] += ac_val[i + 8];
1750
                }
1751
            }else{
1752
                /* different qscale, we must rescale */
1753
                for(i=1;i<8;i++) {
1754
                    block[s->idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale);
1755
                }
1756
            }
1757
        }
1758
    }
1759
    /* left copy */
1760
    for(i=1;i<8;i++)
1761
        ac_val1[i    ] = block[s->idct_permutation[i<<3]];
1762

    
1763
    /* top copy */
1764
    for(i=1;i<8;i++)
1765
        ac_val1[8 + i] = block[s->idct_permutation[i   ]];
1766

    
1767
}
1768

    
1769
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1770
                              int dir)
1771
{
1772
    int i;
1773
    INT16 *ac_val;
1774

    
1775
    /* find prediction */
1776
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1777
 
1778
    if (dir == 0) {
1779
        const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1780
        /* left prediction */
1781
        ac_val -= 16;
1782
        if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
1783
            /* same qscale */
1784
            for(i=1;i<8;i++) {
1785
                block[s->idct_permutation[i<<3]] -= ac_val[i];
1786
            }
1787
        }else{
1788
            /* different qscale, we must rescale */
1789
            for(i=1;i<8;i++) {
1790
                block[s->idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale);
1791
            }
1792
        }
1793
    } else {
1794
        const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1795
        /* top prediction */
1796
        ac_val -= 16 * s->block_wrap[n];
1797
        if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
1798
            /* same qscale */
1799
            for(i=1;i<8;i++) {
1800
                block[s->idct_permutation[i]] -= ac_val[i + 8];
1801
            }
1802
        }else{
1803
            /* different qscale, we must rescale */
1804
            for(i=1;i<8;i++) {
1805
                block[s->idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale);
1806
            }
1807
        }
1808
    }
1809
}
1810

    
1811
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1812
{
1813
#if 1
1814
//    if(level<-255 || level>255) printf("dc overflow\n");
1815
    level+=256;
1816
    if (n < 4) {
1817
        /* luminance */
1818
        put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1819
    } else {
1820
        /* chrominance */
1821
        put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1822
    }
1823
#else
1824
    int size, v;
1825
    /* find number of bits */
1826
    size = 0;
1827
    v = abs(level);
1828
    while (v) {
1829
        v >>= 1;
1830
        size++;
1831
    }
1832

    
1833
    if (n < 4) {
1834
        /* luminance */
1835
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1836
    } else {
1837
        /* chrominance */
1838
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1839
    }
1840

    
1841
    /* encode remaining bits */
1842
    if (size > 0) {
1843
        if (level < 0)
1844
            level = (-level) ^ ((1 << size) - 1);
1845
        put_bits(&s->pb, size, level);
1846
        if (size > 8)
1847
            put_bits(&s->pb, 1, 1);
1848
    }
1849
#endif
1850
}
1851
#ifdef CONFIG_ENCODERS
1852
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
1853
                               UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
1854
{
1855
    int i, last_non_zero;
1856
#if 0 //variables for the outcommented version
1857
    int code, sign, last;
1858
#endif
1859
    const RLTable *rl;
1860
    UINT32 *bits_tab;
1861
    UINT8 *len_tab;
1862
    const int last_index = s->block_last_index[n];
1863

    
1864
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
1865
        /* mpeg4 based DC predictor */
1866
        mpeg4_encode_dc(dc_pb, intra_dc, n);
1867
        if(last_index<1) return;
1868
        i = 1;
1869
        rl = &rl_intra;
1870
        bits_tab= uni_mpeg4_intra_rl_bits;
1871
        len_tab = uni_mpeg4_intra_rl_len;
1872
    } else {
1873
        if(last_index<0) return;
1874
        i = 0;
1875
        rl = &rl_inter;
1876
        bits_tab= uni_mpeg4_inter_rl_bits;
1877
        len_tab = uni_mpeg4_inter_rl_len;
1878
    }
1879

    
1880
    /* AC coefs */
1881
    last_non_zero = i - 1;
1882
#if 1
1883
    for (; i < last_index; i++) {
1884
        int level = block[ scan_table[i] ];
1885
        if (level) {
1886
            int run = i - last_non_zero - 1;
1887
            level+=64;
1888
            if((level&(~127)) == 0){
1889
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
1890
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
1891
            }else{ //ESC3
1892
                put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
1893
            }
1894
            last_non_zero = i;
1895
        }
1896
    }
1897
    /*if(i<=last_index)*/{
1898
        int level = block[ scan_table[i] ];
1899
        int run = i - last_non_zero - 1;
1900
        level+=64;
1901
        if((level&(~127)) == 0){
1902
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
1903
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
1904
        }else{ //ESC3
1905
            put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
1906
        }
1907
    }
1908
#else
1909
    for (; i <= last_index; i++) {
1910
        const int slevel = block[ scan_table[i] ];
1911
        if (slevel) {
1912
            int level;
1913
            int run = i - last_non_zero - 1;
1914
            last = (i == last_index);
1915
            sign = 0;
1916
            level = slevel;
1917
            if (level < 0) {
1918
                sign = 1;
1919
                level = -level;
1920
            }
1921
            code = get_rl_index(rl, last, run, level);
1922
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1923
            if (code == rl->n) {
1924
                int level1, run1;
1925
                level1 = level - rl->max_level[last][run];
1926
                if (level1 < 1) 
1927
                    goto esc2;
1928
                code = get_rl_index(rl, last, run, level1);
1929
                if (code == rl->n) {
1930
                esc2:
1931
                    put_bits(ac_pb, 1, 1);
1932
                    if (level > MAX_LEVEL)
1933
                        goto esc3;
1934
                    run1 = run - rl->max_run[last][level] - 1;
1935
                    if (run1 < 0)
1936
                        goto esc3;
1937
                    code = get_rl_index(rl, last, run1, level);
1938
                    if (code == rl->n) {
1939
                    esc3:
1940
                        /* third escape */
1941
                        put_bits(ac_pb, 1, 1);
1942
                        put_bits(ac_pb, 1, last);
1943
                        put_bits(ac_pb, 6, run);
1944
                        put_bits(ac_pb, 1, 1);
1945
                        put_bits(ac_pb, 12, slevel & 0xfff);
1946
                        put_bits(ac_pb, 1, 1);
1947
                    } else {
1948
                        /* second escape */
1949
                        put_bits(ac_pb, 1, 0);
1950
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1951
                        put_bits(ac_pb, 1, sign);
1952
                    }
1953
                } else {
1954
                    /* first escape */
1955
                    put_bits(ac_pb, 1, 0);
1956
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1957
                    put_bits(ac_pb, 1, sign);
1958
                }
1959
            } else {
1960
                put_bits(ac_pb, 1, sign);
1961
            }
1962
            last_non_zero = i;
1963
        }
1964
    }
1965
#endif
1966
}
1967
#endif
1968

    
1969

    
1970
/***********************************************/
1971
/* decoding */
1972

    
1973
static VLC intra_MCBPC_vlc;
1974
static VLC inter_MCBPC_vlc;
1975
static VLC cbpy_vlc;
1976
static VLC mv_vlc;
1977
static VLC dc_lum, dc_chrom;
1978
static VLC sprite_trajectory;
1979
static VLC mb_type_b_vlc;
1980

    
1981
void init_rl(RLTable *rl)
1982
{
1983
    INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1984
    UINT8 index_run[MAX_RUN+1];
1985
    int last, run, level, start, end, i;
1986

    
1987
    /* compute max_level[], max_run[] and index_run[] */
1988
    for(last=0;last<2;last++) {
1989
        if (last == 0) {
1990
            start = 0;
1991
            end = rl->last;
1992
        } else {
1993
            start = rl->last;
1994
            end = rl->n;
1995
        }
1996

    
1997
        memset(max_level, 0, MAX_RUN + 1);
1998
        memset(max_run, 0, MAX_LEVEL + 1);
1999
        memset(index_run, rl->n, MAX_RUN + 1);
2000
        for(i=start;i<end;i++) {
2001
            run = rl->table_run[i];
2002
            level = rl->table_level[i];
2003
            if (index_run[run] == rl->n)
2004
                index_run[run] = i;
2005
            if (level > max_level[run])
2006
                max_level[run] = level;
2007
            if (run > max_run[level])
2008
                max_run[level] = run;
2009
        }
2010
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
2011
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
2012
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
2013
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
2014
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
2015
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
2016
    }
2017
}
2018

    
2019
void init_vlc_rl(RLTable *rl)
2020
{
2021
    int i, q;
2022
    
2023
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2024
             &rl->table_vlc[0][1], 4, 2,
2025
             &rl->table_vlc[0][0], 4, 2);
2026

    
2027
    
2028
    for(q=0; q<32; q++){
2029
        int qmul= q*2;
2030
        int qadd= (q-1)|1;
2031
        
2032
        if(q==0){
2033
            qmul=1;
2034
            qadd=0;
2035
        }
2036
        
2037
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2038
        for(i=0; i<rl->vlc.table_size; i++){
2039
            int code= rl->vlc.table[i][0];
2040
            int len = rl->vlc.table[i][1];
2041
            int level, run;
2042
        
2043
            if(len==0){ // illegal code
2044
                run= 66;
2045
                level= MAX_LEVEL;
2046
            }else if(len<0){ //more bits needed
2047
                run= 0;
2048
                level= code;
2049
            }else{
2050
                if(code==rl->n){ //esc
2051
                    run= 66;
2052
                    level= 0;
2053
                }else{
2054
                    run=   rl->table_run  [code] + 1;
2055
                    level= rl->table_level[code] * qmul + qadd;
2056
                    if(code >= rl->last) run+=192;
2057
                }
2058
            }
2059
            rl->rl_vlc[q][i].len= len;
2060
            rl->rl_vlc[q][i].level= level;
2061
            rl->rl_vlc[q][i].run= run;
2062
        }
2063
    }
2064
}
2065

    
2066
/* init vlcs */
2067

    
2068
/* XXX: find a better solution to handle static init */
2069
void h263_decode_init_vlc(MpegEncContext *s)
2070
{
2071
    static int done = 0;
2072

    
2073
    if (!done) {
2074
        done = 1;
2075

    
2076
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8, 
2077
                 intra_MCBPC_bits, 1, 1,
2078
                 intra_MCBPC_code, 1, 1);
2079
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25, 
2080
                 inter_MCBPC_bits, 1, 1,
2081
                 inter_MCBPC_code, 1, 1);
2082
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2083
                 &cbpy_tab[0][1], 2, 1,
2084
                 &cbpy_tab[0][0], 2, 1);
2085
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2086
                 &mvtab[0][1], 2, 1,
2087
                 &mvtab[0][0], 2, 1);
2088
        init_rl(&rl_inter);
2089
        init_rl(&rl_intra);
2090
        init_rl(&rl_intra_aic);
2091
        init_vlc_rl(&rl_inter);
2092
        init_vlc_rl(&rl_intra);
2093
        init_vlc_rl(&rl_intra_aic);
2094
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2095
                 &DCtab_lum[0][1], 2, 1,
2096
                 &DCtab_lum[0][0], 2, 1);
2097
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2098
                 &DCtab_chrom[0][1], 2, 1,
2099
                 &DCtab_chrom[0][0], 2, 1);
2100
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2101
                 &sprite_trajectory_tab[0][1], 4, 2,
2102
                 &sprite_trajectory_tab[0][0], 4, 2);
2103
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2104
                 &mb_type_b_tab[0][1], 2, 1,
2105
                 &mb_type_b_tab[0][0], 2, 1);
2106
    }
2107
}
2108

    
2109
/**
2110
 * Get the GOB height based on picture height.
2111
 */
2112
int ff_h263_get_gob_height(MpegEncContext *s){
2113
    if (s->height <= 400)
2114
        return 1;
2115
    else if (s->height <= 800)
2116
        return  2;
2117
    else
2118
        return 4;
2119
}
2120

    
2121
/**
2122
 * decodes the group of blocks header.
2123
 * @return <0 if an error occured
2124
 */
2125
static int h263_decode_gob_header(MpegEncContext *s)
2126
{
2127
    unsigned int val, gfid;
2128
    int left;
2129
    
2130
    /* Check for GOB Start Code */
2131
    val = show_bits(&s->gb, 16);
2132
    if(val)
2133
        return -1;
2134

    
2135
        /* We have a GBSC probably with GSTUFF */
2136
    skip_bits(&s->gb, 16); /* Drop the zeros */
2137
    left= s->gb.size*8 - get_bits_count(&s->gb);
2138
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2139
    for(;left>13; left--){
2140
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2141
    }
2142
    if(left<=13) 
2143
        return -1;
2144

    
2145
#ifdef DEBUG
2146
    fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2147
#endif
2148
    s->gob_number = get_bits(&s->gb, 5); /* GN */
2149
    gfid = get_bits(&s->gb, 2); /* GFID */
2150
    s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2151
    if(s->qscale==0) 
2152
        return -1;
2153
    s->mb_x= 0;
2154
    s->mb_y= s->gob_index* s->gob_number;
2155
#ifdef DEBUG
2156
    fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2157
#endif
2158
    return 0;
2159
}
2160

    
2161
static inline void memsetw(short *tab, int val, int n)
2162
{
2163
    int i;
2164
    for(i=0;i<n;i++)
2165
        tab[i] = val;
2166
}
2167

    
2168
void ff_mpeg4_init_partitions(MpegEncContext *s)
2169
{
2170
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2171
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
2172
}
2173

    
2174
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2175
{
2176
    const int pb2_len   = get_bit_count(&s->pb2   );
2177
    const int tex_pb_len= get_bit_count(&s->tex_pb);
2178
    const int bits= get_bit_count(&s->pb);
2179

    
2180
    if(s->pict_type==I_TYPE){
2181
        put_bits(&s->pb, 19, DC_MARKER);
2182
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2183
        s->i_tex_bits+= tex_pb_len;
2184
    }else{
2185
        put_bits(&s->pb, 17, MOTION_MARKER);
2186
        s->misc_bits+=17 + pb2_len;
2187
        s->mv_bits+= bits - s->last_bits;
2188
        s->p_tex_bits+= tex_pb_len;
2189
    }
2190

    
2191
    flush_put_bits(&s->pb2);
2192
    flush_put_bits(&s->tex_pb);
2193

    
2194
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2195
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2196
    s->last_bits= get_bit_count(&s->pb);
2197
}
2198

    
2199
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2200
    switch(s->pict_type){
2201
        case I_TYPE:
2202
            return 16;
2203
        case P_TYPE:
2204
        case S_TYPE:
2205
            return s->f_code+15;
2206
        case B_TYPE:
2207
            return MAX(MAX(s->f_code, s->b_code)+15, 17);
2208
        default:
2209
            return -1;
2210
    }
2211
}
2212

    
2213
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2214
{
2215
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2216

    
2217
    ff_mpeg4_stuffing(&s->pb);
2218
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2219
    put_bits(&s->pb, 1, 1);
2220
    
2221
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2222
    put_bits(&s->pb, s->quant_precision, s->qscale);
2223
    put_bits(&s->pb, 1, 0); /* no HEC */
2224
}
2225

    
2226
/**
2227
 * check if the next stuff is a resync marker or the end.
2228
 * @return 0 if not
2229
 */
2230
static inline int mpeg4_is_resync(MpegEncContext *s){
2231
    const int bits_count= get_bits_count(&s->gb);
2232
    
2233
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
2234
        return 0;
2235
    }
2236

    
2237
    if(bits_count + 8 >= s->gb.size*8){
2238
        int v= show_bits(&s->gb, 8);
2239
        v|= 0x7F >> (7-(bits_count&7));
2240
                
2241
        if(v==0x7F)
2242
            return 1;
2243
    }else{
2244
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2245
            int len;
2246
            GetBitContext gb= s->gb;
2247
        
2248
            skip_bits(&s->gb, 1);
2249
            align_get_bits(&s->gb);
2250
        
2251
            for(len=0; len<32; len++){
2252
                if(get_bits1(&s->gb)) break;
2253
            }
2254

    
2255
            s->gb= gb;
2256

    
2257
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2258
                return 1;
2259
        }
2260
    }
2261
    return 0;
2262
}
2263

    
2264
/**
2265
 * decodes the next video packet.
2266
 * @return <0 if something went wrong
2267
 */
2268
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2269
{
2270
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2271
    int header_extension=0, mb_num, len;
2272
    
2273
    /* is there enough space left for a video packet + header */
2274
    if( get_bits_count(&s->gb) > s->gb.size*8-20) return -1;
2275

    
2276
    for(len=0; len<32; len++){
2277
        if(get_bits1(&s->gb)) break;
2278
    }
2279

    
2280
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2281
        printf("marker does not match f_code\n");
2282
        return -1;
2283
    }
2284
    
2285
    if(s->shape != RECT_SHAPE){
2286
        header_extension= get_bits1(&s->gb);
2287
        //FIXME more stuff here
2288
    }
2289

    
2290
    mb_num= get_bits(&s->gb, mb_num_bits);
2291
    if(mb_num>=s->mb_num){
2292
        fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2293
        return -1;
2294
    }
2295
    s->mb_x= mb_num % s->mb_width;
2296
    s->mb_y= mb_num / s->mb_width;
2297

    
2298
    if(s->shape != BIN_ONLY_SHAPE){
2299
        int qscale= get_bits(&s->gb, s->quant_precision); 
2300
        if(qscale)
2301
            s->qscale= qscale;
2302
    }
2303

    
2304
    if(s->shape == RECT_SHAPE){
2305
        header_extension= get_bits1(&s->gb);
2306
    }
2307
    if(header_extension){
2308
        int time_increment;
2309
        int time_incr=0;
2310

    
2311
        while (get_bits1(&s->gb) != 0) 
2312
            time_incr++;
2313

    
2314
        check_marker(&s->gb, "before time_increment in video packed header");
2315
        time_increment= get_bits(&s->gb, s->time_increment_bits);
2316
        check_marker(&s->gb, "before vop_coding_type in video packed header");
2317
        
2318
        skip_bits(&s->gb, 2); /* vop coding type */
2319
        //FIXME not rect stuff here
2320

    
2321
        if(s->shape != BIN_ONLY_SHAPE){
2322
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2323
//FIXME dont just ignore everything
2324
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2325
                mpeg4_decode_sprite_trajectory(s);
2326
                fprintf(stderr, "untested\n");
2327
            }
2328

    
2329
            //FIXME reduced res stuff here
2330
            
2331
            if (s->pict_type != I_TYPE) {
2332
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
2333
                if(f_code==0){
2334
                    printf("Error, video packet header damaged (f_code=0)\n");
2335
                }
2336
            }
2337
            if (s->pict_type == B_TYPE) {
2338
                int b_code = get_bits(&s->gb, 3);
2339
                if(b_code==0){
2340
                    printf("Error, video packet header damaged (b_code=0)\n");
2341
                }
2342
            }       
2343
        }
2344
    }
2345
    //FIXME new-pred stuff
2346
    
2347
//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));
2348

    
2349
    return 0;
2350
}
2351

    
2352
void ff_mpeg4_clean_buffers(MpegEncContext *s)
2353
{
2354
    int c_wrap, c_xy, l_wrap, l_xy;
2355

    
2356
    l_wrap= s->block_wrap[0];
2357
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2358
    c_wrap= s->block_wrap[4];
2359
    c_xy= s->mb_y*c_wrap + s->mb_x;
2360

    
2361
#if 0
2362
    /* clean DC */
2363
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2364
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2365
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2366
#endif
2367

    
2368
    /* clean AC */
2369
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
2370
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
2371
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
2372

    
2373
    /* clean MV */
2374
    // we cant clear the MVs as they might be needed by a b frame
2375
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
2376
//    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2377
    s->last_mv[0][0][0]=
2378
    s->last_mv[0][0][1]=
2379
    s->last_mv[1][0][0]=
2380
    s->last_mv[1][0][1]= 0;
2381
}
2382

    
2383
/**
2384
 * decodes the group of blocks / video packet header.
2385
 * @return <0 if no resync found
2386
 */
2387
int ff_h263_resync(MpegEncContext *s){
2388
    int left, ret;
2389
    
2390
    if(s->codec_id==CODEC_ID_MPEG4)
2391
        skip_bits1(&s->gb);
2392
    
2393
    align_get_bits(&s->gb);
2394

    
2395
    if(show_bits(&s->gb, 16)==0){
2396
        if(s->codec_id==CODEC_ID_MPEG4)
2397
            ret= mpeg4_decode_video_packet_header(s);
2398
        else
2399
            ret= h263_decode_gob_header(s);
2400
        if(ret>=0)
2401
            return 0;
2402
    }
2403
    //ok, its not where its supposed to be ...
2404
    s->gb= s->last_resync_gb;
2405
    align_get_bits(&s->gb);
2406
    left= s->gb.size*8 - get_bits_count(&s->gb);
2407
    
2408
    for(;left>16+1+5+5; left-=8){ 
2409
        if(show_bits(&s->gb, 16)==0){
2410
            GetBitContext bak= s->gb;
2411

    
2412
            if(s->codec_id==CODEC_ID_MPEG4)
2413
                ret= mpeg4_decode_video_packet_header(s);
2414
            else
2415
                ret= h263_decode_gob_header(s);
2416
            if(ret>=0)
2417
                return 0;
2418

    
2419
            s->gb= bak;
2420
        }
2421
        skip_bits(&s->gb, 8);
2422
    }
2423
    
2424
    return -1;
2425
}
2426

    
2427
/**
2428
 * @param n either 0 for the x component or 1 for y
2429
 * @returns the average MV for a GMC MB
2430
 */
2431
static inline int get_amv(MpegEncContext *s, int n){
2432
    int x, y, mb_v, sum, dx, dy, shift;
2433
    int len = 1 << (s->f_code + 4);
2434
    const int a= s->sprite_warping_accuracy;
2435

    
2436
    if(s->real_sprite_warping_points==1){
2437
        if(s->divx_version==500 && s->divx_build==413)
2438
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2439
        else
2440
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2441
    }else{
2442
        dx= s->sprite_delta[n][0];
2443
        dy= s->sprite_delta[n][1];
2444
        shift= s->sprite_shift[0];
2445
        if(n) dy -= 1<<(shift + a + 1);
2446
        else  dx -= 1<<(shift + a + 1);
2447
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2448

    
2449
        sum=0;
2450
        for(y=0; y<16; y++){
2451
            int v;
2452
        
2453
            v= mb_v + dy*y;
2454
            //XXX FIXME optimize
2455
            for(x=0; x<16; x++){
2456
                sum+= v>>shift;
2457
                v+= dx;
2458
            }
2459
        }
2460
        sum /= 256;
2461
        sum= RSHIFT(sum<<s->quarter_sample, a);
2462
    }
2463

    
2464
    if      (sum < -len) sum= -len;
2465
    else if (sum >= len) sum= len-1;
2466

    
2467
    return sum;
2468
}
2469

    
2470
/**
2471
 * decodes first partition.
2472
 * @return number of MBs decoded or <0 if an error occured
2473
 */
2474
static int mpeg4_decode_partition_a(MpegEncContext *s){
2475
    int mb_num;
2476
    static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2477
    
2478
    /* decode first partition */
2479
    mb_num=0;
2480
    s->first_slice_line=1;
2481
    for(; s->mb_y<s->mb_height; s->mb_y++){
2482
        ff_init_block_index(s);
2483
        for(; s->mb_x<s->mb_width; s->mb_x++){
2484
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2485
            int cbpc;
2486
            int dir=0;
2487
            
2488
            mb_num++;
2489
            ff_update_block_index(s);
2490
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2491
                s->first_slice_line=0;
2492
            
2493
            if(s->mb_x==0) PRINT_MB_TYPE("\n");
2494

    
2495
            if(s->pict_type==I_TYPE){
2496
                int i;
2497

    
2498
                if(show_bits(&s->gb, 19)==DC_MARKER){
2499
                    return mb_num-1;
2500
                }
2501

    
2502
                PRINT_MB_TYPE("I");
2503
                cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2504
                if (cbpc < 0){
2505

    
2506
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2507
                    return -1;
2508
                }
2509
                s->cbp_table[xy]= cbpc & 3;
2510
                s->mb_type[xy]= MB_TYPE_INTRA;
2511
                s->mb_intra = 1;
2512

    
2513
                if(cbpc & 4) {
2514
                    change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2515
                }
2516
                s->qscale_table[xy]= s->qscale;
2517

    
2518
                s->mbintra_table[xy]= 1;
2519
                for(i=0; i<6; i++){
2520
                    int dc_pred_dir;
2521
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2522
                    if(dc < 0){
2523
                        fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2524
                        return -1;
2525
                    }
2526
                    dir<<=1;
2527
                    if(dc_pred_dir) dir|=1;
2528
                }
2529
                s->pred_dir_table[xy]= dir;
2530
                
2531
                s->error_status_table[xy]= AC_ERROR;
2532
            }else{ /* P/S_TYPE */
2533
                int mx, my, pred_x, pred_y, bits;
2534
                INT16 * const mot_val= s->motion_val[s->block_index[0]];
2535
                const int stride= s->block_wrap[0]*2;
2536

    
2537
                bits= show_bits(&s->gb, 17);
2538
                if(bits==MOTION_MARKER){
2539
                    return mb_num-1;
2540
                }
2541
                skip_bits1(&s->gb);
2542
                if(bits&0x10000){
2543
                    /* skip mb */
2544
                    s->mb_type[xy]= MB_TYPE_SKIPED;
2545
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2546
                        PRINT_MB_TYPE("G");
2547
                        mx= get_amv(s, 0);
2548
                        my= get_amv(s, 1);
2549
                    }else{
2550
                        PRINT_MB_TYPE("S");
2551
                        mx=my=0;
2552
                    }
2553
                    mot_val[0       ]= mot_val[2       ]=
2554
                    mot_val[0+stride]= mot_val[2+stride]= mx;
2555
                    mot_val[1       ]= mot_val[3       ]=
2556
                    mot_val[1+stride]= mot_val[3+stride]= my;
2557

    
2558
                    if(s->mbintra_table[xy])
2559
                        ff_clean_intra_table_entries(s);
2560

    
2561
                    s->error_status_table[xy]= AC_ERROR;
2562
                    continue;
2563
                }
2564
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2565
                if (cbpc < 0){
2566
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2567
                    return -1;
2568
                }
2569
                if (cbpc > 20)
2570
                    cbpc+=3;
2571
                else if (cbpc == 20)
2572
                    fprintf(stderr, "Stuffing !");
2573
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2574
    
2575
                s->mb_intra = ((cbpc & 4) != 0);
2576
        
2577
                if(s->mb_intra){
2578
                    PRINT_MB_TYPE("I");
2579
                    s->mbintra_table[xy]= 1;
2580
                    s->mb_type[xy]= MB_TYPE_INTRA;
2581
                    mot_val[0       ]= mot_val[2       ]= 
2582
                    mot_val[0+stride]= mot_val[2+stride]= 0;
2583
                    mot_val[1       ]= mot_val[3       ]=
2584
                    mot_val[1+stride]= mot_val[3+stride]= 0;
2585
                    s->error_status_table[xy]= DC_ERROR|AC_ERROR;
2586
                }else{
2587
                    if(s->mbintra_table[xy])
2588
                        ff_clean_intra_table_entries(s);
2589

    
2590
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2591
                        s->mcsel= get_bits1(&s->gb);
2592
                    else s->mcsel= 0;
2593
        
2594
                    if ((cbpc & 16) == 0) {
2595
                        PRINT_MB_TYPE("P");
2596
                        /* 16x16 motion prediction */
2597
                        s->mb_type[xy]= MB_TYPE_INTER;
2598

    
2599
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
2600
                        if(!s->mcsel){
2601
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2602
                            if (mx >= 0xffff)
2603
                                return -1;
2604

    
2605
                            my = h263_decode_motion(s, pred_y, s->f_code);
2606
                            if (my >= 0xffff)
2607
                                return -1;
2608
                        } else {
2609
                            mx = get_amv(s, 0);
2610
                            my = get_amv(s, 1);
2611
                        }
2612

    
2613
                        mot_val[0       ]= mot_val[2       ] =
2614
                        mot_val[0+stride]= mot_val[2+stride]= mx;
2615
                        mot_val[1       ]= mot_val[3       ]=
2616
                        mot_val[1+stride]= mot_val[3+stride]= my;
2617
                    } else {
2618
                        int i;
2619
                        PRINT_MB_TYPE("4");
2620
                        s->mb_type[xy]= MB_TYPE_INTER4V;
2621
                        for(i=0;i<4;i++) {
2622
                            INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2623
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2624
                            if (mx >= 0xffff)
2625
                                return -1;
2626
                
2627
                            my = h263_decode_motion(s, pred_y, s->f_code);
2628
                            if (my >= 0xffff)
2629
                                return -1;
2630
                            mot_val[0] = mx;
2631
                            mot_val[1] = my;
2632
                        }
2633
                    }
2634
                    s->error_status_table[xy]= AC_ERROR;
2635
                }
2636
            }
2637
        }
2638
        s->mb_x= 0;
2639
    }
2640

    
2641
    return mb_num;
2642
}
2643

    
2644
/**
2645
 * decode second partition.
2646
 * @return <0 if an error occured
2647
 */
2648
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
2649
    int mb_num=0;
2650
    static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2651

    
2652
    s->mb_x= s->resync_mb_x;
2653
    s->first_slice_line=1;
2654
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
2655
        ff_init_block_index(s);
2656
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
2657
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2658

    
2659
            mb_num++;
2660
            ff_update_block_index(s);
2661
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2662
                s->first_slice_line=0;
2663
            
2664
            if(s->pict_type==I_TYPE){
2665
                int ac_pred= get_bits1(&s->gb);
2666
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2667
                if(cbpy<0){
2668
                    fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2669
                    return -1;
2670
                }
2671
                
2672
                s->cbp_table[xy]|= cbpy<<2;
2673
                s->pred_dir_table[xy]|= ac_pred<<7;
2674
            }else{ /* P || S_TYPE */
2675
                if(s->mb_type[xy]&MB_TYPE_INTRA){          
2676
                    int dir=0,i;
2677
                    int ac_pred = get_bits1(&s->gb);
2678
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2679

    
2680
                    if(cbpy<0){
2681
                        fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2682
                        return -1;
2683
                    }
2684
                    
2685
                    if(s->cbp_table[xy] & 8) {
2686
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2687
                    }
2688
                    s->qscale_table[xy]= s->qscale;
2689

    
2690
                    for(i=0; i<6; i++){
2691
                        int dc_pred_dir;
2692
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2693
                        if(dc < 0){
2694
                            fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2695
                            return -1;
2696
                        }
2697
                        dir<<=1;
2698
                        if(dc_pred_dir) dir|=1;
2699
                    }
2700
                    s->cbp_table[xy]&= 3; //remove dquant
2701
                    s->cbp_table[xy]|= cbpy<<2;
2702
                    s->pred_dir_table[xy]= dir | (ac_pred<<7);
2703
                    s->error_status_table[xy]&= ~DC_ERROR;
2704
                }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
2705
                    s->qscale_table[xy]= s->qscale;
2706
                    s->cbp_table[xy]= 0;
2707
                }else{
2708
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2709

    
2710
                    if(cbpy<0){
2711
                        fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2712
                        return -1;
2713
                    }
2714
                    
2715
                    if(s->cbp_table[xy] & 8) {
2716
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2717
                    }
2718
                    s->qscale_table[xy]= s->qscale;
2719

    
2720
                    s->cbp_table[xy]&= 3; //remove dquant
2721
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
2722
                }
2723
            }
2724
        }
2725
        if(mb_num >= mb_count) return 0;
2726
        s->mb_x= 0;
2727
    }
2728
    return 0;
2729
}
2730

    
2731
/**
2732
 * decodes the first & second partition
2733
 * @return <0 if error (and sets error type in the error_status_table)
2734
 */
2735
int ff_mpeg4_decode_partitions(MpegEncContext *s)
2736
{
2737
    int mb_num;
2738
    
2739
    mb_num= mpeg4_decode_partition_a(s);    
2740
    if(mb_num<0)
2741
        return -1;
2742
    
2743
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
2744
        fprintf(stderr, "slice below monitor ...\n");
2745
        return -1;
2746
    }
2747

    
2748
    s->mb_num_left= mb_num;
2749
        
2750
    if(s->pict_type==I_TYPE){
2751
        if(get_bits(&s->gb, 19)!=DC_MARKER){
2752
            fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
2753
            return -1;
2754
        }else
2755
            s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END|DC_END;
2756
    }else{
2757
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
2758
            fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
2759
            return -1;
2760
        }else
2761
            s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END;
2762
    }
2763
    
2764
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
2765
        return -1;
2766
    }
2767
    
2768
    s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= DC_END;
2769

    
2770
    return 0;        
2771
}
2772

    
2773
/**
2774
 * decode partition C of one MB.
2775
 * @return <0 if an error occured
2776
 */
2777
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
2778
{
2779
    int cbp, mb_type;
2780
    const int xy= s->mb_x + s->mb_y*s->mb_width;
2781

    
2782
    mb_type= s->mb_type[xy];
2783
    cbp = s->cbp_table[xy];
2784

    
2785
    if(s->qscale_table[xy] != s->qscale){
2786
        s->qscale= s->qscale_table[xy];
2787
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2788
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2789
    }
2790
    
2791
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2792
        int i;
2793
        for(i=0; i<4; i++){
2794
            s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
2795
            s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
2796
        }
2797
        s->mb_intra = mb_type&MB_TYPE_INTRA;
2798

    
2799
        if (mb_type&MB_TYPE_SKIPED) {
2800
            /* skip mb */
2801
            for(i=0;i<6;i++)
2802
                s->block_last_index[i] = -1;
2803
            s->mv_dir = MV_DIR_FORWARD;
2804
            s->mv_type = MV_TYPE_16X16;
2805
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2806
                s->mcsel=1;
2807
                s->mb_skiped = 0;
2808
            }else{
2809
                s->mcsel=0;
2810
                s->mb_skiped = 1;
2811
            }
2812
        }else if(s->mb_intra){
2813
            s->ac_pred = s->pred_dir_table[xy]>>7;
2814

    
2815
            /* decode each block */
2816
            for (i = 0; i < 6; i++) {
2817
                if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
2818
                    fprintf(stderr, "texture corrupted at %d %d\n", s->mb_x, s->mb_y);
2819
                    return -1;
2820
                }
2821
                cbp+=cbp;
2822
            }
2823
        }else if(!s->mb_intra){
2824
//            s->mcsel= 0; //FIXME do we need to init that
2825
            
2826
            s->mv_dir = MV_DIR_FORWARD;
2827
            if (mb_type&MB_TYPE_INTER4V) {
2828
                s->mv_type = MV_TYPE_8X8;
2829
            } else {
2830
                s->mv_type = MV_TYPE_16X16;
2831
            }
2832
            /* decode each block */
2833
            for (i = 0; i < 6; i++) {
2834
                if(mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0){
2835
                    fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2836
                    return -1;
2837
                }
2838
                cbp+=cbp;
2839
            }
2840
        }
2841
    } else { /* I-Frame */
2842
        int i;
2843
        s->mb_intra = 1;
2844
        s->ac_pred = s->pred_dir_table[xy]>>7;
2845
        
2846
        /* decode each block */
2847
        for (i = 0; i < 6; i++) {
2848
            if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
2849
                fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
2850
                return -1;
2851
            }
2852
            cbp+=cbp;
2853
        }
2854
    }
2855

    
2856
    s->error_status_table[xy]&= ~AC_ERROR;
2857

    
2858
    /* per-MB end of slice check */
2859

    
2860
    if(--s->mb_num_left <= 0){
2861
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size*8 - get_bits_count(&s->gb));
2862
        if(mpeg4_is_resync(s))
2863
            return SLICE_END;
2864
        else
2865
            return SLICE_NOEND;     
2866
    }else{
2867
        if(s->cbp_table[xy+1] && mpeg4_is_resync(s))
2868
            return SLICE_END;
2869
        else
2870
            return SLICE_OK;
2871
    }
2872
}
2873

    
2874
int ff_h263_decode_mb(MpegEncContext *s,
2875
                      DCTELEM block[6][64])
2876
{
2877
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
2878
    INT16 *mot_val;
2879
    static INT8 quant_tab[4] = { -1, -2, 1, 2 };
2880

    
2881
    s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
2882

    
2883
    if(s->mb_x==0) PRINT_MB_TYPE("\n");
2884

    
2885
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2886
        if (get_bits1(&s->gb)) {
2887
            /* skip mb */
2888
            s->mb_intra = 0;
2889
            for(i=0;i<6;i++)
2890
                s->block_last_index[i] = -1;
2891
            s->mv_dir = MV_DIR_FORWARD;
2892
            s->mv_type = MV_TYPE_16X16;
2893
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2894
                PRINT_MB_TYPE("G");
2895
                s->mcsel=1;
2896
                s->mv[0][0][0]= get_amv(s, 0);
2897
                s->mv[0][0][1]= get_amv(s, 1);
2898

    
2899
                s->mb_skiped = 0;
2900
            }else{
2901
                PRINT_MB_TYPE("S");
2902
                s->mcsel=0;
2903
                s->mv[0][0][0] = 0;
2904
                s->mv[0][0][1] = 0;
2905
                s->mb_skiped = 1;
2906
            }
2907
            goto end;
2908
        }
2909
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2910
        //fprintf(stderr, "\tCBPC: %d", cbpc);
2911
        if (cbpc < 0)
2912
            return -1;
2913
        if (cbpc > 20)
2914
            cbpc+=3;
2915
        else if (cbpc == 20)
2916
            fprintf(stderr, "Stuffing !");
2917
        
2918
        dquant = cbpc & 8;
2919
        s->mb_intra = ((cbpc & 4) != 0);
2920
        if (s->mb_intra) goto intra;
2921
        
2922
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2923
            s->mcsel= get_bits1(&s->gb);
2924
        else s->mcsel= 0;
2925
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2926
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
2927
        if (dquant) {
2928
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2929
        }
2930
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
2931
            s->interlaced_dct= get_bits1(&s->gb);
2932
        
2933
        s->mv_dir = MV_DIR_FORWARD;
2934
        if ((cbpc & 16) == 0) {
2935
            if(s->mcsel){
2936
                PRINT_MB_TYPE("G");
2937
                /* 16x16 global motion prediction */
2938
                s->mv_type = MV_TYPE_16X16;
2939
                mx= get_amv(s, 0);
2940
                my= get_amv(s, 1);
2941
                s->mv[0][0][0] = mx;
2942
                s->mv[0][0][1] = my;
2943
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
2944
                PRINT_MB_TYPE("f");
2945
                /* 16x8 field motion prediction */
2946
                s->mv_type= MV_TYPE_FIELD;
2947

    
2948
                s->field_select[0][0]= get_bits1(&s->gb);
2949
                s->field_select[0][1]= get_bits1(&s->gb);
2950

    
2951
                h263_pred_motion(s, 0, &pred_x, &pred_y);
2952
                
2953
                for(i=0; i<2; i++){
2954
                    mx = h263_decode_motion(s, pred_x, s->f_code);
2955
                    if (mx >= 0xffff)
2956
                        return -1;
2957
            
2958
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
2959
                    if (my >= 0xffff)
2960
                        return -1;
2961

    
2962
                    s->mv[0][i][0] = mx;
2963
                    s->mv[0][i][1] = my;
2964
                }
2965
            }else{
2966
                PRINT_MB_TYPE("P");
2967
                /* 16x16 motion prediction */
2968
                s->mv_type = MV_TYPE_16X16;
2969
                h263_pred_motion(s, 0, &pred_x, &pred_y);
2970
                if (s->umvplus_dec)
2971
                   mx = h263p_decode_umotion(s, pred_x);
2972
                else
2973
                   mx = h263_decode_motion(s, pred_x, s->f_code);
2974
            
2975
                if (mx >= 0xffff)
2976
                    return -1;
2977
            
2978
                if (s->umvplus_dec)
2979
                   my = h263p_decode_umotion(s, pred_y);
2980
                else
2981
                   my = h263_decode_motion(s, pred_y, s->f_code);
2982
            
2983
                if (my >= 0xffff)
2984
                    return -1;
2985
                s->mv[0][0][0] = mx;
2986
                s->mv[0][0][1] = my;
2987

    
2988
                if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2989
                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
2990
            }
2991
        } else {
2992
            PRINT_MB_TYPE("4");
2993
            s->mv_type = MV_TYPE_8X8;
2994
            for(i=0;i<4;i++) {
2995
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
2996
                if (s->umvplus_dec)
2997
                  mx = h263p_decode_umotion(s, pred_x);
2998
                else
2999
                  mx = h263_decode_motion(s, pred_x, s->f_code);
3000
                if (mx >= 0xffff)
3001
                    return -1;
3002
                
3003
                if (s->umvplus_dec)
3004
                  my = h263p_decode_umotion(s, pred_y);
3005
                else    
3006
                  my = h263_decode_motion(s, pred_y, s->f_code);
3007
                if (my >= 0xffff)
3008
                    return -1;
3009
                s->mv[0][i][0] = mx;
3010
                s->mv[0][i][1] = my;
3011
                if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
3012
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3013
                mot_val[0] = mx;
3014
                mot_val[1] = my;
3015
            }
3016
        }
3017
    } else if(s->pict_type==B_TYPE) {
3018
        int modb1; // first bit of modb
3019
        int modb2; // second bit of modb
3020
        int mb_type;
3021
        uint16_t time_pp;
3022
        uint16_t time_pb;
3023
        int xy;
3024

    
3025
        s->mb_intra = 0; //B-frames never contain intra blocks
3026
        s->mcsel=0;      //     ...               true gmc blocks
3027

    
3028
        if(s->mb_x==0){
3029
            for(i=0; i<2; i++){
3030
                s->last_mv[i][0][0]= 
3031
                s->last_mv[i][0][1]= 
3032
                s->last_mv[i][1][0]= 
3033
                s->last_mv[i][1][1]= 0;
3034
            }
3035
        }
3036

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

    
3040
        if(s->mb_skiped){
3041
                /* skip mb */
3042
            for(i=0;i<6;i++)
3043
                s->block_last_index[i] = -1;
3044

    
3045
            s->mv_dir = MV_DIR_FORWARD;
3046
            s->mv_type = MV_TYPE_16X16;
3047
            s->mv[0][0][0] = 0;
3048
            s->mv[0][0][1] = 0;
3049
            s->mv[1][0][0] = 0;
3050
            s->mv[1][0][1] = 0;
3051
            PRINT_MB_TYPE("s");
3052
            goto end;
3053
        }
3054

    
3055
        modb1= get_bits1(&s->gb); 
3056
        if(modb1){
3057
            mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
3058
            cbp=0;
3059
        }else{
3060
            int field_mv;
3061
        
3062
            modb2= get_bits1(&s->gb);
3063
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3064
            if(modb2) cbp= 0;
3065
            else      cbp= get_bits(&s->gb, 6);
3066

    
3067
            if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
3068
                if(get_bits1(&s->gb)){
3069
                    change_qscale(s, get_bits1(&s->gb)*4 - 2);
3070
                }
3071
            }
3072
            field_mv=0;
3073

    
3074
            if(!s->progressive_sequence){
3075
                if(cbp)
3076
                    s->interlaced_dct= get_bits1(&s->gb);
3077

    
3078
                if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
3079
                    field_mv=1;
3080

    
3081
                    if(mb_type!=MB_TYPE_B_BACKW){
3082
                        s->field_select[0][0]= get_bits1(&s->gb);
3083
                        s->field_select[0][1]= get_bits1(&s->gb);
3084
                    }
3085
                    if(mb_type!=MB_TYPE_B_FORW){
3086
                        s->field_select[1][0]= get_bits1(&s->gb);
3087
                        s->field_select[1][1]= get_bits1(&s->gb);
3088
                    }
3089
                }
3090
            }
3091

    
3092
            s->mv_dir = 0;
3093
            if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
3094
                s->mv_type= MV_TYPE_16X16;
3095
                if(mb_type!=MB_TYPE_B_BACKW){
3096
                    s->mv_dir = MV_DIR_FORWARD;
3097

    
3098
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3099
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3100
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3101
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3102
                }
3103
    
3104
                if(mb_type!=MB_TYPE_B_FORW){
3105
                    s->mv_dir |= MV_DIR_BACKWARD;
3106

    
3107
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3108
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3109
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3110
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3111
                }
3112
                if(mb_type!=MB_TYPE_B_DIRECT)
3113
                    PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "F" : (mb_type==MB_TYPE_B_BACKW ? "B" : "T"));
3114
            }else if(mb_type!=MB_TYPE_B_DIRECT){
3115
                s->mv_type= MV_TYPE_FIELD;
3116

    
3117
                if(mb_type!=MB_TYPE_B_BACKW){
3118
                    s->mv_dir = MV_DIR_FORWARD;
3119
                
3120
                    for(i=0; i<2; i++){
3121
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3122
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3123
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3124
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3125
                    }
3126
                }
3127
    
3128
                if(mb_type!=MB_TYPE_B_FORW){
3129
                    s->mv_dir |= MV_DIR_BACKWARD;
3130

    
3131
                    for(i=0; i<2; i++){
3132
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
3133
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3134
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
3135
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3136
                    }
3137
                }
3138
                if(mb_type!=MB_TYPE_B_DIRECT)
3139
                    PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "f" : (mb_type==MB_TYPE_B_BACKW ? "b" : "t"));
3140
            }
3141
        }
3142
          
3143
        if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
3144
            int mb_index= s->mb_x + s->mb_y*s->mb_width;
3145
            int i;
3146
            
3147
            if(mb_type==4)
3148
                mx=my=0;
3149
            else{
3150
                mx = h263_decode_motion(s, 0, 1);
3151
                my = h263_decode_motion(s, 0, 1);
3152
            }
3153
 
3154
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3155
            xy= s->block_index[0];
3156
            time_pp= s->pp_time;
3157
            time_pb= s->pb_time;
3158
            
3159
            //FIXME avoid divides
3160
            switch(s->co_located_type_table[mb_index]){
3161
            case 0:
3162
                s->mv_type= MV_TYPE_16X16;
3163
                s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
3164
                s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
3165
                s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
3166
                                    : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
3167
                s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
3168
                                    : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
3169
                PRINT_MB_TYPE(mb_type==4 ? "D" : "S");
3170
                break;
3171
            case CO_LOCATED_TYPE_4MV:
3172
                s->mv_type = MV_TYPE_8X8;
3173
                for(i=0; i<4; i++){
3174
                    xy= s->block_index[i];
3175
                    s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
3176
                    s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
3177
                    s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
3178
                                        : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
3179
                    s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1] 
3180
                                        : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
3181
                }
3182
                PRINT_MB_TYPE("4");
3183
                break;
3184
            case CO_LOCATED_TYPE_FIELDMV:
3185
                s->mv_type = MV_TYPE_FIELD;
3186
                for(i=0; i<2; i++){
3187
                    if(s->top_field_first){
3188
                        time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
3189
                        time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
3190
                    }else{
3191
                        time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
3192
                        time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
3193
                    }
3194
                    s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
3195
                    s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
3196
                    s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
3197
                                        : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
3198
                    s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] 
3199
                                        : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
3200
                }
3201
                PRINT_MB_TYPE("=");
3202
                break;
3203
            }
3204
        }
3205
        
3206
        if(mb_type<0 || mb_type>4){
3207
            printf("illegal MB_type\n");
3208
            return -1;
3209
        }
3210
    } else { /* I-Frame */
3211
        cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
3212
        if (cbpc < 0)
3213
            return -1;
3214
        dquant = cbpc & 4;
3215
        s->mb_intra = 1;
3216
intra:
3217
        s->ac_pred = 0;
3218
        if (s->h263_pred || s->h263_aic) {
3219
            s->ac_pred = get_bits1(&s->gb);
3220
            if (s->ac_pred && s->h263_aic)
3221
                s->h263_aic_dir = get_bits1(&s->gb);
3222
        }
3223
        PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
3224
        
3225
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3226
        if(cbpy<0) return -1;
3227
        cbp = (cbpc & 3) | (cbpy << 2);
3228
        if (dquant) {
3229
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3230
        }
3231
        
3232
        if(!s->progressive_sequence)
3233
            s->interlaced_dct= get_bits1(&s->gb);
3234

    
3235
        /* decode each block */
3236
        if (s->h263_pred) {
3237
            for (i = 0; i < 6; i++) {
3238
                if (mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0)
3239
                    return -1;
3240
                cbp+=cbp;
3241
            }
3242
        } else {
3243
            for (i = 0; i < 6; i++) {
3244
                if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3245
                    return -1;
3246
                cbp+=cbp;
3247
            }
3248
        }
3249
        goto end;
3250
    }
3251

    
3252
    /* decode each block */
3253
    if (s->h263_pred) {
3254
        for (i = 0; i < 6; i++) {
3255
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0)
3256
                return -1;
3257
            cbp+=cbp;
3258
        }
3259
    } else {
3260
        for (i = 0; i < 6; i++) {
3261
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3262
                return -1;
3263
            cbp+=cbp;
3264
        }
3265
    }
3266
end:
3267

    
3268
        /* per-MB end of slice check */
3269
    if(s->codec_id==CODEC_ID_MPEG4){
3270
        if(mpeg4_is_resync(s)){
3271
            if(s->pict_type==B_TYPE && s->mbskip_table[s->mb_y * s->mb_width + s->mb_x+1])
3272
                return SLICE_OK;
3273
            return SLICE_END;
3274
        }
3275
    }else{
3276
        if(get_bits_count(&s->gb) + 7 >= s->gb.size*8){
3277
            int v= show_bits(&s->gb, 8) >> (((get_bits_count(&s->gb)-1)&7)+1);
3278
            if(v==0)
3279
                return SLICE_END;
3280
        }else{
3281
            if(show_bits(&s->gb, 16)==0)
3282
                return SLICE_END; 
3283
        }
3284
    }
3285

    
3286
    return SLICE_OK;     
3287
}
3288

    
3289
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3290
{
3291
    int code, val, sign, shift, l;
3292
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3293
    if (code < 0)
3294
        return 0xffff;
3295

    
3296
    if (code == 0)
3297
        return pred;
3298

    
3299
    sign = get_bits1(&s->gb);
3300
    shift = f_code - 1;
3301
    val = (code - 1) << shift;
3302
    if (shift > 0)
3303
        val |= get_bits(&s->gb, shift);
3304
    val++;
3305
    if (sign)
3306
        val = -val;
3307
    val += pred;
3308

    
3309
    /* modulo decoding */
3310
    if (!s->h263_long_vectors) {
3311
        l = 1 << (f_code + 4);
3312
        if (val < -l) {
3313
            val += l<<1;
3314
        } else if (val >= l) {
3315
            val -= l<<1;
3316
        }
3317
    } else {
3318
        /* horrible h263 long vector mode */
3319
        if (pred < -31 && val < -63)
3320
            val += 64;
3321
        if (pred > 32 && val > 63)
3322
            val -= 64;
3323
        
3324
    }
3325
    return val;
3326
}
3327

    
3328
/* Decodes RVLC of H.263+ UMV */
3329
static int h263p_decode_umotion(MpegEncContext * s, int pred)
3330
{
3331
   int code = 0, sign;
3332
   
3333
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
3334
      return pred;
3335
   
3336
   code = 2 + get_bits1(&s->gb);
3337
   
3338
   while (get_bits1(&s->gb))
3339
   {
3340
      code <<= 1;
3341
      code += get_bits1(&s->gb);
3342
   }
3343
   sign = code & 1;
3344
   code >>= 1;
3345
   
3346
   code = (sign) ? (pred - code) : (pred + code);
3347
#ifdef DEBUG
3348
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3349
#endif
3350
   return code;   
3351

    
3352
}
3353

    
3354
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3355
                             int n, int coded)
3356
{
3357
    int code, level, i, j, last, run;
3358
    RLTable *rl = &rl_inter;
3359
    const UINT8 *scan_table;
3360

    
3361
    scan_table = s->intra_scantable.permutated;
3362
    if (s->h263_aic && s->mb_intra) {
3363
        rl = &rl_intra_aic;
3364
        i = 0;
3365
        if (s->ac_pred) {
3366
            if (s->h263_aic_dir) 
3367
                scan_table = s->intra_v_scantable.permutated; /* left */
3368
            else
3369
                scan_table = s->intra_h_scantable.permutated; /* top */
3370
        }
3371
    } else if (s->mb_intra) {
3372
        /* DC coef */
3373
        if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
3374
            int component, diff;
3375
            component = (n <= 3 ? 0 : n - 4 + 1);
3376
            level = s->last_dc[component];
3377
            if (s->rv10_first_dc_coded[component]) {
3378
                diff = rv_decode_dc(s, n);
3379
                if (diff == 0xffff)
3380
                    return -1;
3381
                level += diff;
3382
                level = level & 0xff; /* handle wrap round */
3383
                s->last_dc[component] = level;
3384
            } else {
3385
                s->rv10_first_dc_coded[component] = 1;
3386
            }
3387
        } else {
3388
            level = get_bits(&s->gb, 8);
3389
            if (level == 255)
3390
                level = 128;
3391
        }
3392
        block[0] = level;
3393
        i = 1;
3394
    } else {
3395
        i = 0;
3396
    }
3397
    if (!coded) {
3398
        if (s->mb_intra && s->h263_aic)
3399
            goto not_coded;
3400
        s->block_last_index[n] = i - 1;
3401
        return 0;
3402
    }
3403

    
3404
    for(;;) {
3405
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3406
        if (code < 0){
3407
            fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3408
            return -1;
3409
        }
3410
        if (code == rl->n) {
3411
            /* escape */
3412
            last = get_bits1(&s->gb);
3413
            run = get_bits(&s->gb, 6);
3414
            level = (INT8)get_bits(&s->gb, 8);
3415
            if (s->h263_rv10 && level == -128) {
3416
                /* XXX: should patch encoder too */
3417
                level = get_bits(&s->gb, 12);
3418
                level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
3419
            }
3420
        } else {
3421
            run = rl->table_run[code];
3422
            level = rl->table_level[code];
3423
            last = code >= rl->last;
3424
            if (get_bits1(&s->gb))
3425
                level = -level;
3426
        }
3427
        i += run;
3428
        if (i >= 64){
3429
            fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
3430
            return -1;
3431
        }
3432
        j = scan_table[i];
3433
        block[j] = level;
3434
        if (last)
3435
            break;
3436
        i++;
3437
    }
3438
not_coded:    
3439
    if (s->mb_intra && s->h263_aic) {
3440
        h263_pred_acdc(s, block, n);
3441
        i = 63;
3442
    }
3443
    s->block_last_index[n] = i;
3444
    return 0;
3445
}
3446

    
3447
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3448
{
3449
    int level, pred, code;
3450
    UINT16 *dc_val;
3451

    
3452
    if (n < 4) 
3453
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3454
    else 
3455
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3456
    if (code < 0 || code > 9 /* && s->nbit<9 */){
3457
        fprintf(stderr, "illegal dc vlc\n");
3458
        return -1;
3459
    }
3460
    if (code == 0) {
3461
        level = 0;
3462
    } else {
3463
        level = get_bits(&s->gb, code);
3464
        if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
3465
            level = - (level ^ ((1 << code) - 1));
3466
        if (code > 8){
3467
            if(get_bits1(&s->gb)==0){ /* marker */
3468
                if(s->error_resilience>=2){
3469
                    fprintf(stderr, "dc marker bit missing\n");
3470
                    return -1;
3471
                }
3472
            }
3473
        }
3474
    }
3475
    pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3476
    level += pred;
3477
    if (level < 0){
3478
        if(s->error_resilience>=3){
3479
            fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3480
            return -1;
3481
        }
3482
        level = 0;
3483
    }
3484
    if (n < 4) {
3485
        *dc_val = level * s->y_dc_scale;
3486
    } else {
3487
        *dc_val = level * s->c_dc_scale;
3488
    }
3489
    if(s->error_resilience>=3){
3490
        if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3491
            fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3492
            return -1;
3493
        }
3494
    }
3495
    return level;
3496
}
3497

    
3498
/**
3499
 * decodes a block.
3500
 * @return <0 if an error occured
3501
 */
3502
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3503
                              int n, int coded, int intra)
3504
{
3505
    int level, i, last, run;
3506
    int dc_pred_dir;
3507
    RLTable * rl;
3508
    RL_VLC_ELEM * rl_vlc;
3509
    const UINT8 * scan_table;
3510
    int qmul, qadd;
3511

    
3512
    if(intra) {
3513
        /* DC coef */
3514
        if(s->partitioned_frame){
3515
            level = s->dc_val[0][ s->block_index[n] ];
3516
            if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
3517
            else    level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
3518
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
3519
        }else{
3520
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3521
            if (level < 0)
3522
                return -1;
3523
        }
3524
        block[0] = level;
3525
        i = 0;
3526
        if (!coded) 
3527
            goto not_coded;
3528
        rl = &rl_intra;
3529
        rl_vlc = rl_intra.rl_vlc[0];
3530
        if (s->ac_pred) {
3531
            if (dc_pred_dir == 0) 
3532
                scan_table = s->intra_v_scantable.permutated; /* left */
3533
            else
3534
                scan_table = s->intra_h_scantable.permutated; /* top */
3535
        } else {
3536
            scan_table = s->intra_scantable.permutated;
3537
        }
3538
        qmul=1;
3539
        qadd=0;
3540
    } else {
3541
        i = -1;
3542
        if (!coded) {
3543
            s->block_last_index[n] = i;
3544
            return 0;
3545
        }
3546
        rl = &rl_inter;
3547
   
3548
        scan_table = s->intra_scantable.permutated;
3549

    
3550
        if(s->mpeg_quant){
3551
            qmul=1;
3552
            qadd=0;
3553
            rl_vlc = rl_inter.rl_vlc[0];        
3554
        }else{
3555
            qmul = s->qscale << 1;
3556
            qadd = (s->qscale - 1) | 1;
3557
            rl_vlc = rl_inter.rl_vlc[s->qscale];
3558
        }
3559
    }
3560
  {
3561
    OPEN_READER(re, &s->gb);
3562
    for(;;) {
3563
        UPDATE_CACHE(re, &s->gb);
3564
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3565
        if (level==0) {
3566
            int cache;
3567
            cache= GET_CACHE(re, &s->gb);
3568
            /* escape */
3569
            if (cache&0x80000000) {
3570
                if (cache&0x40000000) {
3571
                    /* third escape */
3572
                    SKIP_CACHE(re, &s->gb, 2);
3573
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3574
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3575
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
3576
                    UPDATE_CACHE(re, &s->gb);
3577

    
3578
                    if(SHOW_UBITS(re, &s->gb, 1)==0){
3579
                        fprintf(stderr, "1. marker bit missing in 3. esc\n");
3580
                        return -1;
3581
                    }; SKIP_CACHE(re, &s->gb, 1);
3582
                    
3583
                    level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3584
 
3585
                    if(SHOW_UBITS(re, &s->gb, 1)==0){
3586
                        fprintf(stderr, "2. marker bit missing in 3. esc\n");
3587
                        return -1;
3588
                    }; LAST_SKIP_CACHE(re, &s->gb, 1);
3589
                    
3590
                    SKIP_COUNTER(re, &s->gb, 1+12+1);
3591
                    
3592
                    if(level*s->qscale>1024 || level*s->qscale<-1024){
3593
                        fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3594
                        return -1;
3595
                    }
3596
#if 1 
3597
                    {
3598
                        const int abs_level= ABS(level);
3599
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN && ((s->workaround_bugs&FF_BUG_AC_VLC)==0)){
3600
                            const int run1= run - rl->max_run[last][abs_level] - 1;
3601
                            if(abs_level <= rl->max_level[last][run]){
3602
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3603
                                return -1;
3604
                            }
3605
                            if(abs_level <= rl->max_level[last][run]*2){
3606
                                fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3607
                                return -1;
3608
                            }
3609
                            if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3610
                                fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3611
                                return -1;
3612
                            }
3613
                        }
3614
                    }
3615
#endif
3616
                    if (level>0) level= level * qmul + qadd;
3617
                    else         level= level * qmul - qadd;
3618

    
3619
                    i+= run + 1;
3620
                    if(last) i+=192;
3621
                } else {
3622
                    /* second escape */
3623
#if MIN_CACHE_BITS < 20
3624
                    LAST_SKIP_BITS(re, &s->gb, 2);
3625
                    UPDATE_CACHE(re, &s->gb);
3626
#else
3627
                    SKIP_BITS(re, &s->gb, 2);
3628
#endif
3629
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3630
                    i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3631
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3632
                    LAST_SKIP_BITS(re, &s->gb, 1);
3633
                }
3634
            } else {
3635
                /* first escape */
3636
#if MIN_CACHE_BITS < 19
3637
                LAST_SKIP_BITS(re, &s->gb, 1);
3638
                UPDATE_CACHE(re, &s->gb);
3639
#else
3640
                SKIP_BITS(re, &s->gb, 1);
3641
#endif
3642
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3643
                i+= run;
3644
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3645
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3646
                LAST_SKIP_BITS(re, &s->gb, 1);
3647
            }
3648
        } else {
3649
            i+= run;
3650
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3651
            LAST_SKIP_BITS(re, &s->gb, 1);
3652
        }
3653
        if (i > 62){
3654
            i-= 192;
3655
            if(i&(~63)){
3656
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3657
                return -1;
3658
            }
3659

    
3660
            block[scan_table[i]] = level;
3661
            break;
3662
        }
3663

    
3664
        block[scan_table[i]] = level;
3665
    }
3666
    CLOSE_READER(re, &s->gb);
3667
  }
3668
 not_coded:
3669
    if (s->mb_intra) {
3670
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
3671
        if (s->ac_pred) {
3672
            i = 63; /* XXX: not optimal */
3673
        }
3674
    }
3675
    s->block_last_index[n] = i;
3676
    return 0;
3677
}
3678

    
3679
/* most is hardcoded. should extend to handle all h263 streams */
3680
int h263_decode_picture_header(MpegEncContext *s)
3681
{
3682
    int format, width, height;
3683

    
3684
    /* picture start code */
3685
    if (get_bits(&s->gb, 22) != 0x20) {
3686
        fprintf(stderr, "Bad picture start code\n");
3687
        return -1;
3688
    }
3689
    /* temporal reference */
3690
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3691

    
3692
    /* PTYPE starts here */    
3693
    if (get_bits1(&s->gb) != 1) {
3694
        /* marker */
3695
        fprintf(stderr, "Bad marker\n");
3696
        return -1;
3697
    }
3698
    if (get_bits1(&s->gb) != 0) {
3699
        fprintf(stderr, "Bad H263 id\n");
3700
        return -1;        /* h263 id */
3701
    }
3702
    skip_bits1(&s->gb);        /* split screen off */
3703
    skip_bits1(&s->gb);        /* camera  off */
3704
    skip_bits1(&s->gb);        /* freeze picture release off */
3705

    
3706
    /* Reset GOB number */
3707
    s->gob_number = 0;
3708
        
3709
    format = get_bits(&s->gb, 3);
3710
    /*
3711
        0    forbidden
3712
        1    sub-QCIF
3713
        10   QCIF
3714
        7        extended PTYPE (PLUSPTYPE)
3715
    */
3716

    
3717
    if (format != 7 && format != 6) {
3718
        s->h263_plus = 0;
3719
        /* H.263v1 */
3720
        width = h263_format[format][0];
3721
        height = h263_format[format][1];
3722
        if (!width)
3723
            return -1;
3724
        
3725
        s->width = width;
3726
        s->height = height;
3727
        s->pict_type = I_TYPE + get_bits1(&s->gb);
3728

    
3729
        s->unrestricted_mv = get_bits1(&s->gb); 
3730
        s->h263_long_vectors = s->unrestricted_mv;
3731

    
3732
        if (get_bits1(&s->gb) != 0) {
3733
            fprintf(stderr, "H263 SAC not supported\n");
3734
            return -1;        /* SAC: off */
3735
        }
3736
        if (get_bits1(&s->gb) != 0) {
3737
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3738
        }   
3739
        
3740
        if (get_bits1(&s->gb) != 0) {
3741
            fprintf(stderr, "H263 PB frame not supported\n");
3742
            return -1;        /* not PB frame */
3743
        }
3744
        s->qscale = get_bits(&s->gb, 5);
3745
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
3746
    } else {
3747
        int ufep;
3748
        
3749
        /* H.263v2 */
3750
        s->h263_plus = 1;
3751
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3752

    
3753
        /* ufep other than 0 and 1 are reserved */        
3754
        if (ufep == 1) {
3755
            /* OPPTYPE */       
3756
            format = get_bits(&s->gb, 3);
3757
            dprintf("ufep=1, format: %d\n", format);
3758
            skip_bits(&s->gb,1); /* Custom PCF */
3759
            s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3760
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3761
            if (get_bits1(&s->gb) != 0) {
3762
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3763
            }
3764
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3765
                s->h263_aic = 1;
3766
            }
3767
            
3768
            skip_bits(&s->gb, 7);
3769
            /* these are the 7 bits: (in order of appearence  */
3770
            /* Deblocking Filter */
3771
            /* Slice Structured */
3772
            /* Reference Picture Selection */
3773
            /* Independent Segment Decoding */
3774
            /* Alternative Inter VLC */
3775
            /* Modified Quantization */
3776
            /* Prevent start code emulation */
3777

    
3778
            skip_bits(&s->gb, 3); /* Reserved */
3779
        } else if (ufep != 0) {
3780
            fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3781
            return -1;
3782
        }
3783
            
3784
        /* MPPTYPE */
3785
        s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3786
        dprintf("pict_type: %d\n", s->pict_type);
3787
        if (s->pict_type != I_TYPE &&
3788
            s->pict_type != P_TYPE)
3789
            return -1;
3790
        skip_bits(&s->gb, 2);
3791
        s->no_rounding = get_bits1(&s->gb);
3792
        dprintf("RTYPE: %d\n", s->no_rounding);
3793
        skip_bits(&s->gb, 4);
3794
        
3795
        /* Get the picture dimensions */
3796
        if (ufep) {
3797
            if (format == 6) {
3798
                /* Custom Picture Format (CPFMT) */
3799
                s->aspect_ratio_info = get_bits(&s->gb, 4);
3800
                dprintf("aspect: %d\n", s->aspect_ratio_info);
3801
                /* aspect ratios:
3802
                0 - forbidden
3803
                1 - 1:1
3804
                2 - 12:11 (CIF 4:3)
3805
                3 - 10:11 (525-type 4:3)
3806
                4 - 16:11 (CIF 16:9)
3807
                5 - 40:33 (525-type 16:9)
3808
                6-14 - reserved
3809
                */
3810
                width = (get_bits(&s->gb, 9) + 1) * 4;
3811
                skip_bits1(&s->gb);
3812
                height = get_bits(&s->gb, 9) * 4;
3813
                dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
3814
                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
3815
                    /* aspected dimensions */
3816
                    s->aspected_width = get_bits(&s->gb, 8);
3817
                    s->aspected_height = get_bits(&s->gb, 8);
3818
                }
3819
            } else {
3820
                width = h263_format[format][0];
3821
                height = h263_format[format][1];
3822
            }
3823
            if ((width == 0) || (height == 0))
3824
                return -1;
3825
            s->width = width;
3826
            s->height = height;
3827
            if (s->umvplus_dec) {
3828
                skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
3829
            }
3830
        }
3831
            
3832
        s->qscale = get_bits(&s->gb, 5);
3833
    }
3834
    /* PEI */
3835
    while (get_bits1(&s->gb) != 0) {
3836
        skip_bits(&s->gb, 8);
3837
    }
3838
    s->f_code = 1;
3839
    
3840
    if(s->h263_aic){
3841
         s->y_dc_scale_table= 
3842
         s->c_dc_scale_table= h263_aic_dc_scale_table;
3843
    }else{
3844
        s->y_dc_scale_table=
3845
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
3846
    }
3847

    
3848
    return 0;
3849
}
3850

    
3851
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
3852
{
3853
    int i;
3854
    int a= 2<<s->sprite_warping_accuracy;
3855
    int rho= 3-s->sprite_warping_accuracy;
3856
    int r=16/a;
3857
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
3858
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
3859
    int sprite_ref[4][2];
3860
    int virtual_ref[2][2];
3861
    int w2, h2, w3, h3;
3862
    int alpha=0, beta=0;
3863
    int w= s->width;
3864
    int h= s->height;
3865
    int min_ab;
3866

    
3867
    for(i=0; i<s->num_sprite_warping_points; i++){
3868
        int length;
3869
        int x=0, y=0;
3870

    
3871
        length= get_vlc(&s->gb, &sprite_trajectory);
3872
        if(length){
3873
            x= get_bits(&s->gb, length);
3874

    
3875
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
3876
                x = - (x ^ ((1 << length) - 1));
3877
        }
3878
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
3879
        
3880
        length= get_vlc(&s->gb, &sprite_trajectory);
3881
        if(length){
3882
            y=get_bits(&s->gb, length);
3883

    
3884
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
3885
                y = - (y ^ ((1 << length) - 1));
3886
        }
3887
        skip_bits1(&s->gb); /* marker bit */
3888
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
3889
        d[i][0]= x;
3890
        d[i][1]= y;
3891
    }
3892

    
3893
    while((1<<alpha)<w) alpha++;
3894
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
3895
    w2= 1<<alpha;
3896
    h2= 1<<beta;
3897

    
3898
// Note, the 4th point isnt used for GMC
3899
    if(s->divx_version==500 && s->divx_build==413){
3900
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
3901
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
3902
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
3903
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
3904
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
3905
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
3906
    } else {
3907
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
3908
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
3909
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
3910
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
3911
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
3912
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
3913
    }
3914
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
3915
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
3916
    
3917
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
3918
// perhaps it should be reordered to be more readable ...
3919
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
3920
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
3921
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
3922
        + 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);
3923
    virtual_ref[0][1]= 16*vop_ref[0][1] 
3924
        + 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);
3925
    virtual_ref[1][0]= 16*vop_ref[0][0] 
3926
        + 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);
3927
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
3928
        + 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);
3929
        
3930
    switch(s->num_sprite_warping_points)
3931
    {
3932
        case 0:
3933
            s->sprite_offset[0][0]= 0;
3934
            s->sprite_offset[0][1]= 0;
3935
            s->sprite_offset[1][0]= 0;
3936
            s->sprite_offset[1][1]= 0;
3937
            s->sprite_delta[0][0]= a;
3938
            s->sprite_delta[0][1]= 0;
3939
            s->sprite_delta[1][0]= 0;
3940
            s->sprite_delta[1][1]= a;
3941
            s->sprite_shift[0]= 0;
3942
            s->sprite_shift[1]= 0;
3943
            break;
3944
        case 1: //GMC only
3945
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
3946
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
3947
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
3948
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
3949
            s->sprite_delta[0][0]= a;
3950
            s->sprite_delta[0][1]= 0;
3951
            s->sprite_delta[1][0]= 0;
3952
            s->sprite_delta[1][1]= a;
3953
            s->sprite_shift[0]= 0;
3954
            s->sprite_shift[1]= 0;
3955
            break;
3956
        case 2:
3957
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
3958
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
3959
                                                  + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
3960
                                                  + (1<<(alpha+rho-1));
3961
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
3962
                                                  + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
3963
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
3964
                                                  + (1<<(alpha+rho-1));
3965
            s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
3966
                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
3967
                                     +2*w2*r*sprite_ref[0][0] 
3968
                                     - 16*w2 
3969
                                     + (1<<(alpha+rho+1)));
3970
            s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
3971
                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
3972
                                     +2*w2*r*sprite_ref[0][1] 
3973
                                     - 16*w2
3974
                                     + (1<<(alpha+rho+1)));
3975
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3976
            s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
3977
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
3978
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3979
            
3980
            s->sprite_shift[0]= alpha+rho;
3981
            s->sprite_shift[1]= alpha+rho+2;
3982
            break;
3983
        case 3:
3984
            min_ab= MIN(alpha, beta);
3985
            w3= w2>>min_ab;
3986
            h3= h2>>min_ab;
3987
            s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
3988
                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
3989
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
3990
                                   + (1<<(alpha+beta+rho-min_ab-1));
3991
            s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
3992
                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
3993
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
3994
                                   + (1<<(alpha+beta+rho-min_ab-1));
3995
            s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
3996
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
3997
                                   + 2*w2*h3*r*sprite_ref[0][0]
3998
                                   - 16*w2*h3
3999
                                   + (1<<(alpha+beta+rho-min_ab+1));
4000
            s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4001
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4002
                                   + 2*w2*h3*r*sprite_ref[0][1]
4003
                                   - 16*w2*h3
4004
                                   + (1<<(alpha+beta+rho-min_ab+1));
4005
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4006
            s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4007
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4008
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4009
                                   
4010
            s->sprite_shift[0]= alpha + beta + rho - min_ab;
4011
            s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4012
            break;
4013
    }
4014
    /* try to simplify the situation */ 
4015
    if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4016
       && s->sprite_delta[0][1] == 0
4017
       && s->sprite_delta[1][0] == 0
4018
       && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4019
    {
4020
        s->sprite_offset[0][0]>>=s->sprite_shift[0];
4021
        s->sprite_offset[0][1]>>=s->sprite_shift[0];
4022
        s->sprite_offset[1][0]>>=s->sprite_shift[1];
4023
        s->sprite_offset[1][1]>>=s->sprite_shift[1];
4024
        s->sprite_delta[0][0]= a;
4025
        s->sprite_delta[0][1]= 0;
4026
        s->sprite_delta[1][0]= 0;
4027
        s->sprite_delta[1][1]= a;
4028
        s->sprite_shift[0]= 0;
4029
        s->sprite_shift[1]= 0;
4030
        s->real_sprite_warping_points=1;
4031
    }
4032
    else{
4033
        int shift_y= 16 - s->sprite_shift[0];
4034
        int shift_c= 16 - s->sprite_shift[1];
4035
//printf("shifts %d %d\n", shift_y, shift_c);
4036
        for(i=0; i<2; i++){
4037
            s->sprite_offset[0][i]<<= shift_y;
4038
            s->sprite_offset[1][i]<<= shift_c;
4039
            s->sprite_delta[0][i]<<= shift_y;
4040
            s->sprite_delta[1][i]<<= shift_y;
4041
            s->sprite_shift[i]= 16;
4042
        }
4043
        s->real_sprite_warping_points= s->num_sprite_warping_points;
4044
    }
4045
#if 0
4046
printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4047
    vop_ref[0][0], vop_ref[0][1],
4048
    vop_ref[1][0], vop_ref[1][1],
4049
    vop_ref[2][0], vop_ref[2][1],
4050
    sprite_ref[0][0], sprite_ref[0][1], 
4051
    sprite_ref[1][0], sprite_ref[1][1], 
4052
    sprite_ref[2][0], sprite_ref[2][1], 
4053
    virtual_ref[0][0], virtual_ref[0][1], 
4054
    virtual_ref[1][0], virtual_ref[1][1]
4055
    );
4056
    
4057
printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4058
    s->sprite_offset[0][0], s->sprite_offset[0][1],
4059
    s->sprite_delta[0][0], s->sprite_delta[0][1],
4060
    s->sprite_delta[1][0], s->sprite_delta[1][1],
4061
    s->sprite_shift[0]
4062
    );
4063
#endif
4064
}
4065

    
4066
static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4067
    int width, height, vo_ver_id;
4068

    
4069
    /* vol header */
4070
    skip_bits(gb, 1); /* random access */
4071
    s->vo_type= get_bits(gb, 8);
4072
    if (get_bits1(gb) != 0) { /* is_ol_id */
4073
        vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4074
        skip_bits(gb, 3); /* vo_priority */
4075
    } else {
4076
        vo_ver_id = 1;
4077
    }
4078
//printf("vo type:%d\n",s->vo_type);
4079
    s->aspect_ratio_info= get_bits(gb, 4);
4080
    if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){            
4081
        s->aspected_width = get_bits(gb, 8); // par_width
4082
        s->aspected_height = get_bits(gb, 8); // par_height
4083
    }
4084

    
4085
    if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4086
        int chroma_format= get_bits(gb, 2);
4087
        if(chroma_format!=1){
4088
            printf("illegal chroma format\n");
4089
        }
4090
        s->low_delay= get_bits1(gb);
4091
        if(get_bits1(gb)){ /* vbv parameters */
4092
            get_bits(gb, 15);        /* first_half_bitrate */
4093
            skip_bits1(gb);        /* marker */
4094
            get_bits(gb, 15);        /* latter_half_bitrate */
4095
            skip_bits1(gb);        /* marker */
4096
            get_bits(gb, 15);        /* first_half_vbv_buffer_size */
4097
            skip_bits1(gb);        /* marker */
4098
            get_bits(gb, 3);        /* latter_half_vbv_buffer_size */
4099
            get_bits(gb, 11);        /* first_half_vbv_occupancy */
4100
            skip_bits1(gb);        /* marker */
4101
            get_bits(gb, 15);        /* latter_half_vbv_occupancy */
4102
            skip_bits1(gb);        /* marker */               
4103
        }
4104
    }else{
4105
        // set low delay flag only once so the smart? low delay detection wont be overriden
4106
        if(s->picture_number==0)
4107
            s->low_delay=0;
4108
    }
4109

    
4110
    s->shape = get_bits(gb, 2); /* vol shape */
4111
    if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4112
    if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4113
        printf("Gray shape not supported\n");
4114
        skip_bits(gb, 4);  //video_object_layer_shape_extension
4115
    }
4116

    
4117
    skip_bits1(gb);   /* marker */
4118
    
4119
    s->time_increment_resolution = get_bits(gb, 16);
4120
    
4121
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4122
    if (s->time_increment_bits < 1)
4123
        s->time_increment_bits = 1;
4124
    skip_bits1(gb);   /* marker */
4125

    
4126
    if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
4127
        skip_bits(gb, s->time_increment_bits);
4128
    }
4129

    
4130
    if (s->shape != BIN_ONLY_SHAPE) {
4131
        if (s->shape == RECT_SHAPE) {
4132
            skip_bits1(gb);   /* marker */
4133
            width = get_bits(gb, 13);
4134
            skip_bits1(gb);   /* marker */
4135
            height = get_bits(gb, 13);
4136
            skip_bits1(gb);   /* marker */
4137
            if(width && height){ /* they should be non zero but who knows ... */
4138
                s->width = width;
4139
                s->height = height;
4140
//                printf("width/height: %d %d\n", width, height);
4141
            }
4142
        }
4143
        
4144
        s->progressive_sequence= get_bits1(gb)^1;
4145
        if(!get_bits1(gb)) printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
4146
        if (vo_ver_id == 1) {
4147
            s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4148
        } else {
4149
            s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4150
        }
4151
        if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4152
        if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4153
            if(s->vol_sprite_usage==STATIC_SPRITE){
4154
                s->sprite_width = get_bits(gb, 13);
4155
                skip_bits1(gb); /* marker */
4156
                s->sprite_height= get_bits(gb, 13);
4157
                skip_bits1(gb); /* marker */
4158
                s->sprite_left  = get_bits(gb, 13);
4159
                skip_bits1(gb); /* marker */
4160
                s->sprite_top   = get_bits(gb, 13);
4161
                skip_bits1(gb); /* marker */
4162
            }
4163
            s->num_sprite_warping_points= get_bits(gb, 6);
4164
            s->sprite_warping_accuracy = get_bits(gb, 2);
4165
            s->sprite_brightness_change= get_bits1(gb);
4166
            if(s->vol_sprite_usage==STATIC_SPRITE)
4167
                s->low_latency_sprite= get_bits1(gb);            
4168
        }
4169
        // FIXME sadct disable bit if verid!=1 && shape not rect
4170
        
4171
        if (get_bits1(gb) == 1) {   /* not_8_bit */
4172
            s->quant_precision = get_bits(gb, 4); /* quant_precision */
4173
            if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4174
            if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4175
        } else {
4176
            s->quant_precision = 5;
4177
        }
4178
        
4179
        // FIXME a bunch of grayscale shape things
4180

    
4181
        if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4182
            int i, j, v;
4183
            
4184
            /* load default matrixes */
4185
            for(i=0; i<64; i++){
4186
                int j= s->idct_permutation[i];
4187
                v= ff_mpeg4_default_intra_matrix[i];
4188
                s->intra_matrix[j]= v;
4189
                s->chroma_intra_matrix[j]= v;
4190
                
4191
                v= ff_mpeg4_default_non_intra_matrix[i];
4192
                s->inter_matrix[j]= v;
4193
                s->chroma_inter_matrix[j]= v;
4194
            }
4195

    
4196
            /* load custom intra matrix */
4197
            if(get_bits1(gb)){
4198
                int last=0;
4199
                for(i=0; i<64; i++){
4200
                    v= get_bits(gb, 8);
4201
                    if(v==0) break;
4202
                    
4203
                    last= v;
4204
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4205
                    s->intra_matrix[j]= v;
4206
                    s->chroma_intra_matrix[j]= v;
4207
                }
4208

    
4209
                /* replicate last value */
4210
                for(; i<64; i++){
4211
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4212
                    s->intra_matrix[j]= v;
4213
                    s->chroma_intra_matrix[j]= v;
4214
                }
4215
            }
4216

    
4217
            /* load custom non intra matrix */
4218
            if(get_bits1(gb)){
4219
                int last=0;
4220
                for(i=0; i<64; i++){
4221
                    v= get_bits(gb, 8);
4222
                    if(v==0) break;
4223

    
4224
                    last= v;
4225
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4226
                    s->inter_matrix[j]= v;
4227
                    s->chroma_inter_matrix[j]= v;
4228
                }
4229

    
4230
                /* replicate last value */
4231
                for(; i<64; i++){
4232
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4233
                    s->inter_matrix[j]= last;
4234
                    s->chroma_inter_matrix[j]= last;
4235
                }
4236
            }
4237

    
4238
            // FIXME a bunch of grayscale shape things
4239
        }
4240

    
4241
        if(vo_ver_id != 1)
4242
             s->quarter_sample= get_bits1(gb);
4243
        else s->quarter_sample=0;
4244

    
4245
        if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4246

    
4247
        s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4248

    
4249
        s->data_partitioning= get_bits1(gb);
4250
        if(s->data_partitioning){
4251
            s->rvlc= get_bits1(gb);
4252
            if(s->rvlc){
4253
                printf("reversible vlc not supported\n");
4254
            }
4255
        }
4256
        
4257
        if(vo_ver_id != 1) {
4258
            s->new_pred= get_bits1(gb);
4259
            if(s->new_pred){
4260
                printf("new pred not supported\n");
4261
                skip_bits(gb, 2); /* requested upstream message type */
4262
                skip_bits1(gb); /* newpred segment type */
4263
            }
4264
            s->reduced_res_vop= get_bits1(gb);
4265
            if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4266
        }
4267
        else{
4268
            s->new_pred=0;
4269
            s->reduced_res_vop= 0;
4270
        }
4271

    
4272
        s->scalability= get_bits1(gb);
4273

    
4274
        if (s->scalability) {
4275
            GetBitContext bak= *gb;
4276
            int ref_layer_id;
4277
            int ref_layer_sampling_dir;
4278
            int h_sampling_factor_n;
4279
            int h_sampling_factor_m;
4280
            int v_sampling_factor_n;
4281
            int v_sampling_factor_m;
4282
            
4283
            s->hierachy_type= get_bits1(gb);
4284
            ref_layer_id= get_bits(gb, 4);
4285
            ref_layer_sampling_dir= get_bits1(gb);
4286
            h_sampling_factor_n= get_bits(gb, 5);
4287
            h_sampling_factor_m= get_bits(gb, 5);
4288
            v_sampling_factor_n= get_bits(gb, 5);
4289
            v_sampling_factor_m= get_bits(gb, 5);
4290
            s->enhancement_type= get_bits1(gb);
4291
            
4292
            if(   h_sampling_factor_n==0 || h_sampling_factor_m==0 
4293
               || v_sampling_factor_n==0 || v_sampling_factor_m==0){
4294
               
4295
//                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4296
                s->scalability=0;
4297
               
4298
                *gb= bak;
4299
            }else
4300
                printf("scalability not supported\n");
4301
            
4302
            // bin shape stuff FIXME
4303
        }
4304
    }
4305
    return 0;
4306
}
4307

    
4308
static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
4309
    char buf[256];
4310
    int i;
4311
    int e;
4312
    int ver, build, ver2, ver3;
4313

    
4314
    buf[0]= show_bits(gb, 8);
4315
    for(i=1; i<256; i++){
4316
        buf[i]= show_bits(gb, 16)&0xFF;
4317
        if(buf[i]==0) break;
4318
        skip_bits(gb, 8);
4319
    }
4320
    buf[255]=0;
4321
    
4322
    /* divx detection */
4323
    e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
4324
    if(e!=2)
4325
        e=sscanf(buf, "DivX%db%d", &ver, &build);
4326
    if(e==2){
4327
        s->divx_version= ver;
4328
        s->divx_build= build;
4329
        if(s->picture_number==0){
4330
            printf("This file was encoded with DivX%d Build%d\n", ver, build);
4331
        }
4332
    }
4333
    
4334
    /* ffmpeg detection */
4335
    e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
4336
    if(e!=4)
4337
        e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); 
4338
    if(e!=4){
4339
        if(strcmp(buf, "ffmpeg")==0){
4340
            s->ffmpeg_version= 0x000406;
4341
            s->lavc_build= 4600;
4342
        }
4343
    }
4344
    if(e==4){
4345
        s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
4346
        s->lavc_build= build;
4347
        if(s->picture_number==0)
4348
            printf("This file was encoded with libavcodec build %d\n", build);
4349
    }
4350
    
4351
    /* xvid detection */
4352
    e=sscanf(buf, "XviD%d", &build);
4353
    if(e==1){
4354
        s->xvid_build= build;
4355
        if(s->picture_number==0)
4356
            printf("This file was encoded with XviD build %d\n", build);
4357
    }
4358

    
4359
//printf("User Data: %s\n", buf);
4360
    return 0;
4361
}
4362

    
4363
static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
4364
    int time_incr, time_increment;
4365

    
4366
    s->pict_type = get_bits(gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
4367
    if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
4368
        printf("low_delay flag set, but shouldnt, clearing it\n");
4369
        s->low_delay=0;
4370
    }
4371
 
4372
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
4373
    if(s->partitioned_frame)
4374
        s->decode_mb= mpeg4_decode_partitioned_mb;
4375
    else
4376
        s->decode_mb= ff_h263_decode_mb;
4377

    
4378
    if(s->time_increment_resolution==0){
4379
        s->time_increment_resolution=1;
4380
//        fprintf(stderr, "time_increment_resolution is illegal\n");
4381
    }
4382
    time_incr=0;
4383
    while (get_bits1(gb) != 0) 
4384
        time_incr++;
4385

    
4386
    check_marker(gb, "before time_increment");
4387
    time_increment= get_bits(gb, s->time_increment_bits);
4388
//printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4389
    if(s->pict_type!=B_TYPE){
4390
        s->last_time_base= s->time_base;
4391
        s->time_base+= time_incr;
4392
        s->time= s->time_base*s->time_increment_resolution + time_increment;
4393
        if(s->workaround_bugs&FF_BUG_UMP4){
4394
            if(s->time < s->last_non_b_time){
4395
//                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4396
                s->time_base++;
4397
                s->time+= s->time_increment_resolution;
4398
            }
4399
        }
4400
        s->pp_time= s->time - s->last_non_b_time;
4401
        s->last_non_b_time= s->time;
4402
    }else{
4403
        s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4404
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4405
        if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4406
//            printf("messed up order, seeking?, skiping current b frame\n");
4407
            return FRAME_SKIPED;
4408
        }
4409
        
4410
        if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4411
        if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4412
//printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4413
        s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame) 
4414
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4415
        s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame) 
4416
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4417
    }
4418
    
4419
    s->avctx->pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4420
    
4421
    if(check_marker(gb, "before vop_coded")==0 && s->picture_number==0){
4422
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4423
        for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
4424
            if(get_bits1(gb)) break;
4425
        }
4426
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
4427
    }
4428
    /* vop coded */
4429
    if (get_bits1(gb) != 1){
4430
        printf("vop not coded\n");
4431
        return FRAME_SKIPED;
4432
    }
4433
//printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4434
//s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);  
4435
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4436
                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4437
        /* rounding type for motion estimation */
4438
        s->no_rounding = get_bits1(gb);
4439
    } else {
4440
        s->no_rounding = 0;
4441
    }
4442
//FIXME reduced res stuff
4443

    
4444
     if (s->shape != RECT_SHAPE) {
4445
         if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4446
             int width, height, hor_spat_ref, ver_spat_ref;
4447
 
4448
             width = get_bits(gb, 13);
4449
             skip_bits1(gb);   /* marker */
4450
             height = get_bits(gb, 13);
4451
             skip_bits1(gb);   /* marker */
4452
             hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
4453
             skip_bits1(gb);   /* marker */
4454
             ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
4455
         }
4456
         skip_bits1(gb); /* change_CR_disable */
4457
 
4458
         if (get_bits1(gb) != 0) {
4459
             skip_bits(gb, 8); /* constant_alpha_value */
4460
         }
4461
     }
4462
//FIXME complexity estimation stuff
4463
     
4464
     if (s->shape != BIN_ONLY_SHAPE) {
4465
         int t;
4466
         t=get_bits(gb, 3); /* intra dc VLC threshold */
4467
//printf("threshold %d\n", t);
4468
         if(!s->progressive_sequence){
4469
             s->top_field_first= get_bits1(gb);
4470
             s->alternate_scan= get_bits1(gb);
4471
         }else
4472
             s->alternate_scan= 0;
4473
     }
4474

    
4475
     if(s->alternate_scan){
4476
         ff_init_scantable(s, &s->inter_scantable  , ff_alternate_vertical_scan);
4477
         ff_init_scantable(s, &s->intra_scantable  , ff_alternate_vertical_scan);
4478
         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
4479
         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4480
     } else{
4481
         ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
4482
         ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
4483
         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
4484
         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4485
     }
4486
 
4487
     if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
4488
         mpeg4_decode_sprite_trajectory(s);
4489
         if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
4490
         if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
4491
     }
4492

    
4493
     if (s->shape != BIN_ONLY_SHAPE) {
4494
         s->qscale = get_bits(gb, s->quant_precision);
4495
         if(s->qscale==0){
4496
             printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
4497
             return -1; // makes no sense to continue, as there is nothing left from the image then
4498
         }
4499
  
4500
         if (s->pict_type != I_TYPE) {
4501
             s->f_code = get_bits(gb, 3);        /* fcode_for */
4502
             if(s->f_code==0){
4503
                 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
4504
                 return -1; // makes no sense to continue, as the MV decoding will break very quickly
4505
             }
4506
         }else
4507
             s->f_code=1;
4508
     
4509
         if (s->pict_type == B_TYPE) {
4510
             s->b_code = get_bits(gb, 3);
4511
         }else
4512
             s->b_code=1;
4513
#if 0
4514
printf("qp:%d fc:%d bc:%d type:%s size:%d pro:%d alt:%d top:%d qpel:%d part:%d resync:%d w:%d a:%d\n", 
4515
    s->qscale, s->f_code, s->b_code, 
4516
    s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), 
4517
    gb->size,s->progressive_sequence, s->alternate_scan, s->top_field_first, 
4518
    s->quarter_sample, s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
4519
    s->sprite_warping_accuracy); 
4520
#endif
4521
         if(!s->scalability){
4522
             if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
4523
                 skip_bits1(gb); // vop shape coding type
4524
             }
4525
         }else{
4526
             if(s->enhancement_type){
4527
                 int load_backward_shape= get_bits1(gb);
4528
                 if(load_backward_shape){
4529
                     printf("load backward shape isnt supported\n");
4530
                 }
4531
             }
4532
             skip_bits(gb, 2); //ref_select_code
4533
         }
4534
     }
4535
     /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
4536
     // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
4537
     if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
4538
         printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
4539
         s->low_delay=1;
4540
     }
4541

    
4542
     s->picture_number++; // better than pic number==0 allways ;)
4543

    
4544
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
4545
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
4546

    
4547
     if(s->divx_version==0 || s->divx_version < 500){
4548
         s->h_edge_pos= s->width;
4549
         s->v_edge_pos= s->height;
4550
     }
4551
     return 0;
4552
}
4553

    
4554
/**
4555
 * decode mpeg4 headers
4556
 * @return <0 if no VOP found (or a damaged one)
4557
 *         FRAME_SKIPPED if a not coded VOP is found
4558
 *         0 if a VOP is found
4559
 */
4560
int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
4561
{
4562
    int startcode, v;
4563

    
4564
    /* search next start code */
4565
    align_get_bits(gb);
4566
    startcode = 0xff;
4567
    for(;;) {
4568
        v = get_bits(gb, 8);
4569
        startcode = ((startcode << 8) | v) & 0xffffffff;
4570
        
4571
        if(get_bits_count(gb) >= gb->size*8){
4572
            if(gb->size==1 && s->divx_version){
4573
                printf("frame skip %d\n", gb->size);
4574
                return FRAME_SKIPED; //divx bug
4575
            }else
4576
                return -1; //end of stream
4577
        }
4578

    
4579
        if((startcode&0xFFFFFF00) != 0x100)
4580
            continue; //no startcode
4581
        
4582
        switch(startcode){
4583
        case 0x120:
4584
            decode_vol_header(s, gb);
4585
            break;
4586
        case 0x1b2:
4587
            decode_user_data(s, gb);
4588
            break;
4589
        case 0x1b6:
4590
            return decode_vop_header(s, gb);
4591
        default:
4592
//            printf("startcode %X found\n", startcode);
4593
            break;
4594
        }
4595

    
4596
        align_get_bits(gb);
4597
        startcode = 0xff;
4598
    }
4599
}
4600

    
4601
/* don't understand why they choose a different header ! */
4602
int intel_h263_decode_picture_header(MpegEncContext *s)
4603
{
4604
    int format;
4605

    
4606
    /* picture header */
4607
    if (get_bits(&s->gb, 22) != 0x20) {
4608
        fprintf(stderr, "Bad picture start code\n");
4609
        return -1;
4610
    }
4611
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4612

    
4613
    if (get_bits1(&s->gb) != 1) {
4614
        fprintf(stderr, "Bad marker\n");
4615
        return -1;        /* marker */
4616
    }
4617
    if (get_bits1(&s->gb) != 0) {
4618
        fprintf(stderr, "Bad H263 id\n");
4619
        return -1;        /* h263 id */
4620
    }
4621
    skip_bits1(&s->gb);        /* split screen off */
4622
    skip_bits1(&s->gb);        /* camera  off */
4623
    skip_bits1(&s->gb);        /* freeze picture release off */
4624

    
4625
    format = get_bits(&s->gb, 3);
4626
    if (format != 7) {
4627
        fprintf(stderr, "Intel H263 free format not supported\n");
4628
        return -1;
4629
    }
4630
    s->h263_plus = 0;
4631

    
4632
    s->pict_type = I_TYPE + get_bits1(&s->gb);
4633
    
4634
    s->unrestricted_mv = get_bits1(&s->gb); 
4635
    s->h263_long_vectors = s->unrestricted_mv;
4636

    
4637
    if (get_bits1(&s->gb) != 0) {
4638
        fprintf(stderr, "SAC not supported\n");
4639
        return -1;        /* SAC: off */
4640
    }
4641
    if (get_bits1(&s->gb) != 0) {
4642
        fprintf(stderr, "Advanced Prediction Mode not supported\n");
4643
        return -1;        /* advanced prediction mode: off */
4644
    }
4645
    if (get_bits1(&s->gb) != 0) {
4646
        fprintf(stderr, "PB frame mode no supported\n");
4647
        return -1;        /* PB frame mode */
4648
    }
4649

    
4650
    /* skip unknown header garbage */
4651
    skip_bits(&s->gb, 41);
4652

    
4653
    s->qscale = get_bits(&s->gb, 5);
4654
    skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
4655

    
4656
    /* PEI */
4657
    while (get_bits1(&s->gb) != 0) {
4658
        skip_bits(&s->gb, 8);
4659
    }
4660
    s->f_code = 1;
4661

    
4662
    s->y_dc_scale_table=
4663
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4664

    
4665
    return 0;
4666
}
4667