Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ f8af5cb5

History | View | Annotate | Download (156 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
static void float_aspect_to_info(MpegEncContext * s, float aspect){
124
    int i;
125

    
126
    aspect*= s->height/(double)s->width;
127
//printf("%f\n", aspect);
128
    
129
    if(aspect==0) aspect= 1.0;
130

    
131
    ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
132

    
133
//printf("%d %d\n", s->aspected_width, s->aspected_height);
134
    for(i=1; i<6; i++){
135
        if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
136
            s->aspect_ratio_info=i;
137
            return;
138
        }
139
    }
140
    
141
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
142
}
143

    
144
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
145
{
146
    int format;
147

    
148
    align_put_bits(&s->pb);
149

    
150
    /* Update the pointer to last GOB */
151
    s->ptr_lastgob = pbBufPtr(&s->pb);
152
    s->gob_number = 0;
153

    
154
    put_bits(&s->pb, 22, 0x20); /* PSC */
155
    put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / 
156
                         s->frame_rate) & 0xff);
157

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

    
222
            put_bits(&s->pb,4,s->aspect_ratio_info);
223
            put_bits(&s->pb,9,(s->width >> 2) - 1);
224
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
225
            put_bits(&s->pb,9,(s->height >> 2));
226
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
227
            {
228
                put_bits(&s->pb, 8, s->aspected_width);
229
                put_bits(&s->pb, 8, s->aspected_height);
230
            }
231
        }
232
        
233
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
234
        if (s->umvplus)
235
            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
236
        put_bits(&s->pb, 5, s->qscale);
237
    }
238

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

    
241
    if(s->h263_aic){
242
         s->y_dc_scale_table= 
243
         s->c_dc_scale_table= h263_aic_dc_scale_table;
244
    }else{
245
        s->y_dc_scale_table=
246
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
247
    }
248
}
249

    
250
/**
251
 * Encodes a group of blocks header.
252
 */
253
int h263_encode_gob_header(MpegEncContext * s, int mb_line)
254
{
255
           align_put_bits(&s->pb);
256
           flush_put_bits(&s->pb);
257
           /* Call the RTP callback to send the last GOB */
258
           if (s->rtp_callback) {
259
               int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
260
               s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
261
           }
262
           put_bits(&s->pb, 17, 1); /* GBSC */
263
           s->gob_number = mb_line / s->gob_index;
264
           put_bits(&s->pb, 5, s->gob_number); /* GN */
265
           put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
266
           put_bits(&s->pb, 5, s->qscale); /* GQUANT */
267
           //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
268
    return 0;
269
}
270

    
271
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
272
{
273
    int score0=0, score1=0;
274
    int i, n;
275
    int8_t * const qscale_table= s->current_picture.qscale_table;
276

    
277
    for(n=0; n<6; n++){
278
        INT16 *ac_val, *ac_val1;
279

    
280
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
281
        ac_val1= ac_val;
282
        if(dir[n]){
283
            const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
284
            /* top prediction */
285
            ac_val-= s->block_wrap[n]*16;
286
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
287
                /* same qscale */
288
                for(i=1; i<8; i++){
289
                    const int level= block[n][s->idct_permutation[i   ]];
290
                    score0+= ABS(level);
291
                    score1+= ABS(level - ac_val[i+8]);
292
                    ac_val1[i  ]=    block[n][s->idct_permutation[i<<3]];
293
                    ac_val1[i+8]= level;
294
                }
295
            }else{
296
                /* different qscale, we must rescale */
297
                for(i=1; i<8; i++){
298
                    const int level= block[n][s->idct_permutation[i   ]];
299
                    score0+= ABS(level);
300
                    score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale));
301
                    ac_val1[i  ]=    block[n][s->idct_permutation[i<<3]];
302
                    ac_val1[i+8]= level;
303
                }
304
            }
305
        }else{
306
            const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
307
            /* left prediction */
308
            ac_val-= 16;
309
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
310
                /* same qscale */
311
                for(i=1; i<8; i++){
312
                    const int level= block[n][s->idct_permutation[i<<3]];
313
                    score0+= ABS(level);
314
                    score1+= ABS(level - ac_val[i]);
315
                    ac_val1[i  ]= level;
316
                    ac_val1[i+8]=    block[n][s->idct_permutation[i   ]];
317
                }
318
            }else{
319
                /* different qscale, we must rescale */
320
                for(i=1; i<8; i++){
321
                    const int level= block[n][s->idct_permutation[i<<3]];
322
                    score0+= ABS(level);
323
                    score1+= ABS(level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale));
324
                    ac_val1[i  ]= level;
325
                    ac_val1[i+8]=    block[n][s->idct_permutation[i   ]];
326
                }
327
            }
328
        }
329
    }
330

    
331
    return score0 > score1 ? 1 : 0;    
332
}
333

    
334
/**
335
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
336
 */
337
void ff_clean_h263_qscales(MpegEncContext *s){
338
    int i;
339
    int8_t * const qscale_table= s->current_picture.qscale_table;
340
    
341
    for(i=1; i<s->mb_num; i++){
342
        if(qscale_table[i] - qscale_table[i-1] >2)
343
            qscale_table[i]= qscale_table[i-1]+2;
344
    }
345
    for(i=s->mb_num-2; i>=0; i--){
346
        if(qscale_table[i] - qscale_table[i+1] >2)
347
            qscale_table[i]= qscale_table[i+1]+2;
348
    }
349
}
350

    
351
/**
352
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
353
 */
354
void ff_clean_mpeg4_qscales(MpegEncContext *s){
355
    int i;
356
    int8_t * const qscale_table= s->current_picture.qscale_table;
357

    
358
    ff_clean_h263_qscales(s);
359
    
360
    for(i=1; i<s->mb_num; i++){
361
        if(qscale_table[i] != qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_INTER4V)){
362
            s->mb_type[i]&= ~MB_TYPE_INTER4V;
363
            s->mb_type[i]|= MB_TYPE_INTER;
364
        }
365
    }
366

    
367
    if(s->pict_type== B_TYPE){
368
        int odd=0;
369
        /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
370
           for the actual adaptive quantization */
371
        
372
        for(i=0; i<s->mb_num; i++){
373
            odd += qscale_table[i]&1;
374
        }
375
        
376
        if(2*odd > s->mb_num) odd=1;
377
        else                  odd=0;
378
        
379
        for(i=0; i<s->mb_num; i++){
380
            if((qscale_table[i]&1) != odd)
381
                qscale_table[i]++;
382
            if(qscale_table[i] > 31)
383
                qscale_table[i]= 31;
384
        }            
385
    
386
        for(i=1; i<s->mb_num; i++){
387
            if(qscale_table[i] != qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_DIRECT)){
388
                s->mb_type[i]&= ~MB_TYPE_DIRECT;
389
                s->mb_type[i]|= MB_TYPE_BIDIR;
390
            }
391
        }
392
    }
393
}
394

    
395
#ifdef CONFIG_ENCODERS
396
void mpeg4_encode_mb(MpegEncContext * s,
397
                    DCTELEM block[6][64],
398
                    int motion_x, int motion_y)
399
{
400
    int cbpc, cbpy, i, pred_x, pred_y;
401
    int bits;
402
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
403
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
404
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
405
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
406
    const int dquant_code[5]= {1,0,9,2,3};
407
    
408
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
409
    if (!s->mb_intra) {
410
        /* compute cbp */
411
        int cbp = 0;
412
        for (i = 0; i < 6; i++) {
413
            if (s->block_last_index[i] >= 0)
414
                cbp |= 1 << (5 - i);
415
        }
416

    
417
        if(s->pict_type==B_TYPE){
418
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
419
            int mb_type=  mb_type_table[s->mv_dir];
420
            
421
            if(s->mb_x==0){
422
                s->last_mv[0][0][0]= 
423
                s->last_mv[0][0][1]= 
424
                s->last_mv[1][0][0]= 
425
                s->last_mv[1][0][1]= 0;
426
            }
427
            
428
            assert(s->dquant>=-2 && s->dquant<=2);
429
            assert((s->dquant&1)==0);
430
            assert(mb_type>=0);
431

    
432
            /* nothing to do if this MB was skiped in the next P Frame */
433
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x]){ //FIXME avoid DCT & ...
434
                s->skip_count++;
435
                s->mv[0][0][0]= 
436
                s->mv[0][0][1]= 
437
                s->mv[1][0][0]= 
438
                s->mv[1][0][1]= 0;
439
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
440
                s->qscale -= s->dquant;
441
//                s->mb_skiped=1;
442

    
443
                return;
444
            }
445

    
446
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
447
                /* direct MB with MV={0,0} */
448
                assert(s->dquant==0);
449
                
450
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
451

    
452
                if(interleaved_stats){
453
                    s->misc_bits++;
454
                    s->last_bits++;
455
                }
456
                s->skip_count++;
457
                return;
458
            }
459
            
460
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
461
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
462
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
463
            if(cbp) put_bits(&s->pb, 6, cbp);
464
            
465
            if(cbp && mb_type){
466
                if(s->dquant)
467
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
468
                else
469
                    put_bits(&s->pb, 1, 0);
470
            }else
471
                s->qscale -= s->dquant;
472
            
473
            if(!s->progressive_sequence){
474
                if(cbp)
475
                    put_bits(&s->pb, 1, s->interlaced_dct);
476
                if(mb_type) // not diect mode
477
                    put_bits(&s->pb, 1, 0); // no interlaced ME yet
478
            }
479

    
480
            if(interleaved_stats){
481
                bits= get_bit_count(&s->pb);
482
                s->misc_bits+= bits - s->last_bits;
483
                s->last_bits=bits;
484
            }
485

    
486
            switch(mb_type)
487
            {
488
            case 0: /* direct */
489
                h263_encode_motion(s, motion_x, 1);
490
                h263_encode_motion(s, motion_y, 1);                
491
                s->b_count++;
492
                s->f_count++;
493
                break;
494
            case 1: /* bidir */
495
                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
496
                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
497
                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
498
                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
499
                s->last_mv[0][0][0]= s->mv[0][0][0];
500
                s->last_mv[0][0][1]= s->mv[0][0][1];
501
                s->last_mv[1][0][0]= s->mv[1][0][0];
502
                s->last_mv[1][0][1]= s->mv[1][0][1];
503
                s->b_count++;
504
                s->f_count++;
505
                break;
506
            case 2: /* backward */
507
                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
508
                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
509
                s->last_mv[1][0][0]= motion_x;
510
                s->last_mv[1][0][1]= motion_y;
511
                s->b_count++;
512
                break;
513
            case 3: /* forward */
514
                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
515
                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
516
                s->last_mv[0][0][0]= motion_x;
517
                s->last_mv[0][0][1]= motion_y;
518
                s->f_count++;
519
                break;
520
            default:
521
                printf("unknown mb type\n");
522
                return;
523
            }
524

    
525
            if(interleaved_stats){
526
                bits= get_bit_count(&s->pb);
527
                s->mv_bits+= bits - s->last_bits;
528
                s->last_bits=bits;
529
            }
530

    
531
            /* encode each block */
532
            for (i = 0; i < 6; i++) {
533
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
534
            }
535

    
536
            if(interleaved_stats){
537
                bits= get_bit_count(&s->pb);
538
                s->p_tex_bits+= bits - s->last_bits;
539
                s->last_bits=bits;
540
            }
541
        }else{ /* s->pict_type==B_TYPE */
542
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
543
                /* check if the B frames can skip it too, as we must skip it if we skip here 
544
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
545
                if(s->max_b_frames>0){
546
                    int i;
547
                    int x,y, offset;
548
                    uint8_t *p_pic;
549

    
550
                    x= s->mb_x*16;
551
                    y= s->mb_y*16;
552
                    if(x+16 > s->width)  x= s->width-16;
553
                    if(y+16 > s->height) y= s->height-16;
554

    
555
                    offset= x + y*s->linesize;
556
                    p_pic= s->new_picture.data[0] + offset;
557
                    
558
                    s->mb_skiped=1;
559
                    for(i=0; i<s->max_b_frames; i++){
560
                        uint8_t *b_pic;
561
                        int diff;
562
                        Picture *pic= s->reordered_input_picture[i+1];
563

    
564
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
565

    
566
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
567
                        diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
568
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
569
                            s->mb_skiped=0;
570
                            break;
571
                        }
572
                    }
573
                }else
574
                    s->mb_skiped=1; 
575

    
576
                if(s->mb_skiped==1){
577
                    /* skip macroblock */
578
                    put_bits(&s->pb, 1, 1);
579

    
580
                    if(interleaved_stats){
581
                        s->misc_bits++;
582
                        s->last_bits++;
583
                    }
584
                    s->skip_count++;
585
                    return;
586
                }
587
            }
588

    
589
            put_bits(&s->pb, 1, 0);        /* mb coded */
590
            if(s->mv_type==MV_TYPE_16X16){
591
                cbpc = cbp & 3;
592
                if(s->dquant) cbpc+= 8;
593
                put_bits(&s->pb,
594
                        inter_MCBPC_bits[cbpc],
595
                        inter_MCBPC_code[cbpc]);
596

    
597
                cbpy = cbp >> 2;
598
                cbpy ^= 0xf;
599
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
600
                if(s->dquant)
601
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
602

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

    
615
                /* motion vectors: 16x16 mode */
616
                h263_pred_motion(s, 0, &pred_x, &pred_y);
617
            
618
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
619
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
620
            }else{
621
                cbpc = (cbp & 3)+16;
622
                put_bits(&s->pb,
623
                        inter_MCBPC_bits[cbpc],
624
                        inter_MCBPC_code[cbpc]);
625
                cbpy = cbp >> 2;
626
                cbpy ^= 0xf;
627
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
628

    
629
                if(!s->progressive_sequence){
630
                    if(cbp)
631
                        put_bits(pb2, 1, s->interlaced_dct);
632
                }
633
    
634
                if(interleaved_stats){
635
                    bits= get_bit_count(&s->pb);
636
                    s->misc_bits+= bits - s->last_bits;
637
                    s->last_bits=bits;
638
                }
639

    
640
                for(i=0; i<4; i++){
641
                    /* motion vectors: 8x8 mode*/
642
                    h263_pred_motion(s, i, &pred_x, &pred_y);
643

    
644
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
645
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
646
                }
647
            }
648

    
649
            if(interleaved_stats){ 
650
                bits= get_bit_count(&s->pb);
651
                s->mv_bits+= bits - s->last_bits;
652
                s->last_bits=bits;
653
            }
654

    
655
            /* encode each block */
656
            for (i = 0; i < 6; i++) {
657
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
658
            }
659

    
660
            if(interleaved_stats){
661
                bits= get_bit_count(&s->pb);
662
                s->p_tex_bits+= bits - s->last_bits;
663
                s->last_bits=bits;
664
            }
665
            s->f_count++;
666
        }
667
    } else {
668
        int cbp;
669
        int dc_diff[6];   //dc values with the dc prediction subtracted 
670
        int dir[6];  //prediction direction
671
        int zigzag_last_index[6];
672
        UINT8 *scan_table[6];
673

    
674
        for(i=0; i<6; i++){
675
            const int level= block[i][0];
676
            UINT16 *dc_ptr;
677

    
678
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
679
            if (i < 4) {
680
                *dc_ptr = level * s->y_dc_scale;
681
            } else {
682
                *dc_ptr = level * s->c_dc_scale;
683
            }
684
        }
685

    
686
        s->ac_pred= decide_ac_pred(s, block, dir);
687

    
688
        if(s->ac_pred){
689
            for(i=0; i<6; i++){
690
                UINT8 *st;
691
                int last_index;
692

    
693
                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
694
                if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
695
                else           st = s->intra_h_scantable.permutated; /* top */
696

    
697
                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
698
                    if(block[i][st[last_index]]) break;
699
                zigzag_last_index[i]= s->block_last_index[i];
700
                s->block_last_index[i]= last_index;
701
                scan_table[i]= st;
702
            }
703
        }else{
704
            for(i=0; i<6; i++)
705
                scan_table[i]= s->intra_scantable.permutated;
706
        }
707

    
708
        /* compute cbp */
709
        cbp = 0;
710
        for (i = 0; i < 6; i++) {
711
            if (s->block_last_index[i] >= 1)
712
                cbp |= 1 << (5 - i);
713
        }
714

    
715
        cbpc = cbp & 3;
716
        if (s->pict_type == I_TYPE) {
717
            if(s->dquant) cbpc+=4;
718
            put_bits(&s->pb,
719
                intra_MCBPC_bits[cbpc],
720
                intra_MCBPC_code[cbpc]);
721
        } else {
722
            if(s->dquant) cbpc+=8;
723
            put_bits(&s->pb, 1, 0);        /* mb coded */
724
            put_bits(&s->pb,
725
                inter_MCBPC_bits[cbpc + 4],
726
                inter_MCBPC_code[cbpc + 4]);
727
        }
728
        put_bits(pb2, 1, s->ac_pred);
729
        cbpy = cbp >> 2;
730
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
731
        if(s->dquant)
732
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
733

    
734
        if(!s->progressive_sequence){
735
            put_bits(dc_pb, 1, s->interlaced_dct);
736
        }
737

    
738
        if(interleaved_stats){
739
            bits= get_bit_count(&s->pb);
740
            s->misc_bits+= bits - s->last_bits;
741
            s->last_bits=bits;
742
        }
743

    
744
        /* encode each block */
745
        for (i = 0; i < 6; i++) {
746
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
747
        }
748

    
749
        if(interleaved_stats){
750
            bits= get_bit_count(&s->pb);
751
            s->i_tex_bits+= bits - s->last_bits;
752
            s->last_bits=bits;
753
        }
754
        s->i_count++;
755

    
756
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
757
        if(s->ac_pred){
758
            for(i=0; i<6; i++){
759
                int j;    
760
                INT16 *ac_val;
761

    
762
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
763

    
764
                if(dir[i]){
765
                    for(j=1; j<8; j++) 
766
                        block[i][s->idct_permutation[j   ]]= ac_val[j+8];
767
                }else{
768
                    for(j=1; j<8; j++) 
769
                        block[i][s->idct_permutation[j<<3]]= ac_val[j  ];
770
                }
771
                s->block_last_index[i]= zigzag_last_index[i];
772
            }
773
        }
774
    }
775
}
776

    
777
void h263_encode_mb(MpegEncContext * s,
778
                    DCTELEM block[6][64],
779
                    int motion_x, int motion_y)
780
{
781
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
782
    INT16 pred_dc;
783
    INT16 rec_intradc[6];
784
    UINT16 *dc_ptr[6];
785
    const int dquant_code[5]= {1,0,9,2,3};
786
           
787
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
788
    if (!s->mb_intra) {
789
        /* compute cbp */
790
        cbp = 0;
791
        for (i = 0; i < 6; i++) {
792
            if (s->block_last_index[i] >= 0)
793
                cbp |= 1 << (5 - i);
794
        }
795
        if ((cbp | motion_x | motion_y | s->dquant) == 0) {
796
            /* skip macroblock */
797
            put_bits(&s->pb, 1, 1);
798
            return;
799
        }
800
        put_bits(&s->pb, 1, 0);        /* mb coded */
801
        cbpc = cbp & 3;
802
        if(s->dquant) cbpc+= 8;
803
        put_bits(&s->pb,
804
                    inter_MCBPC_bits[cbpc],
805
                    inter_MCBPC_code[cbpc]);
806
        cbpy = cbp >> 2;
807
        cbpy ^= 0xf;
808
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
809
        if(s->dquant)
810
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
811

    
812
        /* motion vectors: 16x16 mode only now */
813
        h263_pred_motion(s, 0, &pred_x, &pred_y);
814
      
815
        if (!s->umvplus) {  
816
            h263_encode_motion(s, motion_x - pred_x, s->f_code);
817
            h263_encode_motion(s, motion_y - pred_y, s->f_code);
818
        }
819
        else {
820
            h263p_encode_umotion(s, motion_x - pred_x);
821
            h263p_encode_umotion(s, motion_y - pred_y);
822
            if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
823
                /* To prevent Start Code emulation */
824
                put_bits(&s->pb,1,1);
825
        }
826
    } else {
827
        int li = s->h263_aic ? 0 : 1;
828
        
829
        cbp = 0;
830
        for(i=0; i<6; i++) {
831
            /* Predict DC */
832
            if (s->h263_aic && s->mb_intra) {
833
                INT16 level = block[i][0];
834
            
835
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
836
                level -= pred_dc;
837
                /* Quant */
838
                if (level < 0)
839
                    level = (level + (s->qscale >> 1))/(s->y_dc_scale);
840
                else
841
                    level = (level - (s->qscale >> 1))/(s->y_dc_scale);
842
                    
843
                /* AIC can change CBP */
844
                if (level == 0 && s->block_last_index[i] == 0)
845
                    s->block_last_index[i] = -1;
846
                else if (level < -127)
847
                    level = -127;
848
                else if (level > 127)
849
                    level = 127;
850
                
851
                block[i][0] = level;
852
                /* Reconstruction */ 
853
                rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
854
                /* Oddify */
855
                rec_intradc[i] |= 1;
856
                //if ((rec_intradc[i] % 2) == 0)
857
                //    rec_intradc[i]++;
858
                /* Clipping */
859
                if (rec_intradc[i] < 0)
860
                    rec_intradc[i] = 0;
861
                else if (rec_intradc[i] > 2047)
862
                    rec_intradc[i] = 2047;
863
                                
864
                /* Update AC/DC tables */
865
                *dc_ptr[i] = rec_intradc[i];
866
            }
867
            /* compute cbp */
868
            if (s->block_last_index[i] >= li)
869
                cbp |= 1 << (5 - i);
870
        }
871

    
872
        cbpc = cbp & 3;
873
        if (s->pict_type == I_TYPE) {
874
            if(s->dquant) cbpc+=4;
875
            put_bits(&s->pb,
876
                intra_MCBPC_bits[cbpc],
877
                intra_MCBPC_code[cbpc]);
878
        } else {
879
            if(s->dquant) cbpc+=8;
880
            put_bits(&s->pb, 1, 0);        /* mb coded */
881
            put_bits(&s->pb,
882
                inter_MCBPC_bits[cbpc + 4],
883
                inter_MCBPC_code[cbpc + 4]);
884
        }
885
        if (s->h263_aic) {
886
            /* XXX: currently, we do not try to use ac prediction */
887
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
888
        }
889
        cbpy = cbp >> 2;
890
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
891
        if(s->dquant)
892
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
893
    }
894

    
895
    for(i=0; i<6; i++) {
896
        /* encode each block */
897
        h263_encode_block(s, block[i], i);
898
    
899
        /* Update INTRADC for decoding */
900
        if (s->h263_aic && s->mb_intra) {
901
            block[i][0] = rec_intradc[i];
902
            
903
        }
904
    }
905
}
906
#endif
907

    
908
static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
909
{
910
    int x, y, wrap, a, c, pred_dc, scale;
911
    INT16 *dc_val, *ac_val;
912

    
913
    /* find prediction */
914
    if (n < 4) {
915
        x = 2 * s->mb_x + 1 + (n & 1);
916
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
917
        wrap = s->mb_width * 2 + 2;
918
        dc_val = s->dc_val[0];
919
        ac_val = s->ac_val[0][0];
920
        scale = s->y_dc_scale;
921
    } else {
922
        x = s->mb_x + 1;
923
        y = s->mb_y + 1;
924
        wrap = s->mb_width + 2;
925
        dc_val = s->dc_val[n - 4 + 1];
926
        ac_val = s->ac_val[n - 4 + 1][0];
927
        scale = s->c_dc_scale;
928
    }
929
    /* B C
930
     * A X 
931
     */
932
    a = dc_val[(x - 1) + (y) * wrap];
933
    c = dc_val[(x) + (y - 1) * wrap];
934
    
935
    /* No prediction outside GOB boundary */
936
    if (s->first_slice_line && ((n < 2) || (n > 3)))
937
        c = 1024;
938
    pred_dc = 1024;
939
    /* just DC prediction */
940
    if (a != 1024 && c != 1024)
941
        pred_dc = (a + c) >> 1;
942
    else if (a != 1024)
943
        pred_dc = a;
944
    else
945
        pred_dc = c;
946
    
947
    /* we assume pred is positive */
948
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
949
    *dc_val_ptr = &dc_val[x + y * wrap];
950
    return pred_dc;
951
}
952

    
953

    
954
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
955
{
956
    int x, y, wrap, a, c, pred_dc, scale, i;
957
    INT16 *dc_val, *ac_val, *ac_val1;
958

    
959
    /* find prediction */
960
    if (n < 4) {
961
        x = 2 * s->mb_x + 1 + (n & 1);
962
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
963
        wrap = s->mb_width * 2 + 2;
964
        dc_val = s->dc_val[0];
965
        ac_val = s->ac_val[0][0];
966
        scale = s->y_dc_scale;
967
    } else {
968
        x = s->mb_x + 1;
969
        y = s->mb_y + 1;
970
        wrap = s->mb_width + 2;
971
        dc_val = s->dc_val[n - 4 + 1];
972
        ac_val = s->ac_val[n - 4 + 1][0];
973
        scale = s->c_dc_scale;
974
    }
975
    
976
    ac_val += ((y) * wrap + (x)) * 16;
977
    ac_val1 = ac_val;
978
    
979
    /* B C
980
     * A X 
981
     */
982
    a = dc_val[(x - 1) + (y) * wrap];
983
    c = dc_val[(x) + (y - 1) * wrap];
984
    
985
    /* No prediction outside GOB boundary */
986
    if (s->first_slice_line && ((n < 2) || (n > 3)))
987
        c = 1024;
988
    pred_dc = 1024;
989
    if (s->ac_pred) {
990
        if (s->h263_aic_dir) {
991
            /* left prediction */
992
            if (a != 1024) {
993
                ac_val -= 16;
994
                for(i=1;i<8;i++) {
995
                    block[s->idct_permutation[i<<3]] += ac_val[i];
996
                }
997
                pred_dc = a;
998
            }
999
        } else {
1000
            /* top prediction */
1001
            if (c != 1024) {
1002
                ac_val -= 16 * wrap;
1003
                for(i=1;i<8;i++) {
1004
                    block[s->idct_permutation[i   ]] += ac_val[i + 8];
1005
                }
1006
                pred_dc = c;
1007
            }
1008
        }
1009
    } else {
1010
        /* just DC prediction */
1011
        if (a != 1024 && c != 1024)
1012
            pred_dc = (a + c) >> 1;
1013
        else if (a != 1024)
1014
            pred_dc = a;
1015
        else
1016
            pred_dc = c;
1017
    }
1018
    
1019
    /* we assume pred is positive */
1020
    block[0]=block[0]*scale + pred_dc;
1021
    
1022
    if (block[0] < 0)
1023
        block[0] = 0;
1024
    else if (!(block[0] & 1))
1025
        block[0]++;
1026
    
1027
    /* Update AC/DC tables */
1028
    dc_val[(x) + (y) * wrap] = block[0];
1029
    
1030
    /* left copy */
1031
    for(i=1;i<8;i++)
1032
        ac_val1[i    ] = block[s->idct_permutation[i<<3]];
1033
    /* top copy */
1034
    for(i=1;i<8;i++)
1035
        ac_val1[8 + i] = block[s->idct_permutation[i   ]];
1036
}
1037

    
1038
INT16 *h263_pred_motion(MpegEncContext * s, int block, 
1039
                        int *px, int *py)
1040
{
1041
    int xy, wrap;
1042
    INT16 *A, *B, *C, *mot_val;
1043
    static const int off[4]= {2, 1, 1, -1};
1044

    
1045
    wrap = s->block_wrap[0];
1046
    xy = s->block_index[block];
1047

    
1048
    mot_val = s->motion_val[xy];
1049

    
1050
    A = s->motion_val[xy - 1];
1051
    /* special case for first (slice) line */
1052
    if (s->first_slice_line && block<3) {
1053
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1054
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1055
        if(block==0){ //most common case
1056
            if(s->mb_x  == s->resync_mb_x){ //rare
1057
                *px= *py = 0;
1058
            }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1059
                C = s->motion_val[xy + off[block] - wrap];
1060
                if(s->mb_x==0){
1061
                    *px = C[0];
1062
                    *py = C[1];
1063
                }else{
1064
                    *px = mid_pred(A[0], 0, C[0]);
1065
                    *py = mid_pred(A[1], 0, C[1]);
1066
                }
1067
            }else{
1068
                *px = A[0];
1069
                *py = A[1];
1070
            }
1071
        }else if(block==1){
1072
            if(s->mb_x + 1 == s->resync_mb_x){ //rare
1073
                C = s->motion_val[xy + off[block] - wrap];
1074
                *px = mid_pred(A[0], 0, C[0]);
1075
                *py = mid_pred(A[1], 0, C[1]);
1076
            }else{
1077
                *px = A[0];
1078
                *py = A[1];
1079
            }
1080
        }else{ /* block==2*/
1081
            B = s->motion_val[xy - wrap];
1082
            C = s->motion_val[xy + off[block] - wrap];
1083
            if(s->mb_x == s->resync_mb_x) //rare
1084
                A[0]=A[1]=0;
1085
    
1086
            *px = mid_pred(A[0], B[0], C[0]);
1087
            *py = mid_pred(A[1], B[1], C[1]);
1088
        }
1089
    } else {
1090
        B = s->motion_val[xy - wrap];
1091
        C = s->motion_val[xy + off[block] - wrap];
1092
        *px = mid_pred(A[0], B[0], C[0]);
1093
        *py = mid_pred(A[1], B[1], C[1]);
1094
    }
1095
    return mot_val;
1096
}
1097

    
1098
#ifdef CONFIG_ENCODERS
1099
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1100
{
1101
    int range, l, bit_size, sign, code, bits;
1102

    
1103
    if (val == 0) {
1104
        /* zero vector */
1105
        code = 0;
1106
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1107
    } else {
1108
        bit_size = f_code - 1;
1109
        range = 1 << bit_size;
1110
        /* modulo encoding */
1111
        l = range * 32;
1112
#if 1
1113
        val+= l;
1114
        val&= 2*l-1;
1115
        val-= l;
1116
        sign = val>>31;
1117
        val= (val^sign)-sign;
1118
        sign&=1;
1119
#else
1120
        if (val < -l) {
1121
            val += 2*l;
1122
        } else if (val >= l) {
1123
            val -= 2*l;
1124
        }
1125

    
1126
        assert(val>=-l && val<l);
1127

    
1128
        if (val >= 0) {
1129
            sign = 0;
1130
        } else {
1131
            val = -val;
1132
            sign = 1;
1133
        }
1134
#endif
1135
        val--;
1136
        code = (val >> bit_size) + 1;
1137
        bits = val & (range - 1);
1138

    
1139
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1140
        if (bit_size > 0) {
1141
            put_bits(&s->pb, bit_size, bits);
1142
        }
1143
    }
1144

    
1145
}
1146

    
1147
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1148
static void h263p_encode_umotion(MpegEncContext * s, int val)
1149
{
1150
    short sval = 0; 
1151
    short i = 0;
1152
    short n_bits = 0;
1153
    short temp_val;
1154
    int code = 0;
1155
    int tcode;
1156
    
1157
    if ( val == 0)
1158
        put_bits(&s->pb, 1, 1);
1159
    else if (val == 1)
1160
        put_bits(&s->pb, 3, 0);
1161
    else if (val == -1)
1162
        put_bits(&s->pb, 3, 2);
1163
    else {
1164
        
1165
        sval = ((val < 0) ? (short)(-val):(short)val);
1166
        temp_val = sval;
1167
        
1168
        while (temp_val != 0) {
1169
            temp_val = temp_val >> 1;
1170
            n_bits++;
1171
        }
1172
        
1173
        i = n_bits - 1;
1174
        while (i > 0) {
1175
            tcode = (sval & (1 << (i-1))) >> (i-1);
1176
            tcode = (tcode << 1) | 1;
1177
            code = (code << 2) | tcode;
1178
            i--;
1179
        }
1180
        code = ((code << 1) | (val < 0)) << 1;
1181
        put_bits(&s->pb, (2*n_bits)+1, code);
1182
        //printf("\nVal = %d\tCode = %d", sval, code);
1183
    }
1184
}
1185

    
1186
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1187
{
1188
    int f_code;
1189
    int mv;
1190
    
1191
    if(mv_penalty==NULL)
1192
        mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1193
    
1194
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1195
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1196
            int len;
1197

    
1198
            if(mv==0) len= mvtab[0][1];
1199
            else{
1200
                int val, bit_size, range, code;
1201

    
1202
                bit_size = s->f_code - 1;
1203
                range = 1 << bit_size;
1204

    
1205
                val=mv;
1206
                if (val < 0) 
1207
                    val = -val;
1208
                val--;
1209
                code = (val >> bit_size) + 1;
1210
                if(code<33){
1211
                    len= mvtab[code][1] + 1 + bit_size;
1212
                }else{
1213
                    len= mvtab[32][1] + 2 + bit_size;
1214
                }
1215
            }
1216

    
1217
            mv_penalty[f_code][mv+MAX_MV]= len;
1218
        }
1219
    }
1220

    
1221
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1222
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1223
            fcode_tab[mv+MAX_MV]= f_code;
1224
        }
1225
    }
1226

    
1227
    for(mv=0; mv<MAX_MV*2+1; mv++){
1228
        umv_fcode_tab[mv]= 1;
1229
    }
1230
}
1231
#endif
1232

    
1233
static void init_uni_dc_tab(void)
1234
{
1235
    int level, uni_code, uni_len;
1236

    
1237
    for(level=-256; level<256; level++){
1238
        int size, v, l;
1239
        /* find number of bits */
1240
        size = 0;
1241
        v = abs(level);
1242
        while (v) {
1243
            v >>= 1;
1244
            size++;
1245
        }
1246

    
1247
        if (level < 0)
1248
            l= (-level) ^ ((1 << size) - 1);
1249
        else
1250
            l= level;
1251

    
1252
        /* luminance */
1253
        uni_code= DCtab_lum[size][0];
1254
        uni_len = DCtab_lum[size][1];
1255

    
1256
        if (size > 0) {
1257
            uni_code<<=size; uni_code|=l;
1258
            uni_len+=size;
1259
            if (size > 8){
1260
                uni_code<<=1; uni_code|=1;
1261
                uni_len++;
1262
            }
1263
        }
1264
        uni_DCtab_lum[level+256][0]= uni_code;
1265
        uni_DCtab_lum[level+256][1]= uni_len;
1266

    
1267
        /* chrominance */
1268
        uni_code= DCtab_chrom[size][0];
1269
        uni_len = DCtab_chrom[size][1];
1270
        
1271
        if (size > 0) {
1272
            uni_code<<=size; uni_code|=l;
1273
            uni_len+=size;
1274
            if (size > 8){
1275
                uni_code<<=1; uni_code|=1;
1276
                uni_len++;
1277
            }
1278
        }
1279
        uni_DCtab_chrom[level+256][0]= uni_code;
1280
        uni_DCtab_chrom[level+256][1]= uni_len;
1281

    
1282
    }
1283
}
1284

    
1285
#ifdef CONFIG_ENCODERS
1286
static void init_uni_mpeg4_rl_tab(RLTable *rl, UINT32 *bits_tab, UINT8 *len_tab){
1287
    int slevel, run, last;
1288
    
1289
    assert(MAX_LEVEL >= 64);
1290
    assert(MAX_RUN   >= 63);
1291

    
1292
    for(slevel=-64; slevel<64; slevel++){
1293
        if(slevel==0) continue;
1294
        for(run=0; run<64; run++){
1295
            for(last=0; last<=1; last++){
1296
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1297
                int level= slevel < 0 ? -slevel : slevel;
1298
                int sign= slevel < 0 ? 1 : 0;
1299
                int bits, len, code;
1300
                int level1, run1;
1301
                
1302
                len_tab[index]= 100;
1303
                     
1304
                /* ESC0 */
1305
                code= get_rl_index(rl, last, run, level);
1306
                bits= rl->table_vlc[code][0];
1307
                len=  rl->table_vlc[code][1];
1308
                bits=bits*2+sign; len++;
1309
                
1310
                if(code!=rl->n && len < len_tab[index]){
1311
                    bits_tab[index]= bits;
1312
                    len_tab [index]= len;
1313
                }
1314
#if 1
1315
                /* ESC1 */
1316
                bits= rl->table_vlc[rl->n][0];
1317
                len=  rl->table_vlc[rl->n][1];
1318
                bits=bits*2;    len++; //esc1
1319
                level1= level - rl->max_level[last][run];
1320
                if(level1>0){
1321
                    code= get_rl_index(rl, last, run, level1);
1322
                    bits<<= rl->table_vlc[code][1];
1323
                    len  += rl->table_vlc[code][1];
1324
                    bits += rl->table_vlc[code][0];
1325
                    bits=bits*2+sign; len++;
1326
                
1327
                    if(code!=rl->n && len < len_tab[index]){
1328
                        bits_tab[index]= bits;
1329
                        len_tab [index]= len;
1330
                    }
1331
                }
1332
#endif 
1333
#if 1
1334
                /* ESC2 */
1335
                bits= rl->table_vlc[rl->n][0];
1336
                len=  rl->table_vlc[rl->n][1];
1337
                bits=bits*4+2;    len+=2; //esc2
1338
                run1 = run - rl->max_run[last][level] - 1;
1339
                if(run1>=0){
1340
                    code= get_rl_index(rl, last, run1, level);
1341
                    bits<<= rl->table_vlc[code][1];
1342
                    len  += rl->table_vlc[code][1];
1343
                    bits += rl->table_vlc[code][0];
1344
                    bits=bits*2+sign; len++;
1345
                
1346
                    if(code!=rl->n && len < len_tab[index]){
1347
                        bits_tab[index]= bits;
1348
                        len_tab [index]= len;
1349
                    }
1350
                }
1351
#endif           
1352
                /* ESC3 */        
1353
                bits= rl->table_vlc[rl->n][0];
1354
                len = rl->table_vlc[rl->n][1];
1355
                bits=bits*4+3;    len+=2; //esc3
1356
                bits=bits*2+last; len++;
1357
                bits=bits*64+run; len+=6;
1358
                bits=bits*2+1;    len++;  //marker
1359
                bits=bits*4096+(slevel&0xfff); len+=12;
1360
                bits=bits*2+1;    len++;  //marker
1361
                
1362
                if(len < len_tab[index]){
1363
                    bits_tab[index]= bits;
1364
                    len_tab [index]= len;
1365
                }
1366
            }
1367
        }
1368
    }
1369
}
1370

    
1371
void h263_encode_init(MpegEncContext *s)
1372
{
1373
    static int done = 0;
1374

    
1375
    if (!done) {
1376
        done = 1;
1377

    
1378
        init_uni_dc_tab();
1379

    
1380
        init_rl(&rl_inter);
1381
        init_rl(&rl_intra);
1382
        init_rl(&rl_intra_aic);
1383
        
1384
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1385
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1386

    
1387
        init_mv_penalty_and_fcode(s);
1388
    }
1389
    s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1390
    
1391
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1392
    switch(s->codec_id){
1393
    case CODEC_ID_MPEG4:
1394
        s->fcode_tab= fcode_tab;
1395
        s->min_qcoeff= -2048;
1396
        s->max_qcoeff=  2047;
1397
        break;
1398
    case CODEC_ID_H263P:
1399
        s->fcode_tab= umv_fcode_tab;
1400
        s->min_qcoeff= -128;
1401
        s->max_qcoeff=  127;
1402
        break;
1403
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1404
    default: //nothing needed default table allready set in mpegvideo.c
1405
        s->min_qcoeff= -128;
1406
        s->max_qcoeff=  127;
1407
        s->y_dc_scale_table=
1408
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1409
    }
1410

    
1411
    if(s->mpeg_quant){
1412
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1413
        s->inter_quant_bias= 0;
1414
    }else{
1415
        s->intra_quant_bias=0;
1416
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1417
    }
1418
}
1419

    
1420
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1421
{
1422
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1423
    RLTable *rl;
1424

    
1425
    rl = &rl_inter;
1426
    if (s->mb_intra && !s->h263_aic) {
1427
        /* DC coef */
1428
            level = block[0];
1429
        /* 255 cannot be represented, so we clamp */
1430
        if (level > 254) {
1431
            level = 254;
1432
            block[0] = 254;
1433
        }
1434
        /* 0 cannot be represented also */
1435
        else if (!level) {
1436
            level = 1;
1437
            block[0] = 1;
1438
        }
1439
            if (level == 128)
1440
                put_bits(&s->pb, 8, 0xff);
1441
            else
1442
                put_bits(&s->pb, 8, level & 0xff);
1443
            i = 1;
1444
    } else {
1445
            i = 0;
1446
            if (s->h263_aic && s->mb_intra)
1447
                rl = &rl_intra_aic;
1448
    }
1449
   
1450
    /* AC coefs */
1451
    last_index = s->block_last_index[n];
1452
    last_non_zero = i - 1;
1453
    for (; i <= last_index; i++) {
1454
        j = s->intra_scantable.permutated[i];
1455
        level = block[j];
1456
        if (level) {
1457
            run = i - last_non_zero - 1;
1458
            last = (i == last_index);
1459
            sign = 0;
1460
            slevel = level;
1461
            if (level < 0) {
1462
                sign = 1;
1463
                level = -level;
1464
            }
1465
            code = get_rl_index(rl, last, run, level);
1466
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1467
            if (code == rl->n) {
1468
                put_bits(&s->pb, 1, last);
1469
                put_bits(&s->pb, 6, run);
1470
                put_bits(&s->pb, 8, slevel & 0xff);
1471
            } else {
1472
                put_bits(&s->pb, 1, sign);
1473
            }
1474
                last_non_zero = i;
1475
            }
1476
    }
1477
}
1478
#endif
1479

    
1480
/***************************************************/
1481
/**
1482
 * add mpeg4 stuffing bits (01...1)
1483
 */
1484
void ff_mpeg4_stuffing(PutBitContext * pbc)
1485
{
1486
    int length;
1487
    put_bits(pbc, 1, 0);
1488
    length= (-get_bit_count(pbc))&7;
1489
    if(length) put_bits(pbc, length, (1<<length)-1);
1490
}
1491

    
1492
/* must be called before writing the header */
1493
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1494
    int time_div, time_mod;
1495

    
1496
    if(s->pict_type==I_TYPE){ //we will encode a vol header
1497
        s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1498
        if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1499

    
1500
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1501
    }
1502
    
1503
    if(s->current_picture.pts)
1504
        s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1505
    else
1506
        s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1507
    time_div= s->time/s->time_increment_resolution;
1508
    time_mod= s->time%s->time_increment_resolution;
1509

    
1510
    if(s->pict_type==B_TYPE){
1511
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1512
    }else{
1513
        s->last_time_base= s->time_base;
1514
        s->time_base= time_div;
1515
        s->pp_time= s->time - s->last_non_b_time;
1516
        s->last_non_b_time= s->time;
1517
    }
1518
}
1519

    
1520
static void mpeg4_encode_vol_header(MpegEncContext * s)
1521
{
1522
    int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1523
    char buf[255];
1524

    
1525
    if(s->max_b_frames){
1526
        s->vo_type= ADV_SIMPLE_VO_TYPE;
1527
    }else{
1528
        s->vo_type= SIMPLE_VO_TYPE;
1529
    }
1530

    
1531
    put_bits(&s->pb, 16, 0);
1532
    put_bits(&s->pb, 16, 0x100);        /* video obj */
1533
    put_bits(&s->pb, 16, 0);
1534
    put_bits(&s->pb, 16, 0x120);        /* video obj layer */
1535

    
1536
    put_bits(&s->pb, 1, 0);                /* random access vol */
1537
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1538
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1539
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1540
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1541
    
1542
    float_aspect_to_info(s, s->avctx->aspect_ratio);
1543

    
1544
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1545
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1546
    {
1547
        put_bits(&s->pb, 8, s->aspected_width);
1548
        put_bits(&s->pb, 8, s->aspected_height);
1549
    }
1550

    
1551
    if(s->low_delay){
1552
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1553
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1554
        put_bits(&s->pb, 1, s->low_delay);
1555
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1556
    }else{
1557
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1558
    }
1559

    
1560
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1561
    put_bits(&s->pb, 1, 1);                /* marker bit */
1562
    
1563
    put_bits(&s->pb, 16, s->time_increment_resolution);
1564
    if (s->time_increment_bits < 1)
1565
        s->time_increment_bits = 1;
1566
    put_bits(&s->pb, 1, 1);                /* marker bit */
1567
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1568
    put_bits(&s->pb, 1, 1);                /* marker bit */
1569
    put_bits(&s->pb, 13, s->width);        /* vol width */
1570
    put_bits(&s->pb, 1, 1);                /* marker bit */
1571
    put_bits(&s->pb, 13, s->height);        /* vol height */
1572
    put_bits(&s->pb, 1, 1);                /* marker bit */
1573
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1574
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1575
    if (vo_ver_id == 1) {
1576
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1577
    }else{ /* vo_ver_id == 2 */
1578
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1579
    }
1580
    
1581
    s->quant_precision=5;
1582
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
1583
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
1584
    if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1585

    
1586
    if (vo_ver_id != 1)
1587
        put_bits(&s->pb, 1, s->quarter_sample=0);
1588
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1589
    s->resync_marker= s->rtp_mode;
1590
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1591
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1592
    if(s->data_partitioning){
1593
        put_bits(&s->pb, 1, 0);                /* no rvlc */
1594
    }
1595

    
1596
    if (vo_ver_id != 1){
1597
        put_bits(&s->pb, 1, 0);                /* newpred */
1598
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1599
    }
1600
    put_bits(&s->pb, 1, 0);                /* scalability */
1601
    
1602
    ff_mpeg4_stuffing(&s->pb);
1603

    
1604
    /* user data */
1605
    if(!ff_bit_exact){
1606
        put_bits(&s->pb, 16, 0);
1607
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1608
        sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1609
        put_string(&s->pb, buf);
1610
        ff_mpeg4_stuffing(&s->pb);
1611
    }
1612
}
1613

    
1614
/* write mpeg4 VOP header */
1615
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1616
{
1617
    int time_incr;
1618
    int time_div, time_mod;
1619
    
1620
    if(s->pict_type==I_TYPE){
1621
        s->no_rounding=0;
1622
        if(picture_number==0 || !s->strict_std_compliance)
1623
            mpeg4_encode_vol_header(s);
1624
    }
1625
    
1626
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1627

    
1628
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1629
    
1630
    put_bits(&s->pb, 16, 0);                /* vop header */
1631
    put_bits(&s->pb, 16, 0x1B6);        /* vop header */
1632
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1633

    
1634
    time_div= s->time/s->time_increment_resolution;
1635
    time_mod= s->time%s->time_increment_resolution;
1636
    time_incr= time_div - s->last_time_base;
1637
    while(time_incr--)
1638
        put_bits(&s->pb, 1, 1);
1639
        
1640
    put_bits(&s->pb, 1, 0);
1641

    
1642
    put_bits(&s->pb, 1, 1);        /* marker */
1643
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1644
    put_bits(&s->pb, 1, 1);        /* marker */
1645
    put_bits(&s->pb, 1, 1);        /* vop coded */
1646
    if (    s->pict_type == P_TYPE 
1647
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1648
        s->no_rounding ^= 1;
1649
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1650
    }
1651
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1652
    if(!s->progressive_sequence){
1653
         put_bits(&s->pb, 1, s->top_field_first);
1654
         put_bits(&s->pb, 1, s->alternate_scan);
1655
    }
1656
    //FIXME sprite stuff
1657

    
1658
    put_bits(&s->pb, 5, s->qscale);
1659

    
1660
    if (s->pict_type != I_TYPE)
1661
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1662
    if (s->pict_type == B_TYPE)
1663
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1664
    //    printf("****frame %d\n", picture_number);
1665

    
1666
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
1667
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1668
     s->h_edge_pos= s->width;
1669
     s->v_edge_pos= s->height;
1670
}
1671

    
1672
/**
1673
 * change qscale by given dquant and update qscale dependant variables.
1674
 */
1675
static void change_qscale(MpegEncContext * s, int dquant)
1676
{
1677
    s->qscale += dquant;
1678

    
1679
    if (s->qscale < 1)
1680
        s->qscale = 1;
1681
    else if (s->qscale > 31)
1682
        s->qscale = 31;
1683

    
1684
    s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1685
    s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1686
}
1687

    
1688
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1689
{
1690
    int a, b, c, wrap, pred, scale;
1691
    UINT16 *dc_val;
1692
    int dummy;
1693

    
1694
    /* find prediction */
1695
    if (n < 4) {
1696
        scale = s->y_dc_scale;
1697
    } else {
1698
        scale = s->c_dc_scale;
1699
    }
1700
    wrap= s->block_wrap[n];
1701
    dc_val = s->dc_val[0] + s->block_index[n];
1702

    
1703
    /* B C
1704
     * A X 
1705
     */
1706
    a = dc_val[ - 1];
1707
    b = dc_val[ - 1 - wrap];
1708
    c = dc_val[ - wrap];
1709

    
1710
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
1711
    if(s->first_slice_line && n!=3){
1712
        if(n!=2) b=c= 1024;
1713
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
1714
    }
1715
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
1716
        if(n==0 || n==4 || n==5)
1717
            b=1024;
1718
    }
1719

    
1720
    if (abs(a - b) < abs(b - c)) {
1721
        pred = c;
1722
        *dir_ptr = 1; /* top */
1723
    } else {
1724
        pred = a;
1725
        *dir_ptr = 0; /* left */
1726
    }
1727
    /* we assume pred is positive */
1728
#ifdef ARCH_X86
1729
        asm volatile (
1730
                "xorl %%edx, %%edx        \n\t"
1731
                "mul %%ecx                \n\t"
1732
                : "=d" (pred), "=a"(dummy)
1733
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1734
        );
1735
#else
1736
    pred = (pred + (scale >> 1)) / scale;
1737
#endif
1738

    
1739
    /* prepare address for prediction update */
1740
    *dc_val_ptr = &dc_val[0];
1741

    
1742
    return pred;
1743
}
1744

    
1745
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1746
                   int dir)
1747
{
1748
    int i;
1749
    INT16 *ac_val, *ac_val1;
1750
    int8_t * const qscale_table= s->current_picture.qscale_table;
1751

    
1752
    /* find prediction */
1753
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1754
    ac_val1 = ac_val;
1755
    if (s->ac_pred) {
1756
        if (dir == 0) {
1757
            const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1758
            /* left prediction */
1759
            ac_val -= 16;
1760
            
1761
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1762
                /* same qscale */
1763
                for(i=1;i<8;i++) {
1764
                    block[s->idct_permutation[i<<3]] += ac_val[i];
1765
                }
1766
            }else{
1767
                /* different qscale, we must rescale */
1768
                for(i=1;i<8;i++) {
1769
                    block[s->idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1770
                }
1771
            }
1772
        } else {
1773
            const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1774
            /* top prediction */
1775
            ac_val -= 16 * s->block_wrap[n];
1776

    
1777
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1778
                /* same qscale */
1779
                for(i=1;i<8;i++) {
1780
                    block[s->idct_permutation[i]] += ac_val[i + 8];
1781
                }
1782
            }else{
1783
                /* different qscale, we must rescale */
1784
                for(i=1;i<8;i++) {
1785
                    block[s->idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1786
                }
1787
            }
1788
        }
1789
    }
1790
    /* left copy */
1791
    for(i=1;i<8;i++)
1792
        ac_val1[i    ] = block[s->idct_permutation[i<<3]];
1793

    
1794
    /* top copy */
1795
    for(i=1;i<8;i++)
1796
        ac_val1[8 + i] = block[s->idct_permutation[i   ]];
1797

    
1798
}
1799

    
1800
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1801
                              int dir)
1802
{
1803
    int i;
1804
    INT16 *ac_val;
1805
    int8_t * const qscale_table= s->current_picture.qscale_table;
1806

    
1807
    /* find prediction */
1808
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1809
 
1810
    if (dir == 0) {
1811
        const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1812
        /* left prediction */
1813
        ac_val -= 16;
1814
        if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1815
            /* same qscale */
1816
            for(i=1;i<8;i++) {
1817
                block[s->idct_permutation[i<<3]] -= ac_val[i];
1818
            }
1819
        }else{
1820
            /* different qscale, we must rescale */
1821
            for(i=1;i<8;i++) {
1822
                block[s->idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1823
            }
1824
        }
1825
    } else {
1826
        const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1827
        /* top prediction */
1828
        ac_val -= 16 * s->block_wrap[n];
1829
        if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1830
            /* same qscale */
1831
            for(i=1;i<8;i++) {
1832
                block[s->idct_permutation[i]] -= ac_val[i + 8];
1833
            }
1834
        }else{
1835
            /* different qscale, we must rescale */
1836
            for(i=1;i<8;i++) {
1837
                block[s->idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1838
            }
1839
        }
1840
    }
1841
}
1842

    
1843
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1844
{
1845
#if 1
1846
//    if(level<-255 || level>255) printf("dc overflow\n");
1847
    level+=256;
1848
    if (n < 4) {
1849
        /* luminance */
1850
        put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1851
    } else {
1852
        /* chrominance */
1853
        put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1854
    }
1855
#else
1856
    int size, v;
1857
    /* find number of bits */
1858
    size = 0;
1859
    v = abs(level);
1860
    while (v) {
1861
        v >>= 1;
1862
        size++;
1863
    }
1864

    
1865
    if (n < 4) {
1866
        /* luminance */
1867
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1868
    } else {
1869
        /* chrominance */
1870
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1871
    }
1872

    
1873
    /* encode remaining bits */
1874
    if (size > 0) {
1875
        if (level < 0)
1876
            level = (-level) ^ ((1 << size) - 1);
1877
        put_bits(&s->pb, size, level);
1878
        if (size > 8)
1879
            put_bits(&s->pb, 1, 1);
1880
    }
1881
#endif
1882
}
1883
#ifdef CONFIG_ENCODERS
1884
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
1885
                               UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
1886
{
1887
    int i, last_non_zero;
1888
#if 0 //variables for the outcommented version
1889
    int code, sign, last;
1890
#endif
1891
    const RLTable *rl;
1892
    UINT32 *bits_tab;
1893
    UINT8 *len_tab;
1894
    const int last_index = s->block_last_index[n];
1895

    
1896
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
1897
        /* mpeg4 based DC predictor */
1898
        mpeg4_encode_dc(dc_pb, intra_dc, n);
1899
        if(last_index<1) return;
1900
        i = 1;
1901
        rl = &rl_intra;
1902
        bits_tab= uni_mpeg4_intra_rl_bits;
1903
        len_tab = uni_mpeg4_intra_rl_len;
1904
    } else {
1905
        if(last_index<0) return;
1906
        i = 0;
1907
        rl = &rl_inter;
1908
        bits_tab= uni_mpeg4_inter_rl_bits;
1909
        len_tab = uni_mpeg4_inter_rl_len;
1910
    }
1911

    
1912
    /* AC coefs */
1913
    last_non_zero = i - 1;
1914
#if 1
1915
    for (; i < last_index; i++) {
1916
        int level = block[ scan_table[i] ];
1917
        if (level) {
1918
            int run = i - last_non_zero - 1;
1919
            level+=64;
1920
            if((level&(~127)) == 0){
1921
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
1922
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
1923
            }else{ //ESC3
1924
                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);
1925
            }
1926
            last_non_zero = i;
1927
        }
1928
    }
1929
    /*if(i<=last_index)*/{
1930
        int level = block[ scan_table[i] ];
1931
        int run = i - last_non_zero - 1;
1932
        level+=64;
1933
        if((level&(~127)) == 0){
1934
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
1935
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
1936
        }else{ //ESC3
1937
            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);
1938
        }
1939
    }
1940
#else
1941
    for (; i <= last_index; i++) {
1942
        const int slevel = block[ scan_table[i] ];
1943
        if (slevel) {
1944
            int level;
1945
            int run = i - last_non_zero - 1;
1946
            last = (i == last_index);
1947
            sign = 0;
1948
            level = slevel;
1949
            if (level < 0) {
1950
                sign = 1;
1951
                level = -level;
1952
            }
1953
            code = get_rl_index(rl, last, run, level);
1954
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1955
            if (code == rl->n) {
1956
                int level1, run1;
1957
                level1 = level - rl->max_level[last][run];
1958
                if (level1 < 1) 
1959
                    goto esc2;
1960
                code = get_rl_index(rl, last, run, level1);
1961
                if (code == rl->n) {
1962
                esc2:
1963
                    put_bits(ac_pb, 1, 1);
1964
                    if (level > MAX_LEVEL)
1965
                        goto esc3;
1966
                    run1 = run - rl->max_run[last][level] - 1;
1967
                    if (run1 < 0)
1968
                        goto esc3;
1969
                    code = get_rl_index(rl, last, run1, level);
1970
                    if (code == rl->n) {
1971
                    esc3:
1972
                        /* third escape */
1973
                        put_bits(ac_pb, 1, 1);
1974
                        put_bits(ac_pb, 1, last);
1975
                        put_bits(ac_pb, 6, run);
1976
                        put_bits(ac_pb, 1, 1);
1977
                        put_bits(ac_pb, 12, slevel & 0xfff);
1978
                        put_bits(ac_pb, 1, 1);
1979
                    } else {
1980
                        /* second escape */
1981
                        put_bits(ac_pb, 1, 0);
1982
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1983
                        put_bits(ac_pb, 1, sign);
1984
                    }
1985
                } else {
1986
                    /* first escape */
1987
                    put_bits(ac_pb, 1, 0);
1988
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1989
                    put_bits(ac_pb, 1, sign);
1990
                }
1991
            } else {
1992
                put_bits(ac_pb, 1, sign);
1993
            }
1994
            last_non_zero = i;
1995
        }
1996
    }
1997
#endif
1998
}
1999
#endif
2000

    
2001

    
2002
/***********************************************/
2003
/* decoding */
2004

    
2005
static VLC intra_MCBPC_vlc;
2006
static VLC inter_MCBPC_vlc;
2007
static VLC cbpy_vlc;
2008
static VLC mv_vlc;
2009
static VLC dc_lum, dc_chrom;
2010
static VLC sprite_trajectory;
2011
static VLC mb_type_b_vlc;
2012

    
2013
void init_rl(RLTable *rl)
2014
{
2015
    INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
2016
    UINT8 index_run[MAX_RUN+1];
2017
    int last, run, level, start, end, i;
2018

    
2019
    /* compute max_level[], max_run[] and index_run[] */
2020
    for(last=0;last<2;last++) {
2021
        if (last == 0) {
2022
            start = 0;
2023
            end = rl->last;
2024
        } else {
2025
            start = rl->last;
2026
            end = rl->n;
2027
        }
2028

    
2029
        memset(max_level, 0, MAX_RUN + 1);
2030
        memset(max_run, 0, MAX_LEVEL + 1);
2031
        memset(index_run, rl->n, MAX_RUN + 1);
2032
        for(i=start;i<end;i++) {
2033
            run = rl->table_run[i];
2034
            level = rl->table_level[i];
2035
            if (index_run[run] == rl->n)
2036
                index_run[run] = i;
2037
            if (level > max_level[run])
2038
                max_level[run] = level;
2039
            if (run > max_run[level])
2040
                max_run[level] = run;
2041
        }
2042
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
2043
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
2044
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
2045
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
2046
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
2047
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
2048
    }
2049
}
2050

    
2051
void init_vlc_rl(RLTable *rl)
2052
{
2053
    int i, q;
2054
    
2055
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2056
             &rl->table_vlc[0][1], 4, 2,
2057
             &rl->table_vlc[0][0], 4, 2);
2058

    
2059
    
2060
    for(q=0; q<32; q++){
2061
        int qmul= q*2;
2062
        int qadd= (q-1)|1;
2063
        
2064
        if(q==0){
2065
            qmul=1;
2066
            qadd=0;
2067
        }
2068
        
2069
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2070
        for(i=0; i<rl->vlc.table_size; i++){
2071
            int code= rl->vlc.table[i][0];
2072
            int len = rl->vlc.table[i][1];
2073
            int level, run;
2074
        
2075
            if(len==0){ // illegal code
2076
                run= 66;
2077
                level= MAX_LEVEL;
2078
            }else if(len<0){ //more bits needed
2079
                run= 0;
2080
                level= code;
2081
            }else{
2082
                if(code==rl->n){ //esc
2083
                    run= 66;
2084
                    level= 0;
2085
                }else{
2086
                    run=   rl->table_run  [code] + 1;
2087
                    level= rl->table_level[code] * qmul + qadd;
2088
                    if(code >= rl->last) run+=192;
2089
                }
2090
            }
2091
            rl->rl_vlc[q][i].len= len;
2092
            rl->rl_vlc[q][i].level= level;
2093
            rl->rl_vlc[q][i].run= run;
2094
        }
2095
    }
2096
}
2097

    
2098
/* init vlcs */
2099

    
2100
/* XXX: find a better solution to handle static init */
2101
void h263_decode_init_vlc(MpegEncContext *s)
2102
{
2103
    static int done = 0;
2104

    
2105
    if (!done) {
2106
        done = 1;
2107

    
2108
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8, 
2109
                 intra_MCBPC_bits, 1, 1,
2110
                 intra_MCBPC_code, 1, 1);
2111
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25, 
2112
                 inter_MCBPC_bits, 1, 1,
2113
                 inter_MCBPC_code, 1, 1);
2114
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2115
                 &cbpy_tab[0][1], 2, 1,
2116
                 &cbpy_tab[0][0], 2, 1);
2117
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2118
                 &mvtab[0][1], 2, 1,
2119
                 &mvtab[0][0], 2, 1);
2120
        init_rl(&rl_inter);
2121
        init_rl(&rl_intra);
2122
        init_rl(&rl_intra_aic);
2123
        init_vlc_rl(&rl_inter);
2124
        init_vlc_rl(&rl_intra);
2125
        init_vlc_rl(&rl_intra_aic);
2126
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2127
                 &DCtab_lum[0][1], 2, 1,
2128
                 &DCtab_lum[0][0], 2, 1);
2129
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2130
                 &DCtab_chrom[0][1], 2, 1,
2131
                 &DCtab_chrom[0][0], 2, 1);
2132
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2133
                 &sprite_trajectory_tab[0][1], 4, 2,
2134
                 &sprite_trajectory_tab[0][0], 4, 2);
2135
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2136
                 &mb_type_b_tab[0][1], 2, 1,
2137
                 &mb_type_b_tab[0][0], 2, 1);
2138
    }
2139
}
2140

    
2141
/**
2142
 * Get the GOB height based on picture height.
2143
 */
2144
int ff_h263_get_gob_height(MpegEncContext *s){
2145
    if (s->height <= 400)
2146
        return 1;
2147
    else if (s->height <= 800)
2148
        return  2;
2149
    else
2150
        return 4;
2151
}
2152

    
2153
/**
2154
 * decodes the group of blocks header.
2155
 * @return <0 if an error occured
2156
 */
2157
static int h263_decode_gob_header(MpegEncContext *s)
2158
{
2159
    unsigned int val, gfid;
2160
    int left;
2161
    
2162
    /* Check for GOB Start Code */
2163
    val = show_bits(&s->gb, 16);
2164
    if(val)
2165
        return -1;
2166

    
2167
        /* We have a GBSC probably with GSTUFF */
2168
    skip_bits(&s->gb, 16); /* Drop the zeros */
2169
    left= s->gb.size*8 - get_bits_count(&s->gb);
2170
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2171
    for(;left>13; left--){
2172
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2173
    }
2174
    if(left<=13) 
2175
        return -1;
2176

    
2177
#ifdef DEBUG
2178
    fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2179
#endif
2180
    s->gob_number = get_bits(&s->gb, 5); /* GN */
2181
    gfid = get_bits(&s->gb, 2); /* GFID */
2182
    s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2183
    if(s->qscale==0) 
2184
        return -1;
2185
    s->mb_x= 0;
2186
    s->mb_y= s->gob_index* s->gob_number;
2187
#ifdef DEBUG
2188
    fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2189
#endif
2190
    return 0;
2191
}
2192

    
2193
static inline void memsetw(short *tab, int val, int n)
2194
{
2195
    int i;
2196
    for(i=0;i<n;i++)
2197
        tab[i] = val;
2198
}
2199

    
2200
void ff_mpeg4_init_partitions(MpegEncContext *s)
2201
{
2202
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2203
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
2204
}
2205

    
2206
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2207
{
2208
    const int pb2_len   = get_bit_count(&s->pb2   );
2209
    const int tex_pb_len= get_bit_count(&s->tex_pb);
2210
    const int bits= get_bit_count(&s->pb);
2211

    
2212
    if(s->pict_type==I_TYPE){
2213
        put_bits(&s->pb, 19, DC_MARKER);
2214
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2215
        s->i_tex_bits+= tex_pb_len;
2216
    }else{
2217
        put_bits(&s->pb, 17, MOTION_MARKER);
2218
        s->misc_bits+=17 + pb2_len;
2219
        s->mv_bits+= bits - s->last_bits;
2220
        s->p_tex_bits+= tex_pb_len;
2221
    }
2222

    
2223
    flush_put_bits(&s->pb2);
2224
    flush_put_bits(&s->tex_pb);
2225

    
2226
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2227
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2228
    s->last_bits= get_bit_count(&s->pb);
2229
}
2230

    
2231
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2232
    switch(s->pict_type){
2233
        case I_TYPE:
2234
            return 16;
2235
        case P_TYPE:
2236
        case S_TYPE:
2237
            return s->f_code+15;
2238
        case B_TYPE:
2239
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2240
        default:
2241
            return -1;
2242
    }
2243
}
2244

    
2245
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2246
{
2247
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2248

    
2249
    ff_mpeg4_stuffing(&s->pb);
2250
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2251
    put_bits(&s->pb, 1, 1);
2252
    
2253
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2254
    put_bits(&s->pb, s->quant_precision, s->qscale);
2255
    put_bits(&s->pb, 1, 0); /* no HEC */
2256
}
2257

    
2258
/**
2259
 * check if the next stuff is a resync marker or the end.
2260
 * @return 0 if not
2261
 */
2262
static inline int mpeg4_is_resync(MpegEncContext *s){
2263
    const int bits_count= get_bits_count(&s->gb);
2264
    
2265
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
2266
        return 0;
2267
    }
2268

    
2269
    if(bits_count + 8 >= s->gb.size*8){
2270
        int v= show_bits(&s->gb, 8);
2271
        v|= 0x7F >> (7-(bits_count&7));
2272
                
2273
        if(v==0x7F)
2274
            return 1;
2275
    }else{
2276
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2277
            int len;
2278
            GetBitContext gb= s->gb;
2279
        
2280
            skip_bits(&s->gb, 1);
2281
            align_get_bits(&s->gb);
2282
        
2283
            for(len=0; len<32; len++){
2284
                if(get_bits1(&s->gb)) break;
2285
            }
2286

    
2287
            s->gb= gb;
2288

    
2289
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2290
                return 1;
2291
        }
2292
    }
2293
    return 0;
2294
}
2295

    
2296
/**
2297
 * decodes the next video packet.
2298
 * @return <0 if something went wrong
2299
 */
2300
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2301
{
2302
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2303
    int header_extension=0, mb_num, len;
2304
    
2305
    /* is there enough space left for a video packet + header */
2306
    if( get_bits_count(&s->gb) > s->gb.size*8-20) return -1;
2307

    
2308
    for(len=0; len<32; len++){
2309
        if(get_bits1(&s->gb)) break;
2310
    }
2311

    
2312
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2313
        printf("marker does not match f_code\n");
2314
        return -1;
2315
    }
2316
    
2317
    if(s->shape != RECT_SHAPE){
2318
        header_extension= get_bits1(&s->gb);
2319
        //FIXME more stuff here
2320
    }
2321

    
2322
    mb_num= get_bits(&s->gb, mb_num_bits);
2323
    if(mb_num>=s->mb_num){
2324
        fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2325
        return -1;
2326
    }
2327
    s->mb_x= mb_num % s->mb_width;
2328
    s->mb_y= mb_num / s->mb_width;
2329

    
2330
    if(s->shape != BIN_ONLY_SHAPE){
2331
        int qscale= get_bits(&s->gb, s->quant_precision); 
2332
        if(qscale)
2333
            s->qscale= qscale;
2334
    }
2335

    
2336
    if(s->shape == RECT_SHAPE){
2337
        header_extension= get_bits1(&s->gb);
2338
    }
2339
    if(header_extension){
2340
        int time_increment;
2341
        int time_incr=0;
2342

    
2343
        while (get_bits1(&s->gb) != 0) 
2344
            time_incr++;
2345

    
2346
        check_marker(&s->gb, "before time_increment in video packed header");
2347
        time_increment= get_bits(&s->gb, s->time_increment_bits);
2348
        check_marker(&s->gb, "before vop_coding_type in video packed header");
2349
        
2350
        skip_bits(&s->gb, 2); /* vop coding type */
2351
        //FIXME not rect stuff here
2352

    
2353
        if(s->shape != BIN_ONLY_SHAPE){
2354
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2355
//FIXME dont just ignore everything
2356
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2357
                mpeg4_decode_sprite_trajectory(s);
2358
                fprintf(stderr, "untested\n");
2359
            }
2360

    
2361
            //FIXME reduced res stuff here
2362
            
2363
            if (s->pict_type != I_TYPE) {
2364
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
2365
                if(f_code==0){
2366
                    printf("Error, video packet header damaged (f_code=0)\n");
2367
                }
2368
            }
2369
            if (s->pict_type == B_TYPE) {
2370
                int b_code = get_bits(&s->gb, 3);
2371
                if(b_code==0){
2372
                    printf("Error, video packet header damaged (b_code=0)\n");
2373
                }
2374
            }       
2375
        }
2376
    }
2377
    //FIXME new-pred stuff
2378
    
2379
//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));
2380

    
2381
    return 0;
2382
}
2383

    
2384
void ff_mpeg4_clean_buffers(MpegEncContext *s)
2385
{
2386
    int c_wrap, c_xy, l_wrap, l_xy;
2387

    
2388
    l_wrap= s->block_wrap[0];
2389
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2390
    c_wrap= s->block_wrap[4];
2391
    c_xy= s->mb_y*c_wrap + s->mb_x;
2392

    
2393
#if 0
2394
    /* clean DC */
2395
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2396
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2397
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2398
#endif
2399

    
2400
    /* clean AC */
2401
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
2402
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
2403
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
2404

    
2405
    /* clean MV */
2406
    // we cant clear the MVs as they might be needed by a b frame
2407
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
2408
//    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2409
    s->last_mv[0][0][0]=
2410
    s->last_mv[0][0][1]=
2411
    s->last_mv[1][0][0]=
2412
    s->last_mv[1][0][1]= 0;
2413
}
2414

    
2415
/**
2416
 * decodes the group of blocks / video packet header.
2417
 * @return <0 if no resync found
2418
 */
2419
int ff_h263_resync(MpegEncContext *s){
2420
    int left, ret;
2421
    
2422
    if(s->codec_id==CODEC_ID_MPEG4)
2423
        skip_bits1(&s->gb);
2424
    
2425
    align_get_bits(&s->gb);
2426

    
2427
    if(show_bits(&s->gb, 16)==0){
2428
        if(s->codec_id==CODEC_ID_MPEG4)
2429
            ret= mpeg4_decode_video_packet_header(s);
2430
        else
2431
            ret= h263_decode_gob_header(s);
2432
        if(ret>=0)
2433
            return 0;
2434
    }
2435
    //ok, its not where its supposed to be ...
2436
    s->gb= s->last_resync_gb;
2437
    align_get_bits(&s->gb);
2438
    left= s->gb.size*8 - get_bits_count(&s->gb);
2439
    
2440
    for(;left>16+1+5+5; left-=8){ 
2441
        if(show_bits(&s->gb, 16)==0){
2442
            GetBitContext bak= s->gb;
2443

    
2444
            if(s->codec_id==CODEC_ID_MPEG4)
2445
                ret= mpeg4_decode_video_packet_header(s);
2446
            else
2447
                ret= h263_decode_gob_header(s);
2448
            if(ret>=0)
2449
                return 0;
2450

    
2451
            s->gb= bak;
2452
        }
2453
        skip_bits(&s->gb, 8);
2454
    }
2455
    
2456
    return -1;
2457
}
2458

    
2459
/**
2460
 * @param n either 0 for the x component or 1 for y
2461
 * @returns the average MV for a GMC MB
2462
 */
2463
static inline int get_amv(MpegEncContext *s, int n){
2464
    int x, y, mb_v, sum, dx, dy, shift;
2465
    int len = 1 << (s->f_code + 4);
2466
    const int a= s->sprite_warping_accuracy;
2467

    
2468
    if(s->real_sprite_warping_points==1){
2469
        if(s->divx_version==500 && s->divx_build==413)
2470
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2471
        else
2472
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2473
    }else{
2474
        dx= s->sprite_delta[n][0];
2475
        dy= s->sprite_delta[n][1];
2476
        shift= s->sprite_shift[0];
2477
        if(n) dy -= 1<<(shift + a + 1);
2478
        else  dx -= 1<<(shift + a + 1);
2479
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2480

    
2481
        sum=0;
2482
        for(y=0; y<16; y++){
2483
            int v;
2484
        
2485
            v= mb_v + dy*y;
2486
            //XXX FIXME optimize
2487
            for(x=0; x<16; x++){
2488
                sum+= v>>shift;
2489
                v+= dx;
2490
            }
2491
        }
2492
        sum /= 256;
2493
        sum= RSHIFT(sum<<s->quarter_sample, a);
2494
    }
2495

    
2496
    if      (sum < -len) sum= -len;
2497
    else if (sum >= len) sum= len-1;
2498

    
2499
    return sum;
2500
}
2501

    
2502
/**
2503
 * decodes first partition.
2504
 * @return number of MBs decoded or <0 if an error occured
2505
 */
2506
static int mpeg4_decode_partition_a(MpegEncContext *s){
2507
    int mb_num;
2508
    static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2509
    
2510
    /* decode first partition */
2511
    mb_num=0;
2512
    s->first_slice_line=1;
2513
    for(; s->mb_y<s->mb_height; s->mb_y++){
2514
        ff_init_block_index(s);
2515
        for(; s->mb_x<s->mb_width; s->mb_x++){
2516
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2517
            int cbpc;
2518
            int dir=0;
2519
            
2520
            mb_num++;
2521
            ff_update_block_index(s);
2522
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2523
                s->first_slice_line=0;
2524
            
2525
            if(s->mb_x==0) PRINT_MB_TYPE("\n");
2526

    
2527
            if(s->pict_type==I_TYPE){
2528
                int i;
2529

    
2530
                if(show_bits(&s->gb, 19)==DC_MARKER){
2531
                    return mb_num-1;
2532
                }
2533

    
2534
                PRINT_MB_TYPE("I");
2535
                cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2536
                if (cbpc < 0){
2537

    
2538
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2539
                    return -1;
2540
                }
2541
                s->cbp_table[xy]= cbpc & 3;
2542
                s->mb_type[xy]= MB_TYPE_INTRA;
2543
                s->mb_intra = 1;
2544

    
2545
                if(cbpc & 4) {
2546
                    change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2547
                }
2548
                s->current_picture.qscale_table[xy]= s->qscale;
2549

    
2550
                s->mbintra_table[xy]= 1;
2551
                for(i=0; i<6; i++){
2552
                    int dc_pred_dir;
2553
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2554
                    if(dc < 0){
2555
                        fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2556
                        return -1;
2557
                    }
2558
                    dir<<=1;
2559
                    if(dc_pred_dir) dir|=1;
2560
                }
2561
                s->pred_dir_table[xy]= dir;
2562
                
2563
                s->error_status_table[xy]= AC_ERROR;
2564
            }else{ /* P/S_TYPE */
2565
                int mx, my, pred_x, pred_y, bits;
2566
                INT16 * const mot_val= s->motion_val[s->block_index[0]];
2567
                const int stride= s->block_wrap[0]*2;
2568

    
2569
                bits= show_bits(&s->gb, 17);
2570
                if(bits==MOTION_MARKER){
2571
                    return mb_num-1;
2572
                }
2573
                skip_bits1(&s->gb);
2574
                if(bits&0x10000){
2575
                    /* skip mb */
2576
                    s->mb_type[xy]= MB_TYPE_SKIPED;
2577
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2578
                        PRINT_MB_TYPE("G");
2579
                        mx= get_amv(s, 0);
2580
                        my= get_amv(s, 1);
2581
                    }else{
2582
                        PRINT_MB_TYPE("S");
2583
                        mx=my=0;
2584
                    }
2585
                    mot_val[0       ]= mot_val[2       ]=
2586
                    mot_val[0+stride]= mot_val[2+stride]= mx;
2587
                    mot_val[1       ]= mot_val[3       ]=
2588
                    mot_val[1+stride]= mot_val[3+stride]= my;
2589

    
2590
                    if(s->mbintra_table[xy])
2591
                        ff_clean_intra_table_entries(s);
2592

    
2593
                    s->error_status_table[xy]= AC_ERROR;
2594
                    continue;
2595
                }
2596
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2597
                if (cbpc < 0){
2598
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2599
                    return -1;
2600
                }
2601
                if (cbpc > 20)
2602
                    cbpc+=3;
2603
                else if (cbpc == 20)
2604
                    fprintf(stderr, "Stuffing !");
2605
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2606
    
2607
                s->mb_intra = ((cbpc & 4) != 0);
2608
        
2609
                if(s->mb_intra){
2610
                    PRINT_MB_TYPE("I");
2611
                    s->mbintra_table[xy]= 1;
2612
                    s->mb_type[xy]= MB_TYPE_INTRA;
2613
                    mot_val[0       ]= mot_val[2       ]= 
2614
                    mot_val[0+stride]= mot_val[2+stride]= 0;
2615
                    mot_val[1       ]= mot_val[3       ]=
2616
                    mot_val[1+stride]= mot_val[3+stride]= 0;
2617
                    s->error_status_table[xy]= DC_ERROR|AC_ERROR;
2618
                }else{
2619
                    if(s->mbintra_table[xy])
2620
                        ff_clean_intra_table_entries(s);
2621

    
2622
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2623
                        s->mcsel= get_bits1(&s->gb);
2624
                    else s->mcsel= 0;
2625
        
2626
                    if ((cbpc & 16) == 0) {
2627
                        PRINT_MB_TYPE("P");
2628
                        /* 16x16 motion prediction */
2629
                        s->mb_type[xy]= MB_TYPE_INTER;
2630

    
2631
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
2632
                        if(!s->mcsel){
2633
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2634
                            if (mx >= 0xffff)
2635
                                return -1;
2636

    
2637
                            my = h263_decode_motion(s, pred_y, s->f_code);
2638
                            if (my >= 0xffff)
2639
                                return -1;
2640
                        } else {
2641
                            mx = get_amv(s, 0);
2642
                            my = get_amv(s, 1);
2643
                        }
2644

    
2645
                        mot_val[0       ]= mot_val[2       ] =
2646
                        mot_val[0+stride]= mot_val[2+stride]= mx;
2647
                        mot_val[1       ]= mot_val[3       ]=
2648
                        mot_val[1+stride]= mot_val[3+stride]= my;
2649
                    } else {
2650
                        int i;
2651
                        PRINT_MB_TYPE("4");
2652
                        s->mb_type[xy]= MB_TYPE_INTER4V;
2653
                        for(i=0;i<4;i++) {
2654
                            INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2655
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2656
                            if (mx >= 0xffff)
2657
                                return -1;
2658
                
2659
                            my = h263_decode_motion(s, pred_y, s->f_code);
2660
                            if (my >= 0xffff)
2661
                                return -1;
2662
                            mot_val[0] = mx;
2663
                            mot_val[1] = my;
2664
                        }
2665
                    }
2666
                    s->error_status_table[xy]= AC_ERROR;
2667
                }
2668
            }
2669
        }
2670
        s->mb_x= 0;
2671
    }
2672

    
2673
    return mb_num;
2674
}
2675

    
2676
/**
2677
 * decode second partition.
2678
 * @return <0 if an error occured
2679
 */
2680
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
2681
    int mb_num=0;
2682
    static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2683

    
2684
    s->mb_x= s->resync_mb_x;
2685
    s->first_slice_line=1;
2686
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
2687
        ff_init_block_index(s);
2688
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
2689
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2690

    
2691
            mb_num++;
2692
            ff_update_block_index(s);
2693
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2694
                s->first_slice_line=0;
2695
            
2696
            if(s->pict_type==I_TYPE){
2697
                int ac_pred= get_bits1(&s->gb);
2698
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2699
                if(cbpy<0){
2700
                    fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2701
                    return -1;
2702
                }
2703
                
2704
                s->cbp_table[xy]|= cbpy<<2;
2705
                s->pred_dir_table[xy]|= ac_pred<<7;
2706
            }else{ /* P || S_TYPE */
2707
                if(s->mb_type[xy]&MB_TYPE_INTRA){          
2708
                    int dir=0,i;
2709
                    int ac_pred = get_bits1(&s->gb);
2710
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2711

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

    
2722
                    for(i=0; i<6; i++){
2723
                        int dc_pred_dir;
2724
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2725
                        if(dc < 0){
2726
                            fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2727
                            return -1;
2728
                        }
2729
                        dir<<=1;
2730
                        if(dc_pred_dir) dir|=1;
2731
                    }
2732
                    s->cbp_table[xy]&= 3; //remove dquant
2733
                    s->cbp_table[xy]|= cbpy<<2;
2734
                    s->pred_dir_table[xy]= dir | (ac_pred<<7);
2735
                    s->error_status_table[xy]&= ~DC_ERROR;
2736
                }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
2737
                    s->current_picture.qscale_table[xy]= s->qscale;
2738
                    s->cbp_table[xy]= 0;
2739
                }else{
2740
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2741

    
2742
                    if(cbpy<0){
2743
                        fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2744
                        return -1;
2745
                    }
2746
                    
2747
                    if(s->cbp_table[xy] & 8) {
2748
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2749
                    }
2750
                    s->current_picture.qscale_table[xy]= s->qscale;
2751

    
2752
                    s->cbp_table[xy]&= 3; //remove dquant
2753
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
2754
                }
2755
            }
2756
        }
2757
        if(mb_num >= mb_count) return 0;
2758
        s->mb_x= 0;
2759
    }
2760
    return 0;
2761
}
2762

    
2763
/**
2764
 * decodes the first & second partition
2765
 * @return <0 if error (and sets error type in the error_status_table)
2766
 */
2767
int ff_mpeg4_decode_partitions(MpegEncContext *s)
2768
{
2769
    int mb_num;
2770
    
2771
    mb_num= mpeg4_decode_partition_a(s);    
2772
    if(mb_num<0)
2773
        return -1;
2774
    
2775
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
2776
        fprintf(stderr, "slice below monitor ...\n");
2777
        return -1;
2778
    }
2779

    
2780
    s->mb_num_left= mb_num;
2781
        
2782
    if(s->pict_type==I_TYPE){
2783
        if(get_bits(&s->gb, 19)!=DC_MARKER){
2784
            fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
2785
            return -1;
2786
        }else
2787
            s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END|DC_END;
2788
    }else{
2789
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
2790
            fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
2791
            return -1;
2792
        }else
2793
            s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END;
2794
    }
2795
    
2796
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
2797
        return -1;
2798
    }
2799
    
2800
    s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= DC_END;
2801

    
2802
    return 0;        
2803
}
2804

    
2805
/**
2806
 * decode partition C of one MB.
2807
 * @return <0 if an error occured
2808
 */
2809
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
2810
{
2811
    int cbp, mb_type;
2812
    const int xy= s->mb_x + s->mb_y*s->mb_width;
2813

    
2814
    mb_type= s->mb_type[xy];
2815
    cbp = s->cbp_table[xy];
2816

    
2817
    if(s->current_picture.qscale_table[xy] != s->qscale){
2818
        s->qscale= s->current_picture.qscale_table[xy];
2819
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2820
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2821
    }
2822
    
2823
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2824
        int i;
2825
        for(i=0; i<4; i++){
2826
            s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
2827
            s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
2828
        }
2829
        s->mb_intra = mb_type&MB_TYPE_INTRA;
2830

    
2831
        if (mb_type&MB_TYPE_SKIPED) {
2832
            /* skip mb */
2833
            for(i=0;i<6;i++)
2834
                s->block_last_index[i] = -1;
2835
            s->mv_dir = MV_DIR_FORWARD;
2836
            s->mv_type = MV_TYPE_16X16;
2837
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2838
                s->mcsel=1;
2839
                s->mb_skiped = 0;
2840
            }else{
2841
                s->mcsel=0;
2842
                s->mb_skiped = 1;
2843
            }
2844
        }else if(s->mb_intra){
2845
            s->ac_pred = s->pred_dir_table[xy]>>7;
2846

    
2847
            /* decode each block */
2848
            for (i = 0; i < 6; i++) {
2849
                if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
2850
                    fprintf(stderr, "texture corrupted at %d %d\n", s->mb_x, s->mb_y);
2851
                    return -1;
2852
                }
2853
                cbp+=cbp;
2854
            }
2855
        }else if(!s->mb_intra){
2856
//            s->mcsel= 0; //FIXME do we need to init that
2857
            
2858
            s->mv_dir = MV_DIR_FORWARD;
2859
            if (mb_type&MB_TYPE_INTER4V) {
2860
                s->mv_type = MV_TYPE_8X8;
2861
            } else {
2862
                s->mv_type = MV_TYPE_16X16;
2863
            }
2864
            /* decode each block */
2865
            for (i = 0; i < 6; i++) {
2866
                if(mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0){
2867
                    fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2868
                    return -1;
2869
                }
2870
                cbp+=cbp;
2871
            }
2872
        }
2873
    } else { /* I-Frame */
2874
        int i;
2875
        s->mb_intra = 1;
2876
        s->ac_pred = s->pred_dir_table[xy]>>7;
2877
        
2878
        /* decode each block */
2879
        for (i = 0; i < 6; i++) {
2880
            if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
2881
                fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
2882
                return -1;
2883
            }
2884
            cbp+=cbp;
2885
        }
2886
    }
2887

    
2888
    s->error_status_table[xy]&= ~AC_ERROR;
2889

    
2890
    /* per-MB end of slice check */
2891

    
2892
    if(--s->mb_num_left <= 0){
2893
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size*8 - get_bits_count(&s->gb));
2894
        if(mpeg4_is_resync(s))
2895
            return SLICE_END;
2896
        else
2897
            return SLICE_NOEND;     
2898
    }else{
2899
        if(s->cbp_table[xy+1] && mpeg4_is_resync(s))
2900
            return SLICE_END;
2901
        else
2902
            return SLICE_OK;
2903
    }
2904
}
2905

    
2906
int ff_h263_decode_mb(MpegEncContext *s,
2907
                      DCTELEM block[6][64])
2908
{
2909
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
2910
    INT16 *mot_val;
2911
    static INT8 quant_tab[4] = { -1, -2, 1, 2 };
2912

    
2913
    s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
2914

    
2915
    if(s->mb_x==0) PRINT_MB_TYPE("\n");
2916

    
2917
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2918
        if (get_bits1(&s->gb)) {
2919
            /* skip mb */
2920
            s->mb_intra = 0;
2921
            for(i=0;i<6;i++)
2922
                s->block_last_index[i] = -1;
2923
            s->mv_dir = MV_DIR_FORWARD;
2924
            s->mv_type = MV_TYPE_16X16;
2925
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2926
                PRINT_MB_TYPE("G");
2927
                s->mcsel=1;
2928
                s->mv[0][0][0]= get_amv(s, 0);
2929
                s->mv[0][0][1]= get_amv(s, 1);
2930

    
2931
                s->mb_skiped = 0;
2932
            }else{
2933
                PRINT_MB_TYPE("S");
2934
                s->mcsel=0;
2935
                s->mv[0][0][0] = 0;
2936
                s->mv[0][0][1] = 0;
2937
                s->mb_skiped = 1;
2938
            }
2939
            goto end;
2940
        }
2941
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2942
        //fprintf(stderr, "\tCBPC: %d", cbpc);
2943
        if (cbpc < 0)
2944
            return -1;
2945
        if (cbpc > 20)
2946
            cbpc+=3;
2947
        else if (cbpc == 20)
2948
            fprintf(stderr, "Stuffing !");
2949
        
2950
        dquant = cbpc & 8;
2951
        s->mb_intra = ((cbpc & 4) != 0);
2952
        if (s->mb_intra) goto intra;
2953
        
2954
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2955
            s->mcsel= get_bits1(&s->gb);
2956
        else s->mcsel= 0;
2957
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2958
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
2959
        if (dquant) {
2960
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2961
        }
2962
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
2963
            s->interlaced_dct= get_bits1(&s->gb);
2964
        
2965
        s->mv_dir = MV_DIR_FORWARD;
2966
        if ((cbpc & 16) == 0) {
2967
            if(s->mcsel){
2968
                PRINT_MB_TYPE("G");
2969
                /* 16x16 global motion prediction */
2970
                s->mv_type = MV_TYPE_16X16;
2971
                mx= get_amv(s, 0);
2972
                my= get_amv(s, 1);
2973
                s->mv[0][0][0] = mx;
2974
                s->mv[0][0][1] = my;
2975
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
2976
                PRINT_MB_TYPE("f");
2977
                /* 16x8 field motion prediction */
2978
                s->mv_type= MV_TYPE_FIELD;
2979

    
2980
                s->field_select[0][0]= get_bits1(&s->gb);
2981
                s->field_select[0][1]= get_bits1(&s->gb);
2982

    
2983
                h263_pred_motion(s, 0, &pred_x, &pred_y);
2984
                
2985
                for(i=0; i<2; i++){
2986
                    mx = h263_decode_motion(s, pred_x, s->f_code);
2987
                    if (mx >= 0xffff)
2988
                        return -1;
2989
            
2990
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
2991
                    if (my >= 0xffff)
2992
                        return -1;
2993

    
2994
                    s->mv[0][i][0] = mx;
2995
                    s->mv[0][i][1] = my;
2996
                }
2997
            }else{
2998
                PRINT_MB_TYPE("P");
2999
                /* 16x16 motion prediction */
3000
                s->mv_type = MV_TYPE_16X16;
3001
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3002
                if (s->umvplus_dec)
3003
                   mx = h263p_decode_umotion(s, pred_x);
3004
                else
3005
                   mx = h263_decode_motion(s, pred_x, s->f_code);
3006
            
3007
                if (mx >= 0xffff)
3008
                    return -1;
3009
            
3010
                if (s->umvplus_dec)
3011
                   my = h263p_decode_umotion(s, pred_y);
3012
                else
3013
                   my = h263_decode_motion(s, pred_y, s->f_code);
3014
            
3015
                if (my >= 0xffff)
3016
                    return -1;
3017
                s->mv[0][0][0] = mx;
3018
                s->mv[0][0][1] = my;
3019

    
3020
                if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
3021
                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3022
            }
3023
        } else {
3024
            PRINT_MB_TYPE("4");
3025
            s->mv_type = MV_TYPE_8X8;
3026
            for(i=0;i<4;i++) {
3027
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3028
                if (s->umvplus_dec)
3029
                  mx = h263p_decode_umotion(s, pred_x);
3030
                else
3031
                  mx = h263_decode_motion(s, pred_x, s->f_code);
3032
                if (mx >= 0xffff)
3033
                    return -1;
3034
                
3035
                if (s->umvplus_dec)
3036
                  my = h263p_decode_umotion(s, pred_y);
3037
                else    
3038
                  my = h263_decode_motion(s, pred_y, s->f_code);
3039
                if (my >= 0xffff)
3040
                    return -1;
3041
                s->mv[0][i][0] = mx;
3042
                s->mv[0][i][1] = my;
3043
                if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
3044
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3045
                mot_val[0] = mx;
3046
                mot_val[1] = my;
3047
            }
3048
        }
3049
    } else if(s->pict_type==B_TYPE) {
3050
        int modb1; // first bit of modb
3051
        int modb2; // second bit of modb
3052
        int mb_type;
3053
        uint16_t time_pp;
3054
        uint16_t time_pb;
3055
        int xy;
3056

    
3057
        s->mb_intra = 0; //B-frames never contain intra blocks
3058
        s->mcsel=0;      //     ...               true gmc blocks
3059

    
3060
        if(s->mb_x==0){
3061
            for(i=0; i<2; i++){
3062
                s->last_mv[i][0][0]= 
3063
                s->last_mv[i][0][1]= 
3064
                s->last_mv[i][1][0]= 
3065
                s->last_mv[i][1][1]= 0;
3066
            }
3067
        }
3068

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

    
3072
        if(s->mb_skiped){
3073
                /* skip mb */
3074
            for(i=0;i<6;i++)
3075
                s->block_last_index[i] = -1;
3076

    
3077
            s->mv_dir = MV_DIR_FORWARD;
3078
            s->mv_type = MV_TYPE_16X16;
3079
            s->mv[0][0][0] = 0;
3080
            s->mv[0][0][1] = 0;
3081
            s->mv[1][0][0] = 0;
3082
            s->mv[1][0][1] = 0;
3083
            PRINT_MB_TYPE("s");
3084
            goto end;
3085
        }
3086

    
3087
        modb1= get_bits1(&s->gb); 
3088
        if(modb1){
3089
            mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
3090
            cbp=0;
3091
        }else{
3092
            int field_mv;
3093
        
3094
            modb2= get_bits1(&s->gb);
3095
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3096
            if(modb2) cbp= 0;
3097
            else      cbp= get_bits(&s->gb, 6);
3098

    
3099
            if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
3100
                if(get_bits1(&s->gb)){
3101
                    change_qscale(s, get_bits1(&s->gb)*4 - 2);
3102
                }
3103
            }
3104
            field_mv=0;
3105

    
3106
            if(!s->progressive_sequence){
3107
                if(cbp)
3108
                    s->interlaced_dct= get_bits1(&s->gb);
3109

    
3110
                if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
3111
                    field_mv=1;
3112

    
3113
                    if(mb_type!=MB_TYPE_B_BACKW){
3114
                        s->field_select[0][0]= get_bits1(&s->gb);
3115
                        s->field_select[0][1]= get_bits1(&s->gb);
3116
                    }
3117
                    if(mb_type!=MB_TYPE_B_FORW){
3118
                        s->field_select[1][0]= get_bits1(&s->gb);
3119
                        s->field_select[1][1]= get_bits1(&s->gb);
3120
                    }
3121
                }
3122
            }
3123

    
3124
            s->mv_dir = 0;
3125
            if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
3126
                s->mv_type= MV_TYPE_16X16;
3127
                if(mb_type!=MB_TYPE_B_BACKW){
3128
                    s->mv_dir = MV_DIR_FORWARD;
3129

    
3130
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3131
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3132
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3133
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3134
                }
3135
    
3136
                if(mb_type!=MB_TYPE_B_FORW){
3137
                    s->mv_dir |= MV_DIR_BACKWARD;
3138

    
3139
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3140
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3141
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3142
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3143
                }
3144
                if(mb_type!=MB_TYPE_B_DIRECT)
3145
                    PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "F" : (mb_type==MB_TYPE_B_BACKW ? "B" : "T"));
3146
            }else if(mb_type!=MB_TYPE_B_DIRECT){
3147
                s->mv_type= MV_TYPE_FIELD;
3148

    
3149
                if(mb_type!=MB_TYPE_B_BACKW){
3150
                    s->mv_dir = MV_DIR_FORWARD;
3151
                
3152
                    for(i=0; i<2; i++){
3153
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3154
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3155
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3156
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3157
                    }
3158
                }
3159
    
3160
                if(mb_type!=MB_TYPE_B_FORW){
3161
                    s->mv_dir |= MV_DIR_BACKWARD;
3162

    
3163
                    for(i=0; i<2; i++){
3164
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
3165
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3166
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
3167
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3168
                    }
3169
                }
3170
                if(mb_type!=MB_TYPE_B_DIRECT)
3171
                    PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "f" : (mb_type==MB_TYPE_B_BACKW ? "b" : "t"));
3172
            }
3173
        }
3174
          
3175
        if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
3176
            int mb_index= s->mb_x + s->mb_y*s->mb_width;
3177
            int i;
3178
            
3179
            if(mb_type==4)
3180
                mx=my=0;
3181
            else{
3182
                mx = h263_decode_motion(s, 0, 1);
3183
                my = h263_decode_motion(s, 0, 1);
3184
            }
3185
 
3186
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3187
            xy= s->block_index[0];
3188
            time_pp= s->pp_time;
3189
            time_pb= s->pb_time;
3190
            
3191
            //FIXME avoid divides
3192
            switch(s->co_located_type_table[mb_index]){
3193
            case 0:
3194
                s->mv_type= MV_TYPE_16X16;
3195
                s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
3196
                s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
3197
                s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
3198
                                    : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
3199
                s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
3200
                                    : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
3201
                PRINT_MB_TYPE(mb_type==4 ? "D" : "S");
3202
                break;
3203
            case CO_LOCATED_TYPE_4MV:
3204
                s->mv_type = MV_TYPE_8X8;
3205
                for(i=0; i<4; i++){
3206
                    xy= s->block_index[i];
3207
                    s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
3208
                    s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
3209
                    s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
3210
                                        : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
3211
                    s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1] 
3212
                                        : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
3213
                }
3214
                PRINT_MB_TYPE("4");
3215
                break;
3216
            case CO_LOCATED_TYPE_FIELDMV:
3217
                s->mv_type = MV_TYPE_FIELD;
3218
                for(i=0; i<2; i++){
3219
                    if(s->top_field_first){
3220
                        time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
3221
                        time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
3222
                    }else{
3223
                        time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
3224
                        time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
3225
                    }
3226
                    s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
3227
                    s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
3228
                    s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
3229
                                        : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
3230
                    s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] 
3231
                                        : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
3232
                }
3233
                PRINT_MB_TYPE("=");
3234
                break;
3235
            }
3236
        }
3237
        
3238
        if(mb_type<0 || mb_type>4){
3239
            printf("illegal MB_type\n");
3240
            return -1;
3241
        }
3242
    } else { /* I-Frame */
3243
        cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
3244
        if (cbpc < 0)
3245
            return -1;
3246
        dquant = cbpc & 4;
3247
        s->mb_intra = 1;
3248
intra:
3249
        s->ac_pred = 0;
3250
        if (s->h263_pred || s->h263_aic) {
3251
            s->ac_pred = get_bits1(&s->gb);
3252
            if (s->ac_pred && s->h263_aic)
3253
                s->h263_aic_dir = get_bits1(&s->gb);
3254
        }
3255
        PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
3256
        
3257
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3258
        if(cbpy<0) return -1;
3259
        cbp = (cbpc & 3) | (cbpy << 2);
3260
        if (dquant) {
3261
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3262
        }
3263
        
3264
        if(!s->progressive_sequence)
3265
            s->interlaced_dct= get_bits1(&s->gb);
3266

    
3267
        /* decode each block */
3268
        if (s->h263_pred) {
3269
            for (i = 0; i < 6; i++) {
3270
                if (mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0)
3271
                    return -1;
3272
                cbp+=cbp;
3273
            }
3274
        } else {
3275
            for (i = 0; i < 6; i++) {
3276
                if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3277
                    return -1;
3278
                cbp+=cbp;
3279
            }
3280
        }
3281
        goto end;
3282
    }
3283

    
3284
    /* decode each block */
3285
    if (s->h263_pred) {
3286
        for (i = 0; i < 6; i++) {
3287
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0)
3288
                return -1;
3289
            cbp+=cbp;
3290
        }
3291
    } else {
3292
        for (i = 0; i < 6; i++) {
3293
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3294
                return -1;
3295
            cbp+=cbp;
3296
        }
3297
    }
3298
end:
3299

    
3300
        /* per-MB end of slice check */
3301
    if(s->codec_id==CODEC_ID_MPEG4){
3302
        if(mpeg4_is_resync(s)){
3303
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x+1])
3304
                return SLICE_OK;
3305
            return SLICE_END;
3306
        }
3307
    }else{
3308
        int v= show_bits(&s->gb, 16);
3309
    
3310
        if(get_bits_count(&s->gb) + 16 > s->gb.size*8){
3311
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size*8;
3312
        }
3313

    
3314
        if(v==0)
3315
            return SLICE_END;
3316
    }
3317

    
3318
    return SLICE_OK;     
3319
}
3320

    
3321
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3322
{
3323
    int code, val, sign, shift, l;
3324
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3325
    if (code < 0)
3326
        return 0xffff;
3327

    
3328
    if (code == 0)
3329
        return pred;
3330

    
3331
    sign = get_bits1(&s->gb);
3332
    shift = f_code - 1;
3333
    val = (code - 1) << shift;
3334
    if (shift > 0)
3335
        val |= get_bits(&s->gb, shift);
3336
    val++;
3337
    if (sign)
3338
        val = -val;
3339
    val += pred;
3340

    
3341
    /* modulo decoding */
3342
    if (!s->h263_long_vectors) {
3343
        l = 1 << (f_code + 4);
3344
        if (val < -l) {
3345
            val += l<<1;
3346
        } else if (val >= l) {
3347
            val -= l<<1;
3348
        }
3349
    } else {
3350
        /* horrible h263 long vector mode */
3351
        if (pred < -31 && val < -63)
3352
            val += 64;
3353
        if (pred > 32 && val > 63)
3354
            val -= 64;
3355
        
3356
    }
3357
    return val;
3358
}
3359

    
3360
/* Decodes RVLC of H.263+ UMV */
3361
static int h263p_decode_umotion(MpegEncContext * s, int pred)
3362
{
3363
   int code = 0, sign;
3364
   
3365
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
3366
      return pred;
3367
   
3368
   code = 2 + get_bits1(&s->gb);
3369
   
3370
   while (get_bits1(&s->gb))
3371
   {
3372
      code <<= 1;
3373
      code += get_bits1(&s->gb);
3374
   }
3375
   sign = code & 1;
3376
   code >>= 1;
3377
   
3378
   code = (sign) ? (pred - code) : (pred + code);
3379
#ifdef DEBUG
3380
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3381
#endif
3382
   return code;   
3383

    
3384
}
3385

    
3386
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3387
                             int n, int coded)
3388
{
3389
    int code, level, i, j, last, run;
3390
    RLTable *rl = &rl_inter;
3391
    const UINT8 *scan_table;
3392

    
3393
    scan_table = s->intra_scantable.permutated;
3394
    if (s->h263_aic && s->mb_intra) {
3395
        rl = &rl_intra_aic;
3396
        i = 0;
3397
        if (s->ac_pred) {
3398
            if (s->h263_aic_dir) 
3399
                scan_table = s->intra_v_scantable.permutated; /* left */
3400
            else
3401
                scan_table = s->intra_h_scantable.permutated; /* top */
3402
        }
3403
    } else if (s->mb_intra) {
3404
        /* DC coef */
3405
        if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
3406
            int component, diff;
3407
            component = (n <= 3 ? 0 : n - 4 + 1);
3408
            level = s->last_dc[component];
3409
            if (s->rv10_first_dc_coded[component]) {
3410
                diff = rv_decode_dc(s, n);
3411
                if (diff == 0xffff)
3412
                    return -1;
3413
                level += diff;
3414
                level = level & 0xff; /* handle wrap round */
3415
                s->last_dc[component] = level;
3416
            } else {
3417
                s->rv10_first_dc_coded[component] = 1;
3418
            }
3419
        } else {
3420
            level = get_bits(&s->gb, 8);
3421
            if (level == 255)
3422
                level = 128;
3423
        }
3424
        block[0] = level;
3425
        i = 1;
3426
    } else {
3427
        i = 0;
3428
    }
3429
    if (!coded) {
3430
        if (s->mb_intra && s->h263_aic)
3431
            goto not_coded;
3432
        s->block_last_index[n] = i - 1;
3433
        return 0;
3434
    }
3435

    
3436
    for(;;) {
3437
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3438
        if (code < 0){
3439
            fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3440
            return -1;
3441
        }
3442
        if (code == rl->n) {
3443
            /* escape */
3444
            last = get_bits1(&s->gb);
3445
            run = get_bits(&s->gb, 6);
3446
            level = (INT8)get_bits(&s->gb, 8);
3447
            if (s->h263_rv10 && level == -128) {
3448
                /* XXX: should patch encoder too */
3449
                level = get_bits(&s->gb, 12);
3450
                level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
3451
            }
3452
        } else {
3453
            run = rl->table_run[code];
3454
            level = rl->table_level[code];
3455
            last = code >= rl->last;
3456
            if (get_bits1(&s->gb))
3457
                level = -level;
3458
        }
3459
        i += run;
3460
        if (i >= 64){
3461
            fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
3462
            return -1;
3463
        }
3464
        j = scan_table[i];
3465
        block[j] = level;
3466
        if (last)
3467
            break;
3468
        i++;
3469
    }
3470
not_coded:    
3471
    if (s->mb_intra && s->h263_aic) {
3472
        h263_pred_acdc(s, block, n);
3473
        i = 63;
3474
    }
3475
    s->block_last_index[n] = i;
3476
    return 0;
3477
}
3478

    
3479
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3480
{
3481
    int level, pred, code;
3482
    UINT16 *dc_val;
3483

    
3484
    if (n < 4) 
3485
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3486
    else 
3487
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3488
    if (code < 0 || code > 9 /* && s->nbit<9 */){
3489
        fprintf(stderr, "illegal dc vlc\n");
3490
        return -1;
3491
    }
3492
    if (code == 0) {
3493
        level = 0;
3494
    } else {
3495
        level = get_bits(&s->gb, code);
3496
        if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
3497
            level = - (level ^ ((1 << code) - 1));
3498
        if (code > 8){
3499
            if(get_bits1(&s->gb)==0){ /* marker */
3500
                if(s->error_resilience>=2){
3501
                    fprintf(stderr, "dc marker bit missing\n");
3502
                    return -1;
3503
                }
3504
            }
3505
        }
3506
    }
3507
    pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3508
    level += pred;
3509
    if (level < 0){
3510
        if(s->error_resilience>=3){
3511
            fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3512
            return -1;
3513
        }
3514
        level = 0;
3515
    }
3516
    if (n < 4) {
3517
        *dc_val = level * s->y_dc_scale;
3518
    } else {
3519
        *dc_val = level * s->c_dc_scale;
3520
    }
3521
    if(s->error_resilience>=3){
3522
        if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3523
            fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3524
            return -1;
3525
        }
3526
    }
3527
    return level;
3528
}
3529

    
3530
/**
3531
 * decodes a block.
3532
 * @return <0 if an error occured
3533
 */
3534
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3535
                              int n, int coded, int intra)
3536
{
3537
    int level, i, last, run;
3538
    int dc_pred_dir;
3539
    RLTable * rl;
3540
    RL_VLC_ELEM * rl_vlc;
3541
    const UINT8 * scan_table;
3542
    int qmul, qadd;
3543

    
3544
    if(intra) {
3545
        /* DC coef */
3546
        if(s->partitioned_frame){
3547
            level = s->dc_val[0][ s->block_index[n] ];
3548
            if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
3549
            else    level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
3550
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
3551
        }else{
3552
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3553
            if (level < 0)
3554
                return -1;
3555
        }
3556
        block[0] = level;
3557
        i = 0;
3558
        if (!coded) 
3559
            goto not_coded;
3560
        rl = &rl_intra;
3561
        rl_vlc = rl_intra.rl_vlc[0];
3562
        if (s->ac_pred) {
3563
            if (dc_pred_dir == 0) 
3564
                scan_table = s->intra_v_scantable.permutated; /* left */
3565
            else
3566
                scan_table = s->intra_h_scantable.permutated; /* top */
3567
        } else {
3568
            scan_table = s->intra_scantable.permutated;
3569
        }
3570
        qmul=1;
3571
        qadd=0;
3572
    } else {
3573
        i = -1;
3574
        if (!coded) {
3575
            s->block_last_index[n] = i;
3576
            return 0;
3577
        }
3578
        rl = &rl_inter;
3579
   
3580
        scan_table = s->intra_scantable.permutated;
3581

    
3582
        if(s->mpeg_quant){
3583
            qmul=1;
3584
            qadd=0;
3585
            rl_vlc = rl_inter.rl_vlc[0];        
3586
        }else{
3587
            qmul = s->qscale << 1;
3588
            qadd = (s->qscale - 1) | 1;
3589
            rl_vlc = rl_inter.rl_vlc[s->qscale];
3590
        }
3591
    }
3592
  {
3593
    OPEN_READER(re, &s->gb);
3594
    for(;;) {
3595
        UPDATE_CACHE(re, &s->gb);
3596
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3597
        if (level==0) {
3598
            int cache;
3599
            cache= GET_CACHE(re, &s->gb);
3600
            /* escape */
3601
            if (cache&0x80000000) {
3602
                if (cache&0x40000000) {
3603
                    /* third escape */
3604
                    SKIP_CACHE(re, &s->gb, 2);
3605
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3606
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3607
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
3608
                    UPDATE_CACHE(re, &s->gb);
3609

    
3610
                    if(SHOW_UBITS(re, &s->gb, 1)==0){
3611
                        fprintf(stderr, "1. marker bit missing in 3. esc\n");
3612
                        return -1;
3613
                    }; SKIP_CACHE(re, &s->gb, 1);
3614
                    
3615
                    level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3616
 
3617
                    if(SHOW_UBITS(re, &s->gb, 1)==0){
3618
                        fprintf(stderr, "2. marker bit missing in 3. esc\n");
3619
                        return -1;
3620
                    }; LAST_SKIP_CACHE(re, &s->gb, 1);
3621
                    
3622
                    SKIP_COUNTER(re, &s->gb, 1+12+1);
3623
                    
3624
                    if(level*s->qscale>1024 || level*s->qscale<-1024){
3625
                        fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3626
                        return -1;
3627
                    }
3628
#if 1 
3629
                    {
3630
                        const int abs_level= ABS(level);
3631
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
3632
                            const int run1= run - rl->max_run[last][abs_level] - 1;
3633
                            if(abs_level <= rl->max_level[last][run]){
3634
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3635
                                return -1;
3636
                            }
3637
                            if(s->error_resilience > FF_ER_COMPLIANT){
3638
                                if(abs_level <= rl->max_level[last][run]*2){
3639
                                    fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3640
                                    return -1;
3641
                                }
3642
                                if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3643
                                    fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3644
                                    return -1;
3645
                                }
3646
                            }
3647
                        }
3648
                    }
3649
#endif
3650
                    if (level>0) level= level * qmul + qadd;
3651
                    else         level= level * qmul - qadd;
3652

    
3653
                    i+= run + 1;
3654
                    if(last) i+=192;
3655
                } else {
3656
                    /* second escape */
3657
#if MIN_CACHE_BITS < 20
3658
                    LAST_SKIP_BITS(re, &s->gb, 2);
3659
                    UPDATE_CACHE(re, &s->gb);
3660
#else
3661
                    SKIP_BITS(re, &s->gb, 2);
3662
#endif
3663
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3664
                    i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3665
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3666
                    LAST_SKIP_BITS(re, &s->gb, 1);
3667
                }
3668
            } else {
3669
                /* first escape */
3670
#if MIN_CACHE_BITS < 19
3671
                LAST_SKIP_BITS(re, &s->gb, 1);
3672
                UPDATE_CACHE(re, &s->gb);
3673
#else
3674
                SKIP_BITS(re, &s->gb, 1);
3675
#endif
3676
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3677
                i+= run;
3678
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3679
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3680
                LAST_SKIP_BITS(re, &s->gb, 1);
3681
            }
3682
        } else {
3683
            i+= run;
3684
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3685
            LAST_SKIP_BITS(re, &s->gb, 1);
3686
        }
3687
        if (i > 62){
3688
            i-= 192;
3689
            if(i&(~63)){
3690
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3691
                return -1;
3692
            }
3693

    
3694
            block[scan_table[i]] = level;
3695
            break;
3696
        }
3697

    
3698
        block[scan_table[i]] = level;
3699
    }
3700
    CLOSE_READER(re, &s->gb);
3701
  }
3702
 not_coded:
3703
    if (s->mb_intra) {
3704
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
3705
        if (s->ac_pred) {
3706
            i = 63; /* XXX: not optimal */
3707
        }
3708
    }
3709
    s->block_last_index[n] = i;
3710
    return 0;
3711
}
3712

    
3713
/* most is hardcoded. should extend to handle all h263 streams */
3714
int h263_decode_picture_header(MpegEncContext *s)
3715
{
3716
    int format, width, height;
3717

    
3718
    /* picture start code */
3719
    if (get_bits(&s->gb, 22) != 0x20) {
3720
        fprintf(stderr, "Bad picture start code\n");
3721
        return -1;
3722
    }
3723
    /* temporal reference */
3724
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3725

    
3726
    /* PTYPE starts here */    
3727
    if (get_bits1(&s->gb) != 1) {
3728
        /* marker */
3729
        fprintf(stderr, "Bad marker\n");
3730
        return -1;
3731
    }
3732
    if (get_bits1(&s->gb) != 0) {
3733
        fprintf(stderr, "Bad H263 id\n");
3734
        return -1;        /* h263 id */
3735
    }
3736
    skip_bits1(&s->gb);        /* split screen off */
3737
    skip_bits1(&s->gb);        /* camera  off */
3738
    skip_bits1(&s->gb);        /* freeze picture release off */
3739

    
3740
    /* Reset GOB number */
3741
    s->gob_number = 0;
3742
        
3743
    format = get_bits(&s->gb, 3);
3744
    /*
3745
        0    forbidden
3746
        1    sub-QCIF
3747
        10   QCIF
3748
        7        extended PTYPE (PLUSPTYPE)
3749
    */
3750

    
3751
    if (format != 7 && format != 6) {
3752
        s->h263_plus = 0;
3753
        /* H.263v1 */
3754
        width = h263_format[format][0];
3755
        height = h263_format[format][1];
3756
        if (!width)
3757
            return -1;
3758
        
3759
        s->width = width;
3760
        s->height = height;
3761
        s->pict_type = I_TYPE + get_bits1(&s->gb);
3762

    
3763
        s->unrestricted_mv = get_bits1(&s->gb); 
3764
        s->h263_long_vectors = s->unrestricted_mv;
3765

    
3766
        if (get_bits1(&s->gb) != 0) {
3767
            fprintf(stderr, "H263 SAC not supported\n");
3768
            return -1;        /* SAC: off */
3769
        }
3770
        if (get_bits1(&s->gb) != 0) {
3771
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3772
        }   
3773
        
3774
        if (get_bits1(&s->gb) != 0) {
3775
            fprintf(stderr, "H263 PB frame not supported\n");
3776
            return -1;        /* not PB frame */
3777
        }
3778
        s->qscale = get_bits(&s->gb, 5);
3779
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
3780
    } else {
3781
        int ufep;
3782
        
3783
        /* H.263v2 */
3784
        s->h263_plus = 1;
3785
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3786

    
3787
        /* ufep other than 0 and 1 are reserved */        
3788
        if (ufep == 1) {
3789
            /* OPPTYPE */       
3790
            format = get_bits(&s->gb, 3);
3791
            dprintf("ufep=1, format: %d\n", format);
3792
            skip_bits(&s->gb,1); /* Custom PCF */
3793
            s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3794
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3795
            if (get_bits1(&s->gb) != 0) {
3796
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3797
            }
3798
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3799
                s->h263_aic = 1;
3800
            }
3801
            
3802
            skip_bits(&s->gb, 7);
3803
            /* these are the 7 bits: (in order of appearence  */
3804
            /* Deblocking Filter */
3805
            /* Slice Structured */
3806
            /* Reference Picture Selection */
3807
            /* Independent Segment Decoding */
3808
            /* Alternative Inter VLC */
3809
            /* Modified Quantization */
3810
            /* Prevent start code emulation */
3811

    
3812
            skip_bits(&s->gb, 3); /* Reserved */
3813
        } else if (ufep != 0) {
3814
            fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3815
            return -1;
3816
        }
3817
            
3818
        /* MPPTYPE */
3819
        s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3820
        dprintf("pict_type: %d\n", s->pict_type);
3821
        if (s->pict_type != I_TYPE &&
3822
            s->pict_type != P_TYPE)
3823
            return -1;
3824
        skip_bits(&s->gb, 2);
3825
        s->no_rounding = get_bits1(&s->gb);
3826
        dprintf("RTYPE: %d\n", s->no_rounding);
3827
        skip_bits(&s->gb, 4);
3828
        
3829
        /* Get the picture dimensions */
3830
        if (ufep) {
3831
            if (format == 6) {
3832
                /* Custom Picture Format (CPFMT) */
3833
                s->aspect_ratio_info = get_bits(&s->gb, 4);
3834
                dprintf("aspect: %d\n", s->aspect_ratio_info);
3835
                /* aspect ratios:
3836
                0 - forbidden
3837
                1 - 1:1
3838
                2 - 12:11 (CIF 4:3)
3839
                3 - 10:11 (525-type 4:3)
3840
                4 - 16:11 (CIF 16:9)
3841
                5 - 40:33 (525-type 16:9)
3842
                6-14 - reserved
3843
                */
3844
                width = (get_bits(&s->gb, 9) + 1) * 4;
3845
                skip_bits1(&s->gb);
3846
                height = get_bits(&s->gb, 9) * 4;
3847
                dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
3848
                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
3849
                    /* aspected dimensions */
3850
                    s->aspected_width = get_bits(&s->gb, 8);
3851
                    s->aspected_height = get_bits(&s->gb, 8);
3852
                }else{
3853
                    s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
3854
                    s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
3855
                }
3856
            } else {
3857
                width = h263_format[format][0];
3858
                height = h263_format[format][1];
3859
            }
3860
            if ((width == 0) || (height == 0))
3861
                return -1;
3862
            s->width = width;
3863
            s->height = height;
3864
            if (s->umvplus_dec) {
3865
                skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
3866
            }
3867
        }
3868
            
3869
        s->qscale = get_bits(&s->gb, 5);
3870
    }
3871
    /* PEI */
3872
    while (get_bits1(&s->gb) != 0) {
3873
        skip_bits(&s->gb, 8);
3874
    }
3875
    s->f_code = 1;
3876
    
3877
    if(s->h263_aic){
3878
         s->y_dc_scale_table= 
3879
         s->c_dc_scale_table= h263_aic_dc_scale_table;
3880
    }else{
3881
        s->y_dc_scale_table=
3882
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
3883
    }
3884

    
3885
    return 0;
3886
}
3887

    
3888
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
3889
{
3890
    int i;
3891
    int a= 2<<s->sprite_warping_accuracy;
3892
    int rho= 3-s->sprite_warping_accuracy;
3893
    int r=16/a;
3894
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
3895
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
3896
    int sprite_ref[4][2];
3897
    int virtual_ref[2][2];
3898
    int w2, h2, w3, h3;
3899
    int alpha=0, beta=0;
3900
    int w= s->width;
3901
    int h= s->height;
3902
    int min_ab;
3903

    
3904
    for(i=0; i<s->num_sprite_warping_points; i++){
3905
        int length;
3906
        int x=0, y=0;
3907

    
3908
        length= get_vlc(&s->gb, &sprite_trajectory);
3909
        if(length){
3910
            x= get_bits(&s->gb, length);
3911

    
3912
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
3913
                x = - (x ^ ((1 << length) - 1));
3914
        }
3915
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
3916
        
3917
        length= get_vlc(&s->gb, &sprite_trajectory);
3918
        if(length){
3919
            y=get_bits(&s->gb, length);
3920

    
3921
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
3922
                y = - (y ^ ((1 << length) - 1));
3923
        }
3924
        skip_bits1(&s->gb); /* marker bit */
3925
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
3926
        d[i][0]= x;
3927
        d[i][1]= y;
3928
    }
3929

    
3930
    while((1<<alpha)<w) alpha++;
3931
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
3932
    w2= 1<<alpha;
3933
    h2= 1<<beta;
3934

    
3935
// Note, the 4th point isnt used for GMC
3936
    if(s->divx_version==500 && s->divx_build==413){
3937
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
3938
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
3939
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
3940
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
3941
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
3942
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
3943
    } else {
3944
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
3945
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
3946
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
3947
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
3948
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
3949
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
3950
    }
3951
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
3952
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
3953
    
3954
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
3955
// perhaps it should be reordered to be more readable ...
3956
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
3957
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
3958
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
3959
        + 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);
3960
    virtual_ref[0][1]= 16*vop_ref[0][1] 
3961
        + 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);
3962
    virtual_ref[1][0]= 16*vop_ref[0][0] 
3963
        + 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);
3964
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
3965
        + 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);
3966
        
3967
    switch(s->num_sprite_warping_points)
3968
    {
3969
        case 0:
3970
            s->sprite_offset[0][0]= 0;
3971
            s->sprite_offset[0][1]= 0;
3972
            s->sprite_offset[1][0]= 0;
3973
            s->sprite_offset[1][1]= 0;
3974
            s->sprite_delta[0][0]= a;
3975
            s->sprite_delta[0][1]= 0;
3976
            s->sprite_delta[1][0]= 0;
3977
            s->sprite_delta[1][1]= a;
3978
            s->sprite_shift[0]= 0;
3979
            s->sprite_shift[1]= 0;
3980
            break;
3981
        case 1: //GMC only
3982
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
3983
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
3984
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
3985
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
3986
            s->sprite_delta[0][0]= a;
3987
            s->sprite_delta[0][1]= 0;
3988
            s->sprite_delta[1][0]= 0;
3989
            s->sprite_delta[1][1]= a;
3990
            s->sprite_shift[0]= 0;
3991
            s->sprite_shift[1]= 0;
3992
            break;
3993
        case 2:
3994
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
3995
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
3996
                                                  + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
3997
                                                  + (1<<(alpha+rho-1));
3998
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
3999
                                                  + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
4000
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
4001
                                                  + (1<<(alpha+rho-1));
4002
            s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
4003
                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
4004
                                     +2*w2*r*sprite_ref[0][0] 
4005
                                     - 16*w2 
4006
                                     + (1<<(alpha+rho+1)));
4007
            s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
4008
                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
4009
                                     +2*w2*r*sprite_ref[0][1] 
4010
                                     - 16*w2
4011
                                     + (1<<(alpha+rho+1)));
4012
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4013
            s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
4014
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
4015
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4016
            
4017
            s->sprite_shift[0]= alpha+rho;
4018
            s->sprite_shift[1]= alpha+rho+2;
4019
            break;
4020
        case 3:
4021
            min_ab= FFMIN(alpha, beta);
4022
            w3= w2>>min_ab;
4023
            h3= h2>>min_ab;
4024
            s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
4025
                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
4026
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
4027
                                   + (1<<(alpha+beta+rho-min_ab-1));
4028
            s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
4029
                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
4030
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
4031
                                   + (1<<(alpha+beta+rho-min_ab-1));
4032
            s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
4033
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
4034
                                   + 2*w2*h3*r*sprite_ref[0][0]
4035
                                   - 16*w2*h3
4036
                                   + (1<<(alpha+beta+rho-min_ab+1));
4037
            s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4038
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4039
                                   + 2*w2*h3*r*sprite_ref[0][1]
4040
                                   - 16*w2*h3
4041
                                   + (1<<(alpha+beta+rho-min_ab+1));
4042
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4043
            s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4044
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4045
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4046
                                   
4047
            s->sprite_shift[0]= alpha + beta + rho - min_ab;
4048
            s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4049
            break;
4050
    }
4051
    /* try to simplify the situation */ 
4052
    if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4053
       && s->sprite_delta[0][1] == 0
4054
       && s->sprite_delta[1][0] == 0
4055
       && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4056
    {
4057
        s->sprite_offset[0][0]>>=s->sprite_shift[0];
4058
        s->sprite_offset[0][1]>>=s->sprite_shift[0];
4059
        s->sprite_offset[1][0]>>=s->sprite_shift[1];
4060
        s->sprite_offset[1][1]>>=s->sprite_shift[1];
4061
        s->sprite_delta[0][0]= a;
4062
        s->sprite_delta[0][1]= 0;
4063
        s->sprite_delta[1][0]= 0;
4064
        s->sprite_delta[1][1]= a;
4065
        s->sprite_shift[0]= 0;
4066
        s->sprite_shift[1]= 0;
4067
        s->real_sprite_warping_points=1;
4068
    }
4069
    else{
4070
        int shift_y= 16 - s->sprite_shift[0];
4071
        int shift_c= 16 - s->sprite_shift[1];
4072
//printf("shifts %d %d\n", shift_y, shift_c);
4073
        for(i=0; i<2; i++){
4074
            s->sprite_offset[0][i]<<= shift_y;
4075
            s->sprite_offset[1][i]<<= shift_c;
4076
            s->sprite_delta[0][i]<<= shift_y;
4077
            s->sprite_delta[1][i]<<= shift_y;
4078
            s->sprite_shift[i]= 16;
4079
        }
4080
        s->real_sprite_warping_points= s->num_sprite_warping_points;
4081
    }
4082
#if 0
4083
printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4084
    vop_ref[0][0], vop_ref[0][1],
4085
    vop_ref[1][0], vop_ref[1][1],
4086
    vop_ref[2][0], vop_ref[2][1],
4087
    sprite_ref[0][0], sprite_ref[0][1], 
4088
    sprite_ref[1][0], sprite_ref[1][1], 
4089
    sprite_ref[2][0], sprite_ref[2][1], 
4090
    virtual_ref[0][0], virtual_ref[0][1], 
4091
    virtual_ref[1][0], virtual_ref[1][1]
4092
    );
4093
    
4094
printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4095
    s->sprite_offset[0][0], s->sprite_offset[0][1],
4096
    s->sprite_delta[0][0], s->sprite_delta[0][1],
4097
    s->sprite_delta[1][0], s->sprite_delta[1][1],
4098
    s->sprite_shift[0]
4099
    );
4100
#endif
4101
}
4102

    
4103
static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4104
    int width, height, vo_ver_id;
4105

    
4106
    /* vol header */
4107
    skip_bits(gb, 1); /* random access */
4108
    s->vo_type= get_bits(gb, 8);
4109
    if (get_bits1(gb) != 0) { /* is_ol_id */
4110
        vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4111
        skip_bits(gb, 3); /* vo_priority */
4112
    } else {
4113
        vo_ver_id = 1;
4114
    }
4115
//printf("vo type:%d\n",s->vo_type);
4116
    s->aspect_ratio_info= get_bits(gb, 4);
4117
    if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){            
4118
        s->aspected_width = get_bits(gb, 8); // par_width
4119
        s->aspected_height = get_bits(gb, 8); // par_height
4120
    }else{
4121
        s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4122
        s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4123
    }
4124

    
4125
    if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4126
        int chroma_format= get_bits(gb, 2);
4127
        if(chroma_format!=1){
4128
            printf("illegal chroma format\n");
4129
        }
4130
        s->low_delay= get_bits1(gb);
4131
        if(get_bits1(gb)){ /* vbv parameters */
4132
            get_bits(gb, 15);        /* first_half_bitrate */
4133
            skip_bits1(gb);        /* marker */
4134
            get_bits(gb, 15);        /* latter_half_bitrate */
4135
            skip_bits1(gb);        /* marker */
4136
            get_bits(gb, 15);        /* first_half_vbv_buffer_size */
4137
            skip_bits1(gb);        /* marker */
4138
            get_bits(gb, 3);        /* latter_half_vbv_buffer_size */
4139
            get_bits(gb, 11);        /* first_half_vbv_occupancy */
4140
            skip_bits1(gb);        /* marker */
4141
            get_bits(gb, 15);        /* latter_half_vbv_occupancy */
4142
            skip_bits1(gb);        /* marker */               
4143
        }
4144
    }else{
4145
        // set low delay flag only once so the smart? low delay detection wont be overriden
4146
        if(s->picture_number==0)
4147
            s->low_delay=0;
4148
    }
4149

    
4150
    s->shape = get_bits(gb, 2); /* vol shape */
4151
    if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4152
    if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4153
        printf("Gray shape not supported\n");
4154
        skip_bits(gb, 4);  //video_object_layer_shape_extension
4155
    }
4156

    
4157
    skip_bits1(gb);   /* marker */
4158
    
4159
    s->time_increment_resolution = get_bits(gb, 16);
4160
    
4161
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4162
    if (s->time_increment_bits < 1)
4163
        s->time_increment_bits = 1;
4164
    skip_bits1(gb);   /* marker */
4165

    
4166
    if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
4167
        skip_bits(gb, s->time_increment_bits);
4168
    }
4169

    
4170
    if (s->shape != BIN_ONLY_SHAPE) {
4171
        if (s->shape == RECT_SHAPE) {
4172
            skip_bits1(gb);   /* marker */
4173
            width = get_bits(gb, 13);
4174
            skip_bits1(gb);   /* marker */
4175
            height = get_bits(gb, 13);
4176
            skip_bits1(gb);   /* marker */
4177
            if(width && height){ /* they should be non zero but who knows ... */
4178
                s->width = width;
4179
                s->height = height;
4180
//                printf("width/height: %d %d\n", width, height);
4181
            }
4182
        }
4183
        
4184
        s->progressive_sequence= get_bits1(gb)^1;
4185
        if(!get_bits1(gb)) printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
4186
        if (vo_ver_id == 1) {
4187
            s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4188
        } else {
4189
            s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4190
        }
4191
        if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4192
        if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4193
            if(s->vol_sprite_usage==STATIC_SPRITE){
4194
                s->sprite_width = get_bits(gb, 13);
4195
                skip_bits1(gb); /* marker */
4196
                s->sprite_height= get_bits(gb, 13);
4197
                skip_bits1(gb); /* marker */
4198
                s->sprite_left  = get_bits(gb, 13);
4199
                skip_bits1(gb); /* marker */
4200
                s->sprite_top   = get_bits(gb, 13);
4201
                skip_bits1(gb); /* marker */
4202
            }
4203
            s->num_sprite_warping_points= get_bits(gb, 6);
4204
            s->sprite_warping_accuracy = get_bits(gb, 2);
4205
            s->sprite_brightness_change= get_bits1(gb);
4206
            if(s->vol_sprite_usage==STATIC_SPRITE)
4207
                s->low_latency_sprite= get_bits1(gb);            
4208
        }
4209
        // FIXME sadct disable bit if verid!=1 && shape not rect
4210
        
4211
        if (get_bits1(gb) == 1) {   /* not_8_bit */
4212
            s->quant_precision = get_bits(gb, 4); /* quant_precision */
4213
            if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4214
            if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4215
        } else {
4216
            s->quant_precision = 5;
4217
        }
4218
        
4219
        // FIXME a bunch of grayscale shape things
4220

    
4221
        if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4222
            int i, j, v;
4223
            
4224
            /* load default matrixes */
4225
            for(i=0; i<64; i++){
4226
                int j= s->idct_permutation[i];
4227
                v= ff_mpeg4_default_intra_matrix[i];
4228
                s->intra_matrix[j]= v;
4229
                s->chroma_intra_matrix[j]= v;
4230
                
4231
                v= ff_mpeg4_default_non_intra_matrix[i];
4232
                s->inter_matrix[j]= v;
4233
                s->chroma_inter_matrix[j]= v;
4234
            }
4235

    
4236
            /* load custom intra matrix */
4237
            if(get_bits1(gb)){
4238
                int last=0;
4239
                for(i=0; i<64; i++){
4240
                    v= get_bits(gb, 8);
4241
                    if(v==0) break;
4242
                    
4243
                    last= v;
4244
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4245
                    s->intra_matrix[j]= v;
4246
                    s->chroma_intra_matrix[j]= v;
4247
                }
4248

    
4249
                /* replicate last value */
4250
                for(; i<64; i++){
4251
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4252
                    s->intra_matrix[j]= v;
4253
                    s->chroma_intra_matrix[j]= v;
4254
                }
4255
            }
4256

    
4257
            /* load custom non intra matrix */
4258
            if(get_bits1(gb)){
4259
                int last=0;
4260
                for(i=0; i<64; i++){
4261
                    v= get_bits(gb, 8);
4262
                    if(v==0) break;
4263

    
4264
                    last= v;
4265
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4266
                    s->inter_matrix[j]= v;
4267
                    s->chroma_inter_matrix[j]= v;
4268
                }
4269

    
4270
                /* replicate last value */
4271
                for(; i<64; i++){
4272
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4273
                    s->inter_matrix[j]= last;
4274
                    s->chroma_inter_matrix[j]= last;
4275
                }
4276
            }
4277

    
4278
            // FIXME a bunch of grayscale shape things
4279
        }
4280

    
4281
        if(vo_ver_id != 1)
4282
             s->quarter_sample= get_bits1(gb);
4283
        else s->quarter_sample=0;
4284

    
4285
        if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4286

    
4287
        s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4288

    
4289
        s->data_partitioning= get_bits1(gb);
4290
        if(s->data_partitioning){
4291
            s->rvlc= get_bits1(gb);
4292
            if(s->rvlc){
4293
                printf("reversible vlc not supported\n");
4294
            }
4295
        }
4296
        
4297
        if(vo_ver_id != 1) {
4298
            s->new_pred= get_bits1(gb);
4299
            if(s->new_pred){
4300
                printf("new pred not supported\n");
4301
                skip_bits(gb, 2); /* requested upstream message type */
4302
                skip_bits1(gb); /* newpred segment type */
4303
            }
4304
            s->reduced_res_vop= get_bits1(gb);
4305
            if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4306
        }
4307
        else{
4308
            s->new_pred=0;
4309
            s->reduced_res_vop= 0;
4310
        }
4311

    
4312
        s->scalability= get_bits1(gb);
4313

    
4314
        if (s->scalability) {
4315
            GetBitContext bak= *gb;
4316
            int ref_layer_id;
4317
            int ref_layer_sampling_dir;
4318
            int h_sampling_factor_n;
4319
            int h_sampling_factor_m;
4320
            int v_sampling_factor_n;
4321
            int v_sampling_factor_m;
4322
            
4323
            s->hierachy_type= get_bits1(gb);
4324
            ref_layer_id= get_bits(gb, 4);
4325
            ref_layer_sampling_dir= get_bits1(gb);
4326
            h_sampling_factor_n= get_bits(gb, 5);
4327
            h_sampling_factor_m= get_bits(gb, 5);
4328
            v_sampling_factor_n= get_bits(gb, 5);
4329
            v_sampling_factor_m= get_bits(gb, 5);
4330
            s->enhancement_type= get_bits1(gb);
4331
            
4332
            if(   h_sampling_factor_n==0 || h_sampling_factor_m==0 
4333
               || v_sampling_factor_n==0 || v_sampling_factor_m==0){
4334
               
4335
//                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4336
                s->scalability=0;
4337
               
4338
                *gb= bak;
4339
            }else
4340
                printf("scalability not supported\n");
4341
            
4342
            // bin shape stuff FIXME
4343
        }
4344
    }
4345
    return 0;
4346
}
4347

    
4348
static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
4349
    char buf[256];
4350
    int i;
4351
    int e;
4352
    int ver, build, ver2, ver3;
4353

    
4354
    buf[0]= show_bits(gb, 8);
4355
    for(i=1; i<256; i++){
4356
        buf[i]= show_bits(gb, 16)&0xFF;
4357
        if(buf[i]==0) break;
4358
        skip_bits(gb, 8);
4359
    }
4360
    buf[255]=0;
4361
    
4362
    /* divx detection */
4363
    e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
4364
    if(e!=2)
4365
        e=sscanf(buf, "DivX%db%d", &ver, &build);
4366
    if(e==2){
4367
        s->divx_version= ver;
4368
        s->divx_build= build;
4369
        if(s->picture_number==0){
4370
            printf("This file was encoded with DivX%d Build%d\n", ver, build);
4371
        }
4372
    }
4373
    
4374
    /* ffmpeg detection */
4375
    e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
4376
    if(e!=4)
4377
        e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); 
4378
    if(e!=4){
4379
        if(strcmp(buf, "ffmpeg")==0){
4380
            s->ffmpeg_version= 0x000406;
4381
            s->lavc_build= 4600;
4382
        }
4383
    }
4384
    if(e==4){
4385
        s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
4386
        s->lavc_build= build;
4387
        if(s->picture_number==0)
4388
            printf("This file was encoded with libavcodec build %d\n", build);
4389
    }
4390
    
4391
    /* xvid detection */
4392
    e=sscanf(buf, "XviD%d", &build);
4393
    if(e==1){
4394
        s->xvid_build= build;
4395
        if(s->picture_number==0)
4396
            printf("This file was encoded with XviD build %d\n", build);
4397
    }
4398

    
4399
//printf("User Data: %s\n", buf);
4400
    return 0;
4401
}
4402

    
4403
static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
4404
    int time_incr, time_increment;
4405

    
4406
    s->pict_type = get_bits(gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
4407
    if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
4408
        printf("low_delay flag set, but shouldnt, clearing it\n");
4409
        s->low_delay=0;
4410
    }
4411
 
4412
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
4413
    if(s->partitioned_frame)
4414
        s->decode_mb= mpeg4_decode_partitioned_mb;
4415
    else
4416
        s->decode_mb= ff_h263_decode_mb;
4417

    
4418
    if(s->time_increment_resolution==0){
4419
        s->time_increment_resolution=1;
4420
//        fprintf(stderr, "time_increment_resolution is illegal\n");
4421
    }
4422
    time_incr=0;
4423
    while (get_bits1(gb) != 0) 
4424
        time_incr++;
4425

    
4426
    check_marker(gb, "before time_increment");
4427
    time_increment= get_bits(gb, s->time_increment_bits);
4428
//printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4429
    if(s->pict_type!=B_TYPE){
4430
        s->last_time_base= s->time_base;
4431
        s->time_base+= time_incr;
4432
        s->time= s->time_base*s->time_increment_resolution + time_increment;
4433
        if(s->workaround_bugs&FF_BUG_UMP4){
4434
            if(s->time < s->last_non_b_time){
4435
//                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4436
                s->time_base++;
4437
                s->time+= s->time_increment_resolution;
4438
            }
4439
        }
4440
        s->pp_time= s->time - s->last_non_b_time;
4441
        s->last_non_b_time= s->time;
4442
    }else{
4443
        s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4444
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4445
        if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4446
//            printf("messed up order, seeking?, skiping current b frame\n");
4447
            return FRAME_SKIPED;
4448
        }
4449
        
4450
        if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4451
        if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4452
//printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4453
        s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame) 
4454
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4455
        s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame) 
4456
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4457
    }
4458
    
4459
    s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4460
    
4461
    if(check_marker(gb, "before vop_coded")==0 && s->picture_number==0){
4462
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4463
        for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
4464
            if(get_bits1(gb)) break;
4465
        }
4466
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
4467
    }
4468
    /* vop coded */
4469
    if (get_bits1(gb) != 1){
4470
        printf("vop not coded\n");
4471
        return FRAME_SKIPED;
4472
    }
4473
//printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4474
//s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);  
4475
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4476
                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4477
        /* rounding type for motion estimation */
4478
        s->no_rounding = get_bits1(gb);
4479
    } else {
4480
        s->no_rounding = 0;
4481
    }
4482
//FIXME reduced res stuff
4483

    
4484
     if (s->shape != RECT_SHAPE) {
4485
         if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4486
             int width, height, hor_spat_ref, ver_spat_ref;
4487
 
4488
             width = get_bits(gb, 13);
4489
             skip_bits1(gb);   /* marker */
4490
             height = get_bits(gb, 13);
4491
             skip_bits1(gb);   /* marker */
4492
             hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
4493
             skip_bits1(gb);   /* marker */
4494
             ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
4495
         }
4496
         skip_bits1(gb); /* change_CR_disable */
4497
 
4498
         if (get_bits1(gb) != 0) {
4499
             skip_bits(gb, 8); /* constant_alpha_value */
4500
         }
4501
     }
4502
//FIXME complexity estimation stuff
4503
     
4504
     if (s->shape != BIN_ONLY_SHAPE) {
4505
         int t;
4506
         t=get_bits(gb, 3); /* intra dc VLC threshold */
4507
//printf("threshold %d\n", t);
4508
         if(!s->progressive_sequence){
4509
             s->top_field_first= get_bits1(gb);
4510
             s->alternate_scan= get_bits1(gb);
4511
         }else
4512
             s->alternate_scan= 0;
4513
     }
4514

    
4515
     if(s->alternate_scan){
4516
         ff_init_scantable(s, &s->inter_scantable  , ff_alternate_vertical_scan);
4517
         ff_init_scantable(s, &s->intra_scantable  , ff_alternate_vertical_scan);
4518
         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
4519
         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4520
     } else{
4521
         ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
4522
         ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
4523
         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
4524
         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4525
     }
4526
 
4527
     if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
4528
         mpeg4_decode_sprite_trajectory(s);
4529
         if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
4530
         if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
4531
     }
4532

    
4533
     if (s->shape != BIN_ONLY_SHAPE) {
4534
         s->qscale = get_bits(gb, s->quant_precision);
4535
         if(s->qscale==0){
4536
             printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
4537
             return -1; // makes no sense to continue, as there is nothing left from the image then
4538
         }
4539
  
4540
         if (s->pict_type != I_TYPE) {
4541
             s->f_code = get_bits(gb, 3);        /* fcode_for */
4542
             if(s->f_code==0){
4543
                 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
4544
                 return -1; // makes no sense to continue, as the MV decoding will break very quickly
4545
             }
4546
         }else
4547
             s->f_code=1;
4548
     
4549
         if (s->pict_type == B_TYPE) {
4550
             s->b_code = get_bits(gb, 3);
4551
         }else
4552
             s->b_code=1;
4553

    
4554
         if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4555
             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", 
4556
                 s->qscale, s->f_code, s->b_code, 
4557
                 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), 
4558
                 gb->size,s->progressive_sequence, s->alternate_scan, s->top_field_first, 
4559
                 s->quarter_sample, s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
4560
                 s->sprite_warping_accuracy); 
4561
         }
4562

    
4563
         if(!s->scalability){
4564
             if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
4565
                 skip_bits1(gb); // vop shape coding type
4566
             }
4567
         }else{
4568
             if(s->enhancement_type){
4569
                 int load_backward_shape= get_bits1(gb);
4570
                 if(load_backward_shape){
4571
                     printf("load backward shape isnt supported\n");
4572
                 }
4573
             }
4574
             skip_bits(gb, 2); //ref_select_code
4575
         }
4576
     }
4577
     /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
4578
     // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
4579
     if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
4580
         printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
4581
         s->low_delay=1;
4582
     }
4583

    
4584
     s->picture_number++; // better than pic number==0 allways ;)
4585

    
4586
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
4587
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
4588

    
4589
     if(s->divx_version==0 || s->divx_version < 500){
4590
         s->h_edge_pos= s->width;
4591
         s->v_edge_pos= s->height;
4592
     }
4593
     return 0;
4594
}
4595

    
4596
/**
4597
 * decode mpeg4 headers
4598
 * @return <0 if no VOP found (or a damaged one)
4599
 *         FRAME_SKIPPED if a not coded VOP is found
4600
 *         0 if a VOP is found
4601
 */
4602
int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
4603
{
4604
    int startcode, v;
4605

    
4606
    /* search next start code */
4607
    align_get_bits(gb);
4608
    startcode = 0xff;
4609
    for(;;) {
4610
        v = get_bits(gb, 8);
4611
        startcode = ((startcode << 8) | v) & 0xffffffff;
4612
        
4613
        if(get_bits_count(gb) >= gb->size*8){
4614
            if(gb->size==1 && s->divx_version){
4615
                printf("frame skip %d\n", gb->size);
4616
                return FRAME_SKIPED; //divx bug
4617
            }else
4618
                return -1; //end of stream
4619
        }
4620

    
4621
        if((startcode&0xFFFFFF00) != 0x100)
4622
            continue; //no startcode
4623
        
4624
        switch(startcode){
4625
        case 0x120:
4626
            decode_vol_header(s, gb);
4627
            break;
4628
        case 0x1b2:
4629
            decode_user_data(s, gb);
4630
            break;
4631
        case 0x1b6:
4632
            return decode_vop_header(s, gb);
4633
        default:
4634
//            printf("startcode %X found\n", startcode);
4635
            break;
4636
        }
4637

    
4638
        align_get_bits(gb);
4639
        startcode = 0xff;
4640
    }
4641
}
4642

    
4643
/* don't understand why they choose a different header ! */
4644
int intel_h263_decode_picture_header(MpegEncContext *s)
4645
{
4646
    int format;
4647

    
4648
    /* picture header */
4649
    if (get_bits(&s->gb, 22) != 0x20) {
4650
        fprintf(stderr, "Bad picture start code\n");
4651
        return -1;
4652
    }
4653
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4654

    
4655
    if (get_bits1(&s->gb) != 1) {
4656
        fprintf(stderr, "Bad marker\n");
4657
        return -1;        /* marker */
4658
    }
4659
    if (get_bits1(&s->gb) != 0) {
4660
        fprintf(stderr, "Bad H263 id\n");
4661
        return -1;        /* h263 id */
4662
    }
4663
    skip_bits1(&s->gb);        /* split screen off */
4664
    skip_bits1(&s->gb);        /* camera  off */
4665
    skip_bits1(&s->gb);        /* freeze picture release off */
4666

    
4667
    format = get_bits(&s->gb, 3);
4668
    if (format != 7) {
4669
        fprintf(stderr, "Intel H263 free format not supported\n");
4670
        return -1;
4671
    }
4672
    s->h263_plus = 0;
4673

    
4674
    s->pict_type = I_TYPE + get_bits1(&s->gb);
4675
    
4676
    s->unrestricted_mv = get_bits1(&s->gb); 
4677
    s->h263_long_vectors = s->unrestricted_mv;
4678

    
4679
    if (get_bits1(&s->gb) != 0) {
4680
        fprintf(stderr, "SAC not supported\n");
4681
        return -1;        /* SAC: off */
4682
    }
4683
    if (get_bits1(&s->gb) != 0) {
4684
        fprintf(stderr, "Advanced Prediction Mode not supported\n");
4685
        return -1;        /* advanced prediction mode: off */
4686
    }
4687
    if (get_bits1(&s->gb) !=