Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 70ac76c0

History | View | Annotate | Download (162 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_t uni_mpeg4_intra_rl_bits[64*64*2*2];
86
static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
87
static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
88
static uint8_t  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
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
92

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

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

    
104

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

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

    
124
static void float_aspect_to_info(MpegEncContext * s, float aspect){
125
    int i;
126

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

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

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

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

    
149
    align_put_bits(&s->pb);
150

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

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

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

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

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

    
238
    if(s->h263_aic){
239
         s->y_dc_scale_table= 
240
         s->c_dc_scale_table= h263_aic_dc_scale_table;
241
    }else{
242
        s->y_dc_scale_table=
243
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
244
    }
245
}
246

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

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

    
274
    for(n=0; n<6; n++){
275
        INT16 *ac_val, *ac_val1;
276

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

    
328
    return score0 > score1 ? 1 : 0;    
329
}
330

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

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

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

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

    
392
void ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
393
    const int mb_index= s->mb_x + s->mb_y*s->mb_width;
394
    int xy= s->block_index[0];
395
    uint16_t time_pp= s->pp_time;
396
    uint16_t time_pb= s->pb_time;
397
    int i;
398
        
399
    //FIXME avoid divides
400
    switch(s->co_located_type_table[mb_index]){
401
    case 0:
402
        s->mv_type= MV_TYPE_16X16;
403
        s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
404
        s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
405
        s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
406
                            : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
407
        s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
408
                            : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
409
        break;
410
    case CO_LOCATED_TYPE_4MV:
411
        s->mv_type = MV_TYPE_8X8;
412
        for(i=0; i<4; i++){
413
            xy= s->block_index[i];
414
            s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
415
            s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
416
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
417
                                : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
418
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1] 
419
                                : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
420
        }
421
        break;
422
    case CO_LOCATED_TYPE_FIELDMV:
423
        s->mv_type = MV_TYPE_FIELD;
424
        for(i=0; i<2; i++){
425
            if(s->top_field_first){
426
                time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
427
                time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
428
            }else{
429
                time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
430
                time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
431
            }
432
            s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
433
            s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
434
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
435
                                : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
436
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] 
437
                                : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
438
        }
439
        break;
440
    }
441
}
442

    
443
#ifdef CONFIG_ENCODERS
444
void mpeg4_encode_mb(MpegEncContext * s,
445
                    DCTELEM block[6][64],
446
                    int motion_x, int motion_y)
447
{
448
    int cbpc, cbpy, i, pred_x, pred_y;
449
    int bits;
450
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
451
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
452
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
453
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
454
    const int dquant_code[5]= {1,0,9,2,3};
455
    
456
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
457
    if (!s->mb_intra) {
458
        /* compute cbp */
459
        int cbp = 0;
460
        for (i = 0; i < 6; i++) {
461
            if (s->block_last_index[i] >= 0)
462
                cbp |= 1 << (5 - i);
463
        }
464

    
465
        if(s->pict_type==B_TYPE){
466
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
467
            int mb_type=  mb_type_table[s->mv_dir];
468
            
469
            if(s->mb_x==0){
470
                s->last_mv[0][0][0]= 
471
                s->last_mv[0][0][1]= 
472
                s->last_mv[1][0][0]= 
473
                s->last_mv[1][0][1]= 0;
474
            }
475
            
476
            assert(s->dquant>=-2 && s->dquant<=2);
477
            assert((s->dquant&1)==0);
478
            assert(mb_type>=0);
479

    
480
            /* nothing to do if this MB was skiped in the next P Frame */
481
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x]){ //FIXME avoid DCT & ...
482
                s->skip_count++;
483
                s->mv[0][0][0]= 
484
                s->mv[0][0][1]= 
485
                s->mv[1][0][0]= 
486
                s->mv[1][0][1]= 0;
487
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
488
                s->qscale -= s->dquant;
489
//                s->mb_skiped=1;
490

    
491
                return;
492
            }
493
            
494
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
495
                /* direct MB with MV={0,0} */
496
                assert(s->dquant==0);
497
                
498
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
499

    
500
                if(interleaved_stats){
501
                    s->misc_bits++;
502
                    s->last_bits++;
503
                }
504
                s->skip_count++;
505
                return;
506
            }
507
            
508
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
509
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
510
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
511
            if(cbp) put_bits(&s->pb, 6, cbp);
512
            
513
            if(cbp && mb_type){
514
                if(s->dquant)
515
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
516
                else
517
                    put_bits(&s->pb, 1, 0);
518
            }else
519
                s->qscale -= s->dquant;
520
            
521
            if(!s->progressive_sequence){
522
                if(cbp)
523
                    put_bits(&s->pb, 1, s->interlaced_dct);
524
                if(mb_type) // not diect mode
525
                    put_bits(&s->pb, 1, 0); // no interlaced ME yet
526
            }
527

    
528
            if(interleaved_stats){
529
                bits= get_bit_count(&s->pb);
530
                s->misc_bits+= bits - s->last_bits;
531
                s->last_bits=bits;
532
            }
533

    
534
            switch(mb_type)
535
            {
536
            case 0: /* direct */
537
                h263_encode_motion(s, motion_x, 1);
538
                h263_encode_motion(s, motion_y, 1);                
539
                s->b_count++;
540
                s->f_count++;
541
                break;
542
            case 1: /* bidir */
543
                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
544
                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
545
                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
546
                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
547
                s->last_mv[0][0][0]= s->mv[0][0][0];
548
                s->last_mv[0][0][1]= s->mv[0][0][1];
549
                s->last_mv[1][0][0]= s->mv[1][0][0];
550
                s->last_mv[1][0][1]= s->mv[1][0][1];
551
                s->b_count++;
552
                s->f_count++;
553
                break;
554
            case 2: /* backward */
555
                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
556
                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
557
                s->last_mv[1][0][0]= motion_x;
558
                s->last_mv[1][0][1]= motion_y;
559
                s->b_count++;
560
                break;
561
            case 3: /* forward */
562
                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
563
                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
564
                s->last_mv[0][0][0]= motion_x;
565
                s->last_mv[0][0][1]= motion_y;
566
                s->f_count++;
567
                break;
568
            default:
569
                printf("unknown mb type\n");
570
                return;
571
            }
572

    
573
            if(interleaved_stats){
574
                bits= get_bit_count(&s->pb);
575
                s->mv_bits+= bits - s->last_bits;
576
                s->last_bits=bits;
577
            }
578

    
579
            /* encode each block */
580
            for (i = 0; i < 6; i++) {
581
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
582
            }
583

    
584
            if(interleaved_stats){
585
                bits= get_bit_count(&s->pb);
586
                s->p_tex_bits+= bits - s->last_bits;
587
                s->last_bits=bits;
588
            }
589
        }else{ /* s->pict_type==B_TYPE */
590
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
591
                /* check if the B frames can skip it too, as we must skip it if we skip here 
592
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
593
                if(s->max_b_frames>0){
594
                    int i;
595
                    int x,y, offset;
596
                    uint8_t *p_pic;
597

    
598
                    x= s->mb_x*16;
599
                    y= s->mb_y*16;
600
                    if(x+16 > s->width)  x= s->width-16;
601
                    if(y+16 > s->height) y= s->height-16;
602

    
603
                    offset= x + y*s->linesize;
604
                    p_pic= s->new_picture.data[0] + offset;
605
                    
606
                    s->mb_skiped=1;
607
                    for(i=0; i<s->max_b_frames; i++){
608
                        uint8_t *b_pic;
609
                        int diff;
610
                        Picture *pic= s->reordered_input_picture[i+1];
611

    
612
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
613

    
614
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
615
                        diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
616
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
617
                            s->mb_skiped=0;
618
                            break;
619
                        }
620
                    }
621
                }else
622
                    s->mb_skiped=1; 
623

    
624
                if(s->mb_skiped==1){
625
                    /* skip macroblock */
626
                    put_bits(&s->pb, 1, 1);
627

    
628
                    if(interleaved_stats){
629
                        s->misc_bits++;
630
                        s->last_bits++;
631
                    }
632
                    s->skip_count++;
633
                    return;
634
                }
635
            }
636

    
637
            put_bits(&s->pb, 1, 0);        /* mb coded */
638
            if(s->mv_type==MV_TYPE_16X16){
639
                cbpc = cbp & 3;
640
                if(s->dquant) cbpc+= 8;
641
                put_bits(&s->pb,
642
                        inter_MCBPC_bits[cbpc],
643
                        inter_MCBPC_code[cbpc]);
644

    
645
                cbpy = cbp >> 2;
646
                cbpy ^= 0xf;
647
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
648
                if(s->dquant)
649
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
650

    
651
                if(!s->progressive_sequence){
652
                    if(cbp)
653
                        put_bits(pb2, 1, s->interlaced_dct);
654
                    put_bits(pb2, 1, 0); // no interlaced ME yet
655
                }
656
                    
657
                if(interleaved_stats){
658
                    bits= get_bit_count(&s->pb);
659
                    s->misc_bits+= bits - s->last_bits;
660
                    s->last_bits=bits;
661
                }
662

    
663
                /* motion vectors: 16x16 mode */
664
                h263_pred_motion(s, 0, &pred_x, &pred_y);
665
            
666
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
667
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
668
            }else{
669
                cbpc = (cbp & 3)+16;
670
                put_bits(&s->pb,
671
                        inter_MCBPC_bits[cbpc],
672
                        inter_MCBPC_code[cbpc]);
673
                cbpy = cbp >> 2;
674
                cbpy ^= 0xf;
675
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
676

    
677
                if(!s->progressive_sequence){
678
                    if(cbp)
679
                        put_bits(pb2, 1, s->interlaced_dct);
680
                }
681
    
682
                if(interleaved_stats){
683
                    bits= get_bit_count(&s->pb);
684
                    s->misc_bits+= bits - s->last_bits;
685
                    s->last_bits=bits;
686
                }
687

    
688
                for(i=0; i<4; i++){
689
                    /* motion vectors: 8x8 mode*/
690
                    h263_pred_motion(s, i, &pred_x, &pred_y);
691

    
692
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
693
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
694
                }
695
            }
696

    
697
            if(interleaved_stats){ 
698
                bits= get_bit_count(&s->pb);
699
                s->mv_bits+= bits - s->last_bits;
700
                s->last_bits=bits;
701
            }
702

    
703
            /* encode each block */
704
            for (i = 0; i < 6; i++) {
705
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
706
            }
707

    
708
            if(interleaved_stats){
709
                bits= get_bit_count(&s->pb);
710
                s->p_tex_bits+= bits - s->last_bits;
711
                s->last_bits=bits;
712
            }
713
            s->f_count++;
714
        }
715
    } else {
716
        int cbp;
717
        int dc_diff[6];   //dc values with the dc prediction subtracted 
718
        int dir[6];  //prediction direction
719
        int zigzag_last_index[6];
720
        UINT8 *scan_table[6];
721

    
722
        for(i=0; i<6; i++){
723
            const int level= block[i][0];
724
            UINT16 *dc_ptr;
725

    
726
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
727
            if (i < 4) {
728
                *dc_ptr = level * s->y_dc_scale;
729
            } else {
730
                *dc_ptr = level * s->c_dc_scale;
731
            }
732
        }
733

    
734
        s->ac_pred= decide_ac_pred(s, block, dir);
735

    
736
        if(s->ac_pred){
737
            for(i=0; i<6; i++){
738
                UINT8 *st;
739
                int last_index;
740

    
741
                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
742
                if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
743
                else           st = s->intra_h_scantable.permutated; /* top */
744

    
745
                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
746
                    if(block[i][st[last_index]]) break;
747
                zigzag_last_index[i]= s->block_last_index[i];
748
                s->block_last_index[i]= last_index;
749
                scan_table[i]= st;
750
            }
751
        }else{
752
            for(i=0; i<6; i++)
753
                scan_table[i]= s->intra_scantable.permutated;
754
        }
755

    
756
        /* compute cbp */
757
        cbp = 0;
758
        for (i = 0; i < 6; i++) {
759
            if (s->block_last_index[i] >= 1)
760
                cbp |= 1 << (5 - i);
761
        }
762

    
763
        cbpc = cbp & 3;
764
        if (s->pict_type == I_TYPE) {
765
            if(s->dquant) cbpc+=4;
766
            put_bits(&s->pb,
767
                intra_MCBPC_bits[cbpc],
768
                intra_MCBPC_code[cbpc]);
769
        } else {
770
            if(s->dquant) cbpc+=8;
771
            put_bits(&s->pb, 1, 0);        /* mb coded */
772
            put_bits(&s->pb,
773
                inter_MCBPC_bits[cbpc + 4],
774
                inter_MCBPC_code[cbpc + 4]);
775
        }
776
        put_bits(pb2, 1, s->ac_pred);
777
        cbpy = cbp >> 2;
778
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
779
        if(s->dquant)
780
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
781

    
782
        if(!s->progressive_sequence){
783
            put_bits(dc_pb, 1, s->interlaced_dct);
784
        }
785

    
786
        if(interleaved_stats){
787
            bits= get_bit_count(&s->pb);
788
            s->misc_bits+= bits - s->last_bits;
789
            s->last_bits=bits;
790
        }
791

    
792
        /* encode each block */
793
        for (i = 0; i < 6; i++) {
794
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
795
        }
796

    
797
        if(interleaved_stats){
798
            bits= get_bit_count(&s->pb);
799
            s->i_tex_bits+= bits - s->last_bits;
800
            s->last_bits=bits;
801
        }
802
        s->i_count++;
803

    
804
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
805
        if(s->ac_pred){
806
            for(i=0; i<6; i++){
807
                int j;    
808
                INT16 *ac_val;
809

    
810
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
811

    
812
                if(dir[i]){
813
                    for(j=1; j<8; j++) 
814
                        block[i][s->idct_permutation[j   ]]= ac_val[j+8];
815
                }else{
816
                    for(j=1; j<8; j++) 
817
                        block[i][s->idct_permutation[j<<3]]= ac_val[j  ];
818
                }
819
                s->block_last_index[i]= zigzag_last_index[i];
820
            }
821
        }
822
    }
823
}
824

    
825
void h263_encode_mb(MpegEncContext * s,
826
                    DCTELEM block[6][64],
827
                    int motion_x, int motion_y)
828
{
829
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
830
    INT16 pred_dc;
831
    INT16 rec_intradc[6];
832
    UINT16 *dc_ptr[6];
833
    const int dquant_code[5]= {1,0,9,2,3};
834
           
835
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
836
    if (!s->mb_intra) {
837
        /* compute cbp */
838
        cbp = 0;
839
        for (i = 0; i < 6; i++) {
840
            if (s->block_last_index[i] >= 0)
841
                cbp |= 1 << (5 - i);
842
        }
843
        if ((cbp | motion_x | motion_y | s->dquant) == 0) {
844
            /* skip macroblock */
845
            put_bits(&s->pb, 1, 1);
846
            return;
847
        }
848
        put_bits(&s->pb, 1, 0);        /* mb coded */
849
        cbpc = cbp & 3;
850
        if(s->dquant) cbpc+= 8;
851
        put_bits(&s->pb,
852
                    inter_MCBPC_bits[cbpc],
853
                    inter_MCBPC_code[cbpc]);
854
        cbpy = cbp >> 2;
855
        cbpy ^= 0xf;
856
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
857
        if(s->dquant)
858
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
859

    
860
        /* motion vectors: 16x16 mode only now */
861
        h263_pred_motion(s, 0, &pred_x, &pred_y);
862
      
863
        if (!s->umvplus) {  
864
            h263_encode_motion(s, motion_x - pred_x, s->f_code);
865
            h263_encode_motion(s, motion_y - pred_y, s->f_code);
866
        }
867
        else {
868
            h263p_encode_umotion(s, motion_x - pred_x);
869
            h263p_encode_umotion(s, motion_y - pred_y);
870
            if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
871
                /* To prevent Start Code emulation */
872
                put_bits(&s->pb,1,1);
873
        }
874
    } else {
875
        int li = s->h263_aic ? 0 : 1;
876
        
877
        cbp = 0;
878
        for(i=0; i<6; i++) {
879
            /* Predict DC */
880
            if (s->h263_aic && s->mb_intra) {
881
                INT16 level = block[i][0];
882
            
883
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
884
                level -= pred_dc;
885
                /* Quant */
886
                if (level < 0)
887
                    level = (level + (s->qscale >> 1))/(s->y_dc_scale);
888
                else
889
                    level = (level - (s->qscale >> 1))/(s->y_dc_scale);
890
                    
891
                /* AIC can change CBP */
892
                if (level == 0 && s->block_last_index[i] == 0)
893
                    s->block_last_index[i] = -1;
894
                else if (level < -127)
895
                    level = -127;
896
                else if (level > 127)
897
                    level = 127;
898
                
899
                block[i][0] = level;
900
                /* Reconstruction */ 
901
                rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
902
                /* Oddify */
903
                rec_intradc[i] |= 1;
904
                //if ((rec_intradc[i] % 2) == 0)
905
                //    rec_intradc[i]++;
906
                /* Clipping */
907
                if (rec_intradc[i] < 0)
908
                    rec_intradc[i] = 0;
909
                else if (rec_intradc[i] > 2047)
910
                    rec_intradc[i] = 2047;
911
                                
912
                /* Update AC/DC tables */
913
                *dc_ptr[i] = rec_intradc[i];
914
            }
915
            /* compute cbp */
916
            if (s->block_last_index[i] >= li)
917
                cbp |= 1 << (5 - i);
918
        }
919

    
920
        cbpc = cbp & 3;
921
        if (s->pict_type == I_TYPE) {
922
            if(s->dquant) cbpc+=4;
923
            put_bits(&s->pb,
924
                intra_MCBPC_bits[cbpc],
925
                intra_MCBPC_code[cbpc]);
926
        } else {
927
            if(s->dquant) cbpc+=8;
928
            put_bits(&s->pb, 1, 0);        /* mb coded */
929
            put_bits(&s->pb,
930
                inter_MCBPC_bits[cbpc + 4],
931
                inter_MCBPC_code[cbpc + 4]);
932
        }
933
        if (s->h263_aic) {
934
            /* XXX: currently, we do not try to use ac prediction */
935
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
936
        }
937
        cbpy = cbp >> 2;
938
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
939
        if(s->dquant)
940
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
941
    }
942

    
943
    for(i=0; i<6; i++) {
944
        /* encode each block */
945
        h263_encode_block(s, block[i], i);
946
    
947
        /* Update INTRADC for decoding */
948
        if (s->h263_aic && s->mb_intra) {
949
            block[i][0] = rec_intradc[i];
950
            
951
        }
952
    }
953
}
954
#endif
955

    
956
static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
957
{
958
    int x, y, wrap, a, c, pred_dc, scale;
959
    INT16 *dc_val, *ac_val;
960

    
961
    /* find prediction */
962
    if (n < 4) {
963
        x = 2 * s->mb_x + 1 + (n & 1);
964
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
965
        wrap = s->mb_width * 2 + 2;
966
        dc_val = s->dc_val[0];
967
        ac_val = s->ac_val[0][0];
968
        scale = s->y_dc_scale;
969
    } else {
970
        x = s->mb_x + 1;
971
        y = s->mb_y + 1;
972
        wrap = s->mb_width + 2;
973
        dc_val = s->dc_val[n - 4 + 1];
974
        ac_val = s->ac_val[n - 4 + 1][0];
975
        scale = s->c_dc_scale;
976
    }
977
    /* B C
978
     * A X 
979
     */
980
    a = dc_val[(x - 1) + (y) * wrap];
981
    c = dc_val[(x) + (y - 1) * wrap];
982
    
983
    /* No prediction outside GOB boundary */
984
    if (s->first_slice_line && ((n < 2) || (n > 3)))
985
        c = 1024;
986
    pred_dc = 1024;
987
    /* just DC prediction */
988
    if (a != 1024 && c != 1024)
989
        pred_dc = (a + c) >> 1;
990
    else if (a != 1024)
991
        pred_dc = a;
992
    else
993
        pred_dc = c;
994
    
995
    /* we assume pred is positive */
996
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
997
    *dc_val_ptr = &dc_val[x + y * wrap];
998
    return pred_dc;
999
}
1000

    
1001

    
1002
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
1003
{
1004
    int x, y, wrap, a, c, pred_dc, scale, i;
1005
    INT16 *dc_val, *ac_val, *ac_val1;
1006

    
1007
    /* find prediction */
1008
    if (n < 4) {
1009
        x = 2 * s->mb_x + 1 + (n & 1);
1010
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1011
        wrap = s->mb_width * 2 + 2;
1012
        dc_val = s->dc_val[0];
1013
        ac_val = s->ac_val[0][0];
1014
        scale = s->y_dc_scale;
1015
    } else {
1016
        x = s->mb_x + 1;
1017
        y = s->mb_y + 1;
1018
        wrap = s->mb_width + 2;
1019
        dc_val = s->dc_val[n - 4 + 1];
1020
        ac_val = s->ac_val[n - 4 + 1][0];
1021
        scale = s->c_dc_scale;
1022
    }
1023
    
1024
    ac_val += ((y) * wrap + (x)) * 16;
1025
    ac_val1 = ac_val;
1026
    
1027
    /* B C
1028
     * A X 
1029
     */
1030
    a = dc_val[(x - 1) + (y) * wrap];
1031
    c = dc_val[(x) + (y - 1) * wrap];
1032
    
1033
    /* No prediction outside GOB boundary */
1034
    if (s->first_slice_line && ((n < 2) || (n > 3)))
1035
        c = 1024;
1036
    pred_dc = 1024;
1037
    if (s->ac_pred) {
1038
        if (s->h263_aic_dir) {
1039
            /* left prediction */
1040
            if (a != 1024) {
1041
                ac_val -= 16;
1042
                for(i=1;i<8;i++) {
1043
                    block[s->idct_permutation[i<<3]] += ac_val[i];
1044
                }
1045
                pred_dc = a;
1046
            }
1047
        } else {
1048
            /* top prediction */
1049
            if (c != 1024) {
1050
                ac_val -= 16 * wrap;
1051
                for(i=1;i<8;i++) {
1052
                    block[s->idct_permutation[i   ]] += ac_val[i + 8];
1053
                }
1054
                pred_dc = c;
1055
            }
1056
        }
1057
    } else {
1058
        /* just DC prediction */
1059
        if (a != 1024 && c != 1024)
1060
            pred_dc = (a + c) >> 1;
1061
        else if (a != 1024)
1062
            pred_dc = a;
1063
        else
1064
            pred_dc = c;
1065
    }
1066
    
1067
    /* we assume pred is positive */
1068
    block[0]=block[0]*scale + pred_dc;
1069
    
1070
    if (block[0] < 0)
1071
        block[0] = 0;
1072
    else if (!(block[0] & 1))
1073
        block[0]++;
1074
    
1075
    /* Update AC/DC tables */
1076
    dc_val[(x) + (y) * wrap] = block[0];
1077
    
1078
    /* left copy */
1079
    for(i=1;i<8;i++)
1080
        ac_val1[i    ] = block[s->idct_permutation[i<<3]];
1081
    /* top copy */
1082
    for(i=1;i<8;i++)
1083
        ac_val1[8 + i] = block[s->idct_permutation[i   ]];
1084
}
1085

    
1086
INT16 *h263_pred_motion(MpegEncContext * s, int block, 
1087
                        int *px, int *py)
1088
{
1089
    int xy, wrap;
1090
    INT16 *A, *B, *C, *mot_val;
1091
    static const int off[4]= {2, 1, 1, -1};
1092

    
1093
    wrap = s->block_wrap[0];
1094
    xy = s->block_index[block];
1095

    
1096
    mot_val = s->motion_val[xy];
1097

    
1098
    A = s->motion_val[xy - 1];
1099
    /* special case for first (slice) line */
1100
    if (s->first_slice_line && block<3) {
1101
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1102
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1103
        if(block==0){ //most common case
1104
            if(s->mb_x  == s->resync_mb_x){ //rare
1105
                *px= *py = 0;
1106
            }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1107
                C = s->motion_val[xy + off[block] - wrap];
1108
                if(s->mb_x==0){
1109
                    *px = C[0];
1110
                    *py = C[1];
1111
                }else{
1112
                    *px = mid_pred(A[0], 0, C[0]);
1113
                    *py = mid_pred(A[1], 0, C[1]);
1114
                }
1115
            }else{
1116
                *px = A[0];
1117
                *py = A[1];
1118
            }
1119
        }else if(block==1){
1120
            if(s->mb_x + 1 == s->resync_mb_x){ //rare
1121
                C = s->motion_val[xy + off[block] - wrap];
1122
                *px = mid_pred(A[0], 0, C[0]);
1123
                *py = mid_pred(A[1], 0, C[1]);
1124
            }else{
1125
                *px = A[0];
1126
                *py = A[1];
1127
            }
1128
        }else{ /* block==2*/
1129
            B = s->motion_val[xy - wrap];
1130
            C = s->motion_val[xy + off[block] - wrap];
1131
            if(s->mb_x == s->resync_mb_x) //rare
1132
                A[0]=A[1]=0;
1133
    
1134
            *px = mid_pred(A[0], B[0], C[0]);
1135
            *py = mid_pred(A[1], B[1], C[1]);
1136
        }
1137
    } else {
1138
        B = s->motion_val[xy - wrap];
1139
        C = s->motion_val[xy + off[block] - wrap];
1140
        *px = mid_pred(A[0], B[0], C[0]);
1141
        *py = mid_pred(A[1], B[1], C[1]);
1142
    }
1143
    return mot_val;
1144
}
1145

    
1146
#ifdef CONFIG_ENCODERS
1147
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1148
{
1149
    int range, l, bit_size, sign, code, bits;
1150

    
1151
    if (val == 0) {
1152
        /* zero vector */
1153
        code = 0;
1154
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1155
    } else {
1156
        bit_size = f_code - 1;
1157
        range = 1 << bit_size;
1158
        /* modulo encoding */
1159
        l = range * 32;
1160
#if 1
1161
        val+= l;
1162
        val&= 2*l-1;
1163
        val-= l;
1164
        sign = val>>31;
1165
        val= (val^sign)-sign;
1166
        sign&=1;
1167
#else
1168
        if (val < -l) {
1169
            val += 2*l;
1170
        } else if (val >= l) {
1171
            val -= 2*l;
1172
        }
1173

    
1174
        assert(val>=-l && val<l);
1175

    
1176
        if (val >= 0) {
1177
            sign = 0;
1178
        } else {
1179
            val = -val;
1180
            sign = 1;
1181
        }
1182
#endif
1183
        val--;
1184
        code = (val >> bit_size) + 1;
1185
        bits = val & (range - 1);
1186

    
1187
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1188
        if (bit_size > 0) {
1189
            put_bits(&s->pb, bit_size, bits);
1190
        }
1191
    }
1192

    
1193
}
1194

    
1195
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1196
static void h263p_encode_umotion(MpegEncContext * s, int val)
1197
{
1198
    short sval = 0; 
1199
    short i = 0;
1200
    short n_bits = 0;
1201
    short temp_val;
1202
    int code = 0;
1203
    int tcode;
1204
    
1205
    if ( val == 0)
1206
        put_bits(&s->pb, 1, 1);
1207
    else if (val == 1)
1208
        put_bits(&s->pb, 3, 0);
1209
    else if (val == -1)
1210
        put_bits(&s->pb, 3, 2);
1211
    else {
1212
        
1213
        sval = ((val < 0) ? (short)(-val):(short)val);
1214
        temp_val = sval;
1215
        
1216
        while (temp_val != 0) {
1217
            temp_val = temp_val >> 1;
1218
            n_bits++;
1219
        }
1220
        
1221
        i = n_bits - 1;
1222
        while (i > 0) {
1223
            tcode = (sval & (1 << (i-1))) >> (i-1);
1224
            tcode = (tcode << 1) | 1;
1225
            code = (code << 2) | tcode;
1226
            i--;
1227
        }
1228
        code = ((code << 1) | (val < 0)) << 1;
1229
        put_bits(&s->pb, (2*n_bits)+1, code);
1230
        //printf("\nVal = %d\tCode = %d", sval, code);
1231
    }
1232
}
1233

    
1234
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1235
{
1236
    int f_code;
1237
    int mv;
1238
    
1239
    if(mv_penalty==NULL)
1240
        mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1241
    
1242
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1243
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1244
            int len;
1245

    
1246
            if(mv==0) len= mvtab[0][1];
1247
            else{
1248
                int val, bit_size, range, code;
1249

    
1250
                bit_size = s->f_code - 1;
1251
                range = 1 << bit_size;
1252

    
1253
                val=mv;
1254
                if (val < 0) 
1255
                    val = -val;
1256
                val--;
1257
                code = (val >> bit_size) + 1;
1258
                if(code<33){
1259
                    len= mvtab[code][1] + 1 + bit_size;
1260
                }else{
1261
                    len= mvtab[32][1] + 2 + bit_size;
1262
                }
1263
            }
1264

    
1265
            mv_penalty[f_code][mv+MAX_MV]= len;
1266
        }
1267
    }
1268

    
1269
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1270
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1271
            fcode_tab[mv+MAX_MV]= f_code;
1272
        }
1273
    }
1274

    
1275
    for(mv=0; mv<MAX_MV*2+1; mv++){
1276
        umv_fcode_tab[mv]= 1;
1277
    }
1278
}
1279
#endif
1280

    
1281
static void init_uni_dc_tab(void)
1282
{
1283
    int level, uni_code, uni_len;
1284

    
1285
    for(level=-256; level<256; level++){
1286
        int size, v, l;
1287
        /* find number of bits */
1288
        size = 0;
1289
        v = abs(level);
1290
        while (v) {
1291
            v >>= 1;
1292
            size++;
1293
        }
1294

    
1295
        if (level < 0)
1296
            l= (-level) ^ ((1 << size) - 1);
1297
        else
1298
            l= level;
1299

    
1300
        /* luminance */
1301
        uni_code= DCtab_lum[size][0];
1302
        uni_len = DCtab_lum[size][1];
1303

    
1304
        if (size > 0) {
1305
            uni_code<<=size; uni_code|=l;
1306
            uni_len+=size;
1307
            if (size > 8){
1308
                uni_code<<=1; uni_code|=1;
1309
                uni_len++;
1310
            }
1311
        }
1312
        uni_DCtab_lum[level+256][0]= uni_code;
1313
        uni_DCtab_lum[level+256][1]= uni_len;
1314

    
1315
        /* chrominance */
1316
        uni_code= DCtab_chrom[size][0];
1317
        uni_len = DCtab_chrom[size][1];
1318
        
1319
        if (size > 0) {
1320
            uni_code<<=size; uni_code|=l;
1321
            uni_len+=size;
1322
            if (size > 8){
1323
                uni_code<<=1; uni_code|=1;
1324
                uni_len++;
1325
            }
1326
        }
1327
        uni_DCtab_chrom[level+256][0]= uni_code;
1328
        uni_DCtab_chrom[level+256][1]= uni_len;
1329

    
1330
    }
1331
}
1332

    
1333
#ifdef CONFIG_ENCODERS
1334
static void init_uni_mpeg4_rl_tab(RLTable *rl, UINT32 *bits_tab, UINT8 *len_tab){
1335
    int slevel, run, last;
1336
    
1337
    assert(MAX_LEVEL >= 64);
1338
    assert(MAX_RUN   >= 63);
1339

    
1340
    for(slevel=-64; slevel<64; slevel++){
1341
        if(slevel==0) continue;
1342
        for(run=0; run<64; run++){
1343
            for(last=0; last<=1; last++){
1344
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1345
                int level= slevel < 0 ? -slevel : slevel;
1346
                int sign= slevel < 0 ? 1 : 0;
1347
                int bits, len, code;
1348
                int level1, run1;
1349
                
1350
                len_tab[index]= 100;
1351
                     
1352
                /* ESC0 */
1353
                code= get_rl_index(rl, last, run, level);
1354
                bits= rl->table_vlc[code][0];
1355
                len=  rl->table_vlc[code][1];
1356
                bits=bits*2+sign; len++;
1357
                
1358
                if(code!=rl->n && len < len_tab[index]){
1359
                    bits_tab[index]= bits;
1360
                    len_tab [index]= len;
1361
                }
1362
#if 1
1363
                /* ESC1 */
1364
                bits= rl->table_vlc[rl->n][0];
1365
                len=  rl->table_vlc[rl->n][1];
1366
                bits=bits*2;    len++; //esc1
1367
                level1= level - rl->max_level[last][run];
1368
                if(level1>0){
1369
                    code= get_rl_index(rl, last, run, level1);
1370
                    bits<<= rl->table_vlc[code][1];
1371
                    len  += rl->table_vlc[code][1];
1372
                    bits += rl->table_vlc[code][0];
1373
                    bits=bits*2+sign; len++;
1374
                
1375
                    if(code!=rl->n && len < len_tab[index]){
1376
                        bits_tab[index]= bits;
1377
                        len_tab [index]= len;
1378
                    }
1379
                }
1380
#endif 
1381
#if 1
1382
                /* ESC2 */
1383
                bits= rl->table_vlc[rl->n][0];
1384
                len=  rl->table_vlc[rl->n][1];
1385
                bits=bits*4+2;    len+=2; //esc2
1386
                run1 = run - rl->max_run[last][level] - 1;
1387
                if(run1>=0){
1388
                    code= get_rl_index(rl, last, run1, level);
1389
                    bits<<= rl->table_vlc[code][1];
1390
                    len  += rl->table_vlc[code][1];
1391
                    bits += rl->table_vlc[code][0];
1392
                    bits=bits*2+sign; len++;
1393
                
1394
                    if(code!=rl->n && len < len_tab[index]){
1395
                        bits_tab[index]= bits;
1396
                        len_tab [index]= len;
1397
                    }
1398
                }
1399
#endif           
1400
                /* ESC3 */        
1401
                bits= rl->table_vlc[rl->n][0];
1402
                len = rl->table_vlc[rl->n][1];
1403
                bits=bits*4+3;    len+=2; //esc3
1404
                bits=bits*2+last; len++;
1405
                bits=bits*64+run; len+=6;
1406
                bits=bits*2+1;    len++;  //marker
1407
                bits=bits*4096+(slevel&0xfff); len+=12;
1408
                bits=bits*2+1;    len++;  //marker
1409
                
1410
                if(len < len_tab[index]){
1411
                    bits_tab[index]= bits;
1412
                    len_tab [index]= len;
1413
                }
1414
            }
1415
        }
1416
    }
1417
}
1418

    
1419
void h263_encode_init(MpegEncContext *s)
1420
{
1421
    static int done = 0;
1422

    
1423
    if (!done) {
1424
        done = 1;
1425

    
1426
        init_uni_dc_tab();
1427

    
1428
        init_rl(&rl_inter);
1429
        init_rl(&rl_intra);
1430
        init_rl(&rl_intra_aic);
1431
        
1432
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1433
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1434

    
1435
        init_mv_penalty_and_fcode(s);
1436
    }
1437
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1438
    
1439
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1440
    switch(s->codec_id){
1441
    case CODEC_ID_MPEG4:
1442
        s->fcode_tab= fcode_tab;
1443
        s->min_qcoeff= -2048;
1444
        s->max_qcoeff=  2047;
1445
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1446
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1447
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1448
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1449
        s->ac_esc_length= 7+2+1+6+1+12+1;
1450
        break;
1451
    case CODEC_ID_H263P:
1452
        s->fcode_tab= umv_fcode_tab;
1453
        s->min_qcoeff= -128;
1454
        s->max_qcoeff=  127;
1455
        break;
1456
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1457
    default: //nothing needed default table allready set in mpegvideo.c
1458
        s->min_qcoeff= -128;
1459
        s->max_qcoeff=  127;
1460
        s->y_dc_scale_table=
1461
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1462
    }
1463

    
1464
    if(s->mpeg_quant){
1465
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1466
        s->inter_quant_bias= 0;
1467
    }else{
1468
        s->intra_quant_bias=0;
1469
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1470
    }
1471
}
1472

    
1473
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1474
{
1475
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1476
    RLTable *rl;
1477

    
1478
    rl = &rl_inter;
1479
    if (s->mb_intra && !s->h263_aic) {
1480
        /* DC coef */
1481
            level = block[0];
1482
        /* 255 cannot be represented, so we clamp */
1483
        if (level > 254) {
1484
            level = 254;
1485
            block[0] = 254;
1486
        }
1487
        /* 0 cannot be represented also */
1488
        else if (!level) {
1489
            level = 1;
1490
            block[0] = 1;
1491
        }
1492
            if (level == 128)
1493
                put_bits(&s->pb, 8, 0xff);
1494
            else
1495
                put_bits(&s->pb, 8, level & 0xff);
1496
            i = 1;
1497
    } else {
1498
            i = 0;
1499
            if (s->h263_aic && s->mb_intra)
1500
                rl = &rl_intra_aic;
1501
    }
1502
   
1503
    /* AC coefs */
1504
    last_index = s->block_last_index[n];
1505
    last_non_zero = i - 1;
1506
    for (; i <= last_index; i++) {
1507
        j = s->intra_scantable.permutated[i];
1508
        level = block[j];
1509
        if (level) {
1510
            run = i - last_non_zero - 1;
1511
            last = (i == last_index);
1512
            sign = 0;
1513
            slevel = level;
1514
            if (level < 0) {
1515
                sign = 1;
1516
                level = -level;
1517
            }
1518
            code = get_rl_index(rl, last, run, level);
1519
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1520
            if (code == rl->n) {
1521
                put_bits(&s->pb, 1, last);
1522
                put_bits(&s->pb, 6, run);
1523
                put_bits(&s->pb, 8, slevel & 0xff);
1524
            } else {
1525
                put_bits(&s->pb, 1, sign);
1526
            }
1527
                last_non_zero = i;
1528
            }
1529
    }
1530
}
1531
#endif
1532

    
1533
/***************************************************/
1534
/**
1535
 * add mpeg4 stuffing bits (01...1)
1536
 */
1537
void ff_mpeg4_stuffing(PutBitContext * pbc)
1538
{
1539
    int length;
1540
    put_bits(pbc, 1, 0);
1541
    length= (-get_bit_count(pbc))&7;
1542
    if(length) put_bits(pbc, length, (1<<length)-1);
1543
}
1544

    
1545
/* must be called before writing the header */
1546
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1547
    int time_div, time_mod;
1548

    
1549
    if(s->pict_type==I_TYPE){ //we will encode a vol header
1550
        s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1551
        if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1552

    
1553
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1554
    }
1555
    
1556
    if(s->current_picture.pts)
1557
        s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1558
    else
1559
        s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1560
    time_div= s->time/s->time_increment_resolution;
1561
    time_mod= s->time%s->time_increment_resolution;
1562

    
1563
    if(s->pict_type==B_TYPE){
1564
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1565
    }else{
1566
        s->last_time_base= s->time_base;
1567
        s->time_base= time_div;
1568
        s->pp_time= s->time - s->last_non_b_time;
1569
        s->last_non_b_time= s->time;
1570
    }
1571
}
1572

    
1573
static void mpeg4_encode_gop_header(MpegEncContext * s){
1574
    int hours, minutes, seconds;
1575
    
1576
    put_bits(&s->pb, 16, 0);
1577
    put_bits(&s->pb, 16, GOP_STARTCODE);
1578
    
1579
    seconds= s->time/s->time_increment_resolution;
1580
    minutes= seconds/60; seconds %= 60;
1581
    hours= minutes/60; minutes %= 60;
1582
    hours%=24;
1583

    
1584
    put_bits(&s->pb, 5, hours);
1585
    put_bits(&s->pb, 6, minutes);
1586
    put_bits(&s->pb, 1, 1);
1587
    put_bits(&s->pb, 6, seconds);
1588
    
1589
    put_bits(&s->pb, 1, 0); //closed gov == NO
1590
    put_bits(&s->pb, 1, 0); //broken link == NO
1591

    
1592
    ff_mpeg4_stuffing(&s->pb);
1593
}
1594

    
1595
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1596
    int profile_and_level_indication;
1597
    int vo_ver_id;
1598
    
1599
    if(s->max_b_frames || s->quarter_sample){
1600
        profile_and_level_indication= 0xF1; // adv simple level 1
1601
        vo_ver_id= 5;
1602
    }else{
1603
        profile_and_level_indication= 0x01; // simple level 1
1604
        vo_ver_id= 1;
1605
    }
1606
    //FIXME levels
1607

    
1608
    put_bits(&s->pb, 16, 0);
1609
    put_bits(&s->pb, 16, VOS_STARTCODE);
1610
    
1611
    put_bits(&s->pb, 8, profile_and_level_indication);
1612
    
1613
    put_bits(&s->pb, 16, 0);
1614
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1615
    
1616
    put_bits(&s->pb, 1, 1);
1617
        put_bits(&s->pb, 4, vo_ver_id);
1618
        put_bits(&s->pb, 3, 1); //priority
1619
 
1620
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
1621
    
1622
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1623

    
1624
    ff_mpeg4_stuffing(&s->pb);
1625
}
1626

    
1627
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
1628
{
1629
    int vo_ver_id;
1630
    char buf[255];
1631

    
1632
    if(s->max_b_frames || s->quarter_sample){
1633
        vo_ver_id= 5;
1634
        s->vo_type= ADV_SIMPLE_VO_TYPE;
1635
    }else{
1636
        vo_ver_id= 1;
1637
        s->vo_type= SIMPLE_VO_TYPE;
1638
    }
1639

    
1640
    put_bits(&s->pb, 16, 0);
1641
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
1642
    put_bits(&s->pb, 16, 0);
1643
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
1644

    
1645
    put_bits(&s->pb, 1, 0);                /* random access vol */
1646
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1647
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1648
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1649
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1650
    
1651
    float_aspect_to_info(s, s->avctx->aspect_ratio);
1652

    
1653
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1654
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1655
    {
1656
        put_bits(&s->pb, 8, s->aspected_width);
1657
        put_bits(&s->pb, 8, s->aspected_height);
1658
    }
1659

    
1660
    if(s->low_delay){
1661
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1662
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1663
        put_bits(&s->pb, 1, s->low_delay);
1664
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1665
    }else{
1666
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1667
    }
1668

    
1669
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1670
    put_bits(&s->pb, 1, 1);                /* marker bit */
1671
    
1672
    put_bits(&s->pb, 16, s->time_increment_resolution);
1673
    if (s->time_increment_bits < 1)
1674
        s->time_increment_bits = 1;
1675
    put_bits(&s->pb, 1, 1);                /* marker bit */
1676
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1677
    put_bits(&s->pb, 1, 1);                /* marker bit */
1678
    put_bits(&s->pb, 13, s->width);        /* vol width */
1679
    put_bits(&s->pb, 1, 1);                /* marker bit */
1680
    put_bits(&s->pb, 13, s->height);        /* vol height */
1681
    put_bits(&s->pb, 1, 1);                /* marker bit */
1682
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1683
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1684
    if (vo_ver_id == 1) {
1685
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1686
    }else{
1687
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1688
    }
1689
    
1690
    s->quant_precision=5;
1691
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
1692
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
1693
    if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1694

    
1695
    if (vo_ver_id != 1)
1696
        put_bits(&s->pb, 1, s->quarter_sample);
1697
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1698
    s->resync_marker= s->rtp_mode;
1699
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1700
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1701
    if(s->data_partitioning){
1702
        put_bits(&s->pb, 1, 0);                /* no rvlc */
1703
    }
1704

    
1705
    if (vo_ver_id != 1){
1706
        put_bits(&s->pb, 1, 0);                /* newpred */
1707
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1708
    }
1709
    put_bits(&s->pb, 1, 0);                /* scalability */
1710
    
1711
    ff_mpeg4_stuffing(&s->pb);
1712

    
1713
    /* user data */
1714
    if(!ff_bit_exact){
1715
        put_bits(&s->pb, 16, 0);
1716
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1717
        sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1718
        put_string(&s->pb, buf);
1719
        ff_mpeg4_stuffing(&s->pb);
1720
    }
1721
}
1722

    
1723
/* write mpeg4 VOP header */
1724
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1725
{
1726
    int time_incr;
1727
    int time_div, time_mod;
1728
    
1729
    if(s->pict_type==I_TYPE){
1730
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
1731
            mpeg4_encode_visual_object_header(s);
1732
            mpeg4_encode_vol_header(s, 0, 0);
1733
        }
1734
        mpeg4_encode_gop_header(s);
1735
    }
1736
    
1737
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1738

    
1739
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1740
    
1741
    put_bits(&s->pb, 16, 0);                /* vop header */
1742
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
1743
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1744

    
1745
    time_div= s->time/s->time_increment_resolution;
1746
    time_mod= s->time%s->time_increment_resolution;
1747
    time_incr= time_div - s->last_time_base;
1748
    while(time_incr--)
1749
        put_bits(&s->pb, 1, 1);
1750
        
1751
    put_bits(&s->pb, 1, 0);
1752

    
1753
    put_bits(&s->pb, 1, 1);        /* marker */
1754
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1755
    put_bits(&s->pb, 1, 1);        /* marker */
1756
    put_bits(&s->pb, 1, 1);        /* vop coded */
1757
    if (    s->pict_type == P_TYPE 
1758
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1759
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1760
    }
1761
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1762
    if(!s->progressive_sequence){
1763
         put_bits(&s->pb, 1, s->top_field_first);
1764
         put_bits(&s->pb, 1, s->alternate_scan);
1765
    }
1766
    //FIXME sprite stuff
1767

    
1768
    put_bits(&s->pb, 5, s->qscale);
1769

    
1770
    if (s->pict_type != I_TYPE)
1771
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1772
    if (s->pict_type == B_TYPE)
1773
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1774
    //    printf("****frame %d\n", picture_number);
1775

    
1776
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
1777
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1778
     s->h_edge_pos= s->width;
1779
     s->v_edge_pos= s->height;
1780
}
1781

    
1782
/**
1783
 * change qscale by given dquant and update qscale dependant variables.
1784
 */
1785
static void change_qscale(MpegEncContext * s, int dquant)
1786
{
1787
    s->qscale += dquant;
1788

    
1789
    if (s->qscale < 1)
1790
        s->qscale = 1;
1791
    else if (s->qscale > 31)
1792
        s->qscale = 31;
1793

    
1794
    s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1795
    s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1796
}
1797

    
1798
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1799
{
1800
    int a, b, c, wrap, pred, scale;
1801
    UINT16 *dc_val;
1802
    int dummy;
1803

    
1804
    /* find prediction */
1805
    if (n < 4) {
1806
        scale = s->y_dc_scale;
1807
    } else {
1808
        scale = s->c_dc_scale;
1809
    }
1810
    wrap= s->block_wrap[n];
1811
    dc_val = s->dc_val[0] + s->block_index[n];
1812

    
1813
    /* B C
1814
     * A X 
1815
     */
1816
    a = dc_val[ - 1];
1817
    b = dc_val[ - 1 - wrap];
1818
    c = dc_val[ - wrap];
1819

    
1820
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
1821
    if(s->first_slice_line && n!=3){
1822
        if(n!=2) b=c= 1024;
1823
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
1824
    }
1825
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
1826
        if(n==0 || n==4 || n==5)
1827
            b=1024;
1828
    }
1829

    
1830
    if (abs(a - b) < abs(b - c)) {
1831
        pred = c;
1832
        *dir_ptr = 1; /* top */
1833
    } else {
1834
        pred = a;
1835
        *dir_ptr = 0; /* left */
1836
    }
1837
    /* we assume pred is positive */
1838
#ifdef ARCH_X86
1839
        asm volatile (
1840
                "xorl %%edx, %%edx        \n\t"
1841
                "mul %%ecx                \n\t"
1842
                : "=d" (pred), "=a"(dummy)
1843
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1844
        );
1845
#else
1846
    pred = (pred + (scale >> 1)) / scale;
1847
#endif
1848

    
1849
    /* prepare address for prediction update */
1850
    *dc_val_ptr = &dc_val[0];
1851

    
1852
    return pred;
1853
}
1854

    
1855
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1856
                   int dir)
1857
{
1858
    int i;
1859
    INT16 *ac_val, *ac_val1;
1860
    int8_t * const qscale_table= s->current_picture.qscale_table;
1861

    
1862
    /* find prediction */
1863
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1864
    ac_val1 = ac_val;
1865
    if (s->ac_pred) {
1866
        if (dir == 0) {
1867
            const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1868
            /* left prediction */
1869
            ac_val -= 16;
1870
            
1871
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1872
                /* same qscale */
1873
                for(i=1;i<8;i++) {
1874
                    block[s->idct_permutation[i<<3]] += ac_val[i];
1875
                }
1876
            }else{
1877
                /* different qscale, we must rescale */
1878
                for(i=1;i<8;i++) {
1879
                    block[s->idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1880
                }
1881
            }
1882
        } else {
1883
            const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1884
            /* top prediction */
1885
            ac_val -= 16 * s->block_wrap[n];
1886

    
1887
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1888
                /* same qscale */
1889
                for(i=1;i<8;i++) {
1890
                    block[s->idct_permutation[i]] += ac_val[i + 8];
1891
                }
1892
            }else{
1893
                /* different qscale, we must rescale */
1894
                for(i=1;i<8;i++) {
1895
                    block[s->idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1896
                }
1897
            }
1898
        }
1899
    }
1900
    /* left copy */
1901
    for(i=1;i<8;i++)
1902
        ac_val1[i    ] = block[s->idct_permutation[i<<3]];
1903

    
1904
    /* top copy */
1905
    for(i=1;i<8;i++)
1906
        ac_val1[8 + i] = block[s->idct_permutation[i   ]];
1907

    
1908
}
1909

    
1910
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1911
                              int dir)
1912
{
1913
    int i;
1914
    INT16 *ac_val;
1915
    int8_t * const qscale_table= s->current_picture.qscale_table;
1916

    
1917
    /* find prediction */
1918
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1919
 
1920
    if (dir == 0) {
1921
        const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1922
        /* left prediction */
1923
        ac_val -= 16;
1924
        if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1925
            /* same qscale */
1926
            for(i=1;i<8;i++) {
1927
                block[s->idct_permutation[i<<3]] -= ac_val[i];
1928
            }
1929
        }else{
1930
            /* different qscale, we must rescale */
1931
            for(i=1;i<8;i++) {
1932
                block[s->idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1933
            }
1934
        }
1935
    } else {
1936
        const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1937
        /* top prediction */
1938
        ac_val -= 16 * s->block_wrap[n];
1939
        if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1940
            /* same qscale */
1941
            for(i=1;i<8;i++) {
1942
                block[s->idct_permutation[i]] -= ac_val[i + 8];
1943
            }
1944
        }else{
1945
            /* different qscale, we must rescale */
1946
            for(i=1;i<8;i++) {
1947
                block[s->idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1948
            }
1949
        }
1950
    }
1951
}
1952

    
1953
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1954
{
1955
#if 1
1956
//    if(level<-255 || level>255) printf("dc overflow\n");
1957
    level+=256;
1958
    if (n < 4) {
1959
        /* luminance */
1960
        put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1961
    } else {
1962
        /* chrominance */
1963
        put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1964
    }
1965
#else
1966
    int size, v;
1967
    /* find number of bits */
1968
    size = 0;
1969
    v = abs(level);
1970
    while (v) {
1971
        v >>= 1;
1972
        size++;
1973
    }
1974

    
1975
    if (n < 4) {
1976
        /* luminance */
1977
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1978
    } else {
1979
        /* chrominance */
1980
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1981
    }
1982

    
1983
    /* encode remaining bits */
1984
    if (size > 0) {
1985
        if (level < 0)
1986
            level = (-level) ^ ((1 << size) - 1);
1987
        put_bits(&s->pb, size, level);
1988
        if (size > 8)
1989
            put_bits(&s->pb, 1, 1);
1990
    }
1991
#endif
1992
}
1993
#ifdef CONFIG_ENCODERS
1994
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
1995
                               UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
1996
{
1997
    int i, last_non_zero;
1998
#if 0 //variables for the outcommented version
1999
    int code, sign, last;
2000
#endif
2001
    const RLTable *rl;
2002
    UINT32 *bits_tab;
2003
    UINT8 *len_tab;
2004
    const int last_index = s->block_last_index[n];
2005

    
2006
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2007
        /* mpeg4 based DC predictor */
2008
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2009
        if(last_index<1) return;
2010
        i = 1;
2011
        rl = &rl_intra;
2012
        bits_tab= uni_mpeg4_intra_rl_bits;
2013
        len_tab = uni_mpeg4_intra_rl_len;
2014
    } else {
2015
        if(last_index<0) return;
2016
        i = 0;
2017
        rl = &rl_inter;
2018
        bits_tab= uni_mpeg4_inter_rl_bits;
2019
        len_tab = uni_mpeg4_inter_rl_len;
2020
    }
2021

    
2022
    /* AC coefs */
2023
    last_non_zero = i - 1;
2024
#if 1
2025
    for (; i < last_index; i++) {
2026
        int level = block[ scan_table[i] ];
2027
        if (level) {
2028
            int run = i - last_non_zero - 1;
2029
            level+=64;
2030
            if((level&(~127)) == 0){
2031
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2032
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2033
            }else{ //ESC3
2034
                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);
2035
            }
2036
            last_non_zero = i;
2037
        }
2038
    }
2039
    /*if(i<=last_index)*/{
2040
        int level = block[ scan_table[i] ];
2041
        int run = i - last_non_zero - 1;
2042
        level+=64;
2043
        if((level&(~127)) == 0){
2044
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2045
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2046
        }else{ //ESC3
2047
            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);
2048
        }
2049
    }
2050
#else
2051
    for (; i <= last_index; i++) {
2052
        const int slevel = block[ scan_table[i] ];
2053
        if (slevel) {
2054
            int level;
2055
            int run = i - last_non_zero - 1;
2056
            last = (i == last_index);
2057
            sign = 0;
2058
            level = slevel;
2059
            if (level < 0) {
2060
                sign = 1;
2061
                level = -level;
2062
            }
2063
            code = get_rl_index(rl, last, run, level);
2064
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2065
            if (code == rl->n) {
2066
                int level1, run1;
2067
                level1 = level - rl->max_level[last][run];
2068
                if (level1 < 1) 
2069
                    goto esc2;
2070
                code = get_rl_index(rl, last, run, level1);
2071
                if (code == rl->n) {
2072
                esc2:
2073
                    put_bits(ac_pb, 1, 1);
2074
                    if (level > MAX_LEVEL)
2075
                        goto esc3;
2076
                    run1 = run - rl->max_run[last][level] - 1;
2077
                    if (run1 < 0)
2078
                        goto esc3;
2079
                    code = get_rl_index(rl, last, run1, level);
2080
                    if (code == rl->n) {
2081
                    esc3:
2082
                        /* third escape */
2083
                        put_bits(ac_pb, 1, 1);
2084
                        put_bits(ac_pb, 1, last);
2085
                        put_bits(ac_pb, 6, run);
2086
                        put_bits(ac_pb, 1, 1);
2087
                        put_bits(ac_pb, 12, slevel & 0xfff);
2088
                        put_bits(ac_pb, 1, 1);
2089
                    } else {
2090
                        /* second escape */
2091
                        put_bits(ac_pb, 1, 0);
2092
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2093
                        put_bits(ac_pb, 1, sign);
2094
                    }
2095
                } else {
2096
                    /* first escape */
2097
                    put_bits(ac_pb, 1, 0);
2098
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2099
                    put_bits(ac_pb, 1, sign);
2100
                }
2101
            } else {
2102
                put_bits(ac_pb, 1, sign);
2103
            }
2104
            last_non_zero = i;
2105
        }
2106
    }
2107
#endif
2108
}
2109

    
2110
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2111
                               UINT8 *scan_table)
2112
{
2113
    int i, last_non_zero;
2114
    const RLTable *rl;
2115
    UINT8 *len_tab;
2116
    const int last_index = s->block_last_index[n];
2117
    int len=0;
2118

    
2119
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2120
        /* mpeg4 based DC predictor */
2121
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2122
        if(last_index<1) return len;
2123
        i = 1;
2124
        rl = &rl_intra;
2125
        len_tab = uni_mpeg4_intra_rl_len;
2126
    } else {
2127
        if(last_index<0) return 0;
2128
        i = 0;
2129
        rl = &rl_inter;
2130
        len_tab = uni_mpeg4_inter_rl_len;
2131
    }
2132

    
2133
    /* AC coefs */
2134
    last_non_zero = i - 1;
2135
    for (; i < last_index; i++) {
2136
        int level = block[ scan_table[i] ];
2137
        if (level) {
2138
            int run = i - last_non_zero - 1;
2139
            level+=64;
2140
            if((level&(~127)) == 0){
2141
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2142
                len += len_tab[index];
2143
            }else{ //ESC3
2144
                len += 7+2+1+6+1+12+1;
2145
            }
2146
            last_non_zero = i;
2147
        }
2148
    }
2149
    /*if(i<=last_index)*/{
2150
        int level = block[ scan_table[i] ];
2151
        int run = i - last_non_zero - 1;
2152
        level+=64;
2153
        if((level&(~127)) == 0){
2154
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2155
            len += len_tab[index];
2156
        }else{ //ESC3
2157
            len += 7+2+1+6+1+12+1;
2158
        }
2159
    }
2160
    
2161
    return len;
2162
}
2163

    
2164
#endif
2165

    
2166

    
2167
/***********************************************/
2168
/* decoding */
2169

    
2170
static VLC intra_MCBPC_vlc;
2171
static VLC inter_MCBPC_vlc;
2172
static VLC cbpy_vlc;
2173
static VLC mv_vlc;
2174
static VLC dc_lum, dc_chrom;
2175
static VLC sprite_trajectory;
2176
static VLC mb_type_b_vlc;
2177

    
2178
void init_rl(RLTable *rl)
2179
{
2180
    INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
2181
    UINT8 index_run[MAX_RUN+1];
2182
    int last, run, level, start, end, i;
2183

    
2184
    /* compute max_level[], max_run[] and index_run[] */
2185
    for(last=0;last<2;last++) {
2186
        if (last == 0) {
2187
            start = 0;
2188
            end = rl->last;
2189
        } else {
2190
            start = rl->last;
2191
            end = rl->n;
2192
        }
2193

    
2194
        memset(max_level, 0, MAX_RUN + 1);
2195
        memset(max_run, 0, MAX_LEVEL + 1);
2196
        memset(index_run, rl->n, MAX_RUN + 1);
2197
        for(i=start;i<end;i++) {
2198
            run = rl->table_run[i];
2199
            level = rl->table_level[i];
2200
            if (index_run[run] == rl->n)
2201
                index_run[run] = i;
2202
            if (level > max_level[run])
2203
                max_level[run] = level;
2204
            if (run > max_run[level])
2205
                max_run[level] = run;
2206
        }
2207
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
2208
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
2209
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
2210
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
2211
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
2212
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
2213
    }
2214
}
2215

    
2216
void init_vlc_rl(RLTable *rl)
2217
{
2218
    int i, q;
2219
    
2220
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2221
             &rl->table_vlc[0][1], 4, 2,
2222
             &rl->table_vlc[0][0], 4, 2);
2223

    
2224
    
2225
    for(q=0; q<32; q++){
2226
        int qmul= q*2;
2227
        int qadd= (q-1)|1;
2228
        
2229
        if(q==0){
2230
            qmul=1;
2231
            qadd=0;
2232
        }
2233
        
2234
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2235
        for(i=0; i<rl->vlc.table_size; i++){
2236
            int code= rl->vlc.table[i][0];
2237
            int len = rl->vlc.table[i][1];
2238
            int level, run;
2239
        
2240
            if(len==0){ // illegal code
2241
                run= 66;
2242
                level= MAX_LEVEL;
2243
            }else if(len<0){ //more bits needed
2244
                run= 0;
2245
                level= code;
2246
            }else{
2247
                if(code==rl->n){ //esc
2248
                    run= 66;
2249
                    level= 0;
2250
                }else{
2251
                    run=   rl->table_run  [code] + 1;
2252
                    level= rl->table_level[code] * qmul + qadd;
2253
                    if(code >= rl->last) run+=192;
2254
                }
2255
            }
2256
            rl->rl_vlc[q][i].len= len;
2257
            rl->rl_vlc[q][i].level= level;
2258
            rl->rl_vlc[q][i].run= run;
2259
        }
2260
    }
2261
}
2262

    
2263
/* init vlcs */
2264

    
2265
/* XXX: find a better solution to handle static init */
2266
void h263_decode_init_vlc(MpegEncContext *s)
2267
{
2268
    static int done = 0;
2269

    
2270
    if (!done) {
2271
        done = 1;
2272

    
2273
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8, 
2274
                 intra_MCBPC_bits, 1, 1,
2275
                 intra_MCBPC_code, 1, 1);
2276
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25, 
2277
                 inter_MCBPC_bits, 1, 1,
2278
                 inter_MCBPC_code, 1, 1);
2279
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2280
                 &cbpy_tab[0][1], 2, 1,
2281
                 &cbpy_tab[0][0], 2, 1);
2282
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2283
                 &mvtab[0][1], 2, 1,
2284
                 &mvtab[0][0], 2, 1);
2285
        init_rl(&rl_inter);
2286
        init_rl(&rl_intra);
2287
        init_rl(&rl_intra_aic);
2288
        init_vlc_rl(&rl_inter);
2289
        init_vlc_rl(&rl_intra);
2290
        init_vlc_rl(&rl_intra_aic);
2291
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2292
                 &DCtab_lum[0][1], 2, 1,
2293
                 &DCtab_lum[0][0], 2, 1);
2294
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2295
                 &DCtab_chrom[0][1], 2, 1,
2296
                 &DCtab_chrom[0][0], 2, 1);
2297
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2298
                 &sprite_trajectory_tab[0][1], 4, 2,
2299
                 &sprite_trajectory_tab[0][0], 4, 2);
2300
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2301
                 &mb_type_b_tab[0][1], 2, 1,
2302
                 &mb_type_b_tab[0][0], 2, 1);
2303
    }
2304
}
2305

    
2306
/**
2307
 * Get the GOB height based on picture height.
2308
 */
2309
int ff_h263_get_gob_height(MpegEncContext *s){
2310
    if (s->height <= 400)
2311
        return 1;
2312
    else if (s->height <= 800)
2313
        return  2;
2314
    else
2315
        return 4;
2316
}
2317

    
2318
/**
2319
 * decodes the group of blocks header.
2320
 * @return <0 if an error occured
2321
 */
2322
static int h263_decode_gob_header(MpegEncContext *s)
2323
{
2324
    unsigned int val, gfid;
2325
    int left;
2326
    
2327
    /* Check for GOB Start Code */
2328
    val = show_bits(&s->gb, 16);
2329
    if(val)
2330
        return -1;
2331

    
2332
        /* We have a GBSC probably with GSTUFF */
2333
    skip_bits(&s->gb, 16); /* Drop the zeros */
2334
    left= s->gb.size*8 - get_bits_count(&s->gb);
2335
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2336
    for(;left>13; left--){
2337
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2338
    }
2339
    if(left<=13) 
2340
        return -1;
2341

    
2342
#ifdef DEBUG
2343
    fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2344
#endif
2345
    s->gob_number = get_bits(&s->gb, 5); /* GN */
2346
    gfid = get_bits(&s->gb, 2); /* GFID */
2347
    s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2348
    if(s->qscale==0) 
2349
        return -1;
2350
    s->mb_x= 0;
2351
    s->mb_y= s->gob_index* s->gob_number;
2352
#ifdef DEBUG
2353
    fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2354
#endif
2355
    return 0;
2356
}
2357

    
2358
static inline void memsetw(short *tab, int val, int n)
2359
{
2360
    int i;
2361
    for(i=0;i<n;i++)
2362
        tab[i] = val;
2363
}
2364

    
2365
void ff_mpeg4_init_partitions(MpegEncContext *s)
2366
{
2367
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2368
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
2369
}
2370

    
2371
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2372
{
2373
    const int pb2_len   = get_bit_count(&s->pb2   );
2374
    const int tex_pb_len= get_bit_count(&s->tex_pb);
2375
    const int bits= get_bit_count(&s->pb);
2376

    
2377
    if(s->pict_type==I_TYPE){
2378
        put_bits(&s->pb, 19, DC_MARKER);
2379
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2380
        s->i_tex_bits+= tex_pb_len;
2381
    }else{
2382
        put_bits(&s->pb, 17, MOTION_MARKER);
2383
        s->misc_bits+=17 + pb2_len;
2384
        s->mv_bits+= bits - s->last_bits;
2385
        s->p_tex_bits+= tex_pb_len;
2386
    }
2387

    
2388
    flush_put_bits(&s->pb2);
2389
    flush_put_bits(&s->tex_pb);
2390

    
2391
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2392
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2393
    s->last_bits= get_bit_count(&s->pb);
2394
}
2395

    
2396
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2397
    switch(s->pict_type){
2398
        case I_TYPE:
2399
            return 16;
2400
        case P_TYPE:
2401
        case S_TYPE:
2402
            return s->f_code+15;
2403
        case B_TYPE:
2404
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2405
        default:
2406
            return -1;
2407
    }
2408
}
2409

    
2410
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2411
{
2412
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2413

    
2414
    ff_mpeg4_stuffing(&s->pb);
2415
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2416
    put_bits(&s->pb, 1, 1);
2417
    
2418
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2419
    put_bits(&s->pb, s->quant_precision, s->qscale);
2420
    put_bits(&s->pb, 1, 0); /* no HEC */
2421
}
2422

    
2423
/**
2424
 * check if the next stuff is a resync marker or the end.
2425
 * @return 0 if not
2426
 */
2427
static inline int mpeg4_is_resync(MpegEncContext *s){
2428
    const int bits_count= get_bits_count(&s->gb);
2429
    
2430
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
2431
        return 0;
2432
    }
2433

    
2434
    if(bits_count + 8 >= s->gb.size*8){
2435
        int v= show_bits(&s->gb, 8);
2436
        v|= 0x7F >> (7-(bits_count&7));
2437
                
2438
        if(v==0x7F)
2439
            return 1;
2440
    }else{
2441
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2442
            int len;
2443
            GetBitContext gb= s->gb;
2444
        
2445
            skip_bits(&s->gb, 1);
2446
            align_get_bits(&s->gb);
2447
        
2448
            for(len=0; len<32; len++){
2449
                if(get_bits1(&s->gb)) break;
2450
            }
2451

    
2452
            s->gb= gb;
2453

    
2454
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2455
                return 1;
2456
        }
2457
    }
2458
    return 0;
2459
}
2460

    
2461
/**
2462
 * decodes the next video packet.
2463
 * @return <0 if something went wrong
2464
 */
2465
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2466
{
2467
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2468
    int header_extension=0, mb_num, len;
2469
    
2470
    /* is there enough space left for a video packet + header */
2471
    if( get_bits_count(&s->gb) > s->gb.size*8-20) return -1;
2472

    
2473
    for(len=0; len<32; len++){
2474
        if(get_bits1(&s->gb)) break;
2475
    }
2476

    
2477
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2478
        printf("marker does not match f_code\n");
2479
        return -1;
2480
    }
2481
    
2482
    if(s->shape != RECT_SHAPE){
2483
        header_extension= get_bits1(&s->gb);
2484
        //FIXME more stuff here
2485
    }
2486

    
2487
    mb_num= get_bits(&s->gb, mb_num_bits);
2488
    if(mb_num>=s->mb_num){
2489
        fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2490
        return -1;
2491
    }
2492
    s->mb_x= mb_num % s->mb_width;
2493
    s->mb_y= mb_num / s->mb_width;
2494

    
2495
    if(s->shape != BIN_ONLY_SHAPE){
2496
        int qscale= get_bits(&s->gb, s->quant_precision); 
2497
        if(qscale)
2498
            s->qscale= qscale;
2499
    }
2500

    
2501
    if(s->shape == RECT_SHAPE){
2502
        header_extension= get_bits1(&s->gb);
2503
    }
2504
    if(header_extension){
2505
        int time_increment;
2506
        int time_incr=0;
2507

    
2508
        while (get_bits1(&s->gb) != 0) 
2509
            time_incr++;
2510

    
2511
        check_marker(&s->gb, "before time_increment in video packed header");
2512
        time_increment= get_bits(&s->gb, s->time_increment_bits);
2513
        check_marker(&s->gb, "before vop_coding_type in video packed header");
2514
        
2515
        skip_bits(&s->gb, 2); /* vop coding type */
2516
        //FIXME not rect stuff here
2517

    
2518
        if(s->shape != BIN_ONLY_SHAPE){
2519
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2520
//FIXME dont just ignore everything
2521
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2522
                mpeg4_decode_sprite_trajectory(s);
2523
                fprintf(stderr, "untested\n");
2524
            }
2525

    
2526
            //FIXME reduced res stuff here
2527
            
2528
            if (s->pict_type != I_TYPE) {
2529
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
2530
                if(f_code==0){
2531
                    printf("Error, video packet header damaged (f_code=0)\n");
2532
                }
2533
            }
2534
            if (s->pict_type == B_TYPE) {
2535
                int b_code = get_bits(&s->gb, 3);
2536
                if(b_code==0){
2537
                    printf("Error, video packet header damaged (b_code=0)\n");
2538
                }
2539
            }       
2540
        }
2541
    }
2542
    //FIXME new-pred stuff
2543
    
2544
//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));
2545

    
2546
    return 0;
2547
}
2548

    
2549
void ff_mpeg4_clean_buffers(MpegEncContext *s)
2550
{
2551
    int c_wrap, c_xy, l_wrap, l_xy;
2552

    
2553
    l_wrap= s->block_wrap[0];
2554
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2555
    c_wrap= s->block_wrap[4];
2556
    c_xy= s->mb_y*c_wrap + s->mb_x;
2557

    
2558
#if 0
2559
    /* clean DC */
2560
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2561
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2562
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2563
#endif
2564

    
2565
    /* clean AC */
2566
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
2567
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
2568
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
2569

    
2570
    /* clean MV */
2571
    // we cant clear the MVs as they might be needed by a b frame
2572
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
2573
//    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2574
    s->last_mv[0][0][0]=
2575
    s->last_mv[0][0][1]=
2576
    s->last_mv[1][0][0]=
2577
    s->last_mv[1][0][1]= 0;
2578
}
2579

    
2580
/**
2581
 * decodes the group of blocks / video packet header.
2582
 * @return <0 if no resync found
2583
 */
2584
int ff_h263_resync(MpegEncContext *s){
2585
    int left, ret;
2586
    
2587
    if(s->codec_id==CODEC_ID_MPEG4)
2588
        skip_bits1(&s->gb);
2589
    
2590
    align_get_bits(&s->gb);
2591

    
2592
    if(show_bits(&s->gb, 16)==0){
2593
        if(s->codec_id==CODEC_ID_MPEG4)
2594
            ret= mpeg4_decode_video_packet_header(s);
2595
        else
2596
            ret= h263_decode_gob_header(s);
2597
        if(ret>=0)
2598
            return 0;
2599
    }
2600
    //ok, its not where its supposed to be ...
2601
    s->gb= s->last_resync_gb;
2602
    align_get_bits(&s->gb);
2603
    left= s->gb.size*8 - get_bits_count(&s->gb);
2604
    
2605
    for(;left>16+1+5+5; left-=8){ 
2606
        if(show_bits(&s->gb, 16)==0){
2607
            GetBitContext bak= s->gb;
2608

    
2609
            if(s->codec_id==CODEC_ID_MPEG4)
2610
                ret= mpeg4_decode_video_packet_header(s);
2611
            else
2612
                ret= h263_decode_gob_header(s);
2613
            if(ret>=0)
2614
                return 0;
2615

    
2616
            s->gb= bak;
2617
        }
2618
        skip_bits(&s->gb, 8);
2619
    }
2620
    
2621
    return -1;
2622
}
2623

    
2624
/**
2625
 * @param n either 0 for the x component or 1 for y
2626
 * @returns the average MV for a GMC MB
2627
 */
2628
static inline int get_amv(MpegEncContext *s, int n){
2629
    int x, y, mb_v, sum, dx, dy, shift;
2630
    int len = 1 << (s->f_code + 4);
2631
    const int a= s->sprite_warping_accuracy;
2632

    
2633
    if(s->real_sprite_warping_points==1){
2634
        if(s->divx_version==500 && s->divx_build==413)
2635
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2636
        else
2637
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2638
    }else{
2639
        dx= s->sprite_delta[n][0];
2640
        dy= s->sprite_delta[n][1];
2641
        shift= s->sprite_shift[0];
2642
        if(n) dy -= 1<<(shift + a + 1);
2643
        else  dx -= 1<<(shift + a + 1);
2644
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2645

    
2646
        sum=0;
2647
        for(y=0; y<16; y++){
2648
            int v;
2649
        
2650
            v= mb_v + dy*y;
2651
            //XXX FIXME optimize
2652
            for(x=0; x<16; x++){
2653
                sum+= v>>shift;
2654
                v+= dx;
2655
            }
2656
        }
2657
        sum /= 256;
2658
        sum= RSHIFT(sum<<s->quarter_sample, a);
2659
    }
2660

    
2661
    if      (sum < -len) sum= -len;
2662
    else if (sum >= len) sum= len-1;
2663

    
2664
    return sum;
2665
}
2666

    
2667
/**
2668
 * decodes first partition.
2669
 * @return number of MBs decoded or <0 if an error occured
2670
 */
2671
static int mpeg4_decode_partition_a(MpegEncContext *s){
2672
    int mb_num;
2673
    static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2674
    
2675
    /* decode first partition */
2676
    mb_num=0;
2677
    s->first_slice_line=1;
2678
    for(; s->mb_y<s->mb_height; s->mb_y++){
2679
        ff_init_block_index(s);
2680
        for(; s->mb_x<s->mb_width; s->mb_x++){
2681
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2682
            int cbpc;
2683
            int dir=0;
2684
            
2685
            mb_num++;
2686
            ff_update_block_index(s);
2687
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2688
                s->first_slice_line=0;
2689
            
2690
            if(s->mb_x==0) PRINT_MB_TYPE("\n");
2691

    
2692
            if(s->pict_type==I_TYPE){
2693
                int i;
2694

    
2695
                if(show_bits(&s->gb, 19)==DC_MARKER){
2696
                    return mb_num-1;
2697
                }
2698

    
2699
                PRINT_MB_TYPE("I");
2700
                cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2701
                if (cbpc < 0){
2702

    
2703
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2704
                    return -1;
2705
                }
2706
                s->cbp_table[xy]= cbpc & 3;
2707
                s->mb_type[xy]= MB_TYPE_INTRA;
2708
                s->mb_intra = 1;
2709

    
2710
                if(cbpc & 4) {
2711
                    change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2712
                }
2713
                s->current_picture.qscale_table[xy]= s->qscale;
2714

    
2715
                s->mbintra_table[xy]= 1;
2716
                for(i=0; i<6; i++){
2717
                    int dc_pred_dir;
2718
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2719
                    if(dc < 0){
2720
                        fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2721
                        return -1;
2722
                    }
2723
                    dir<<=1;
2724
                    if(dc_pred_dir) dir|=1;
2725
                }
2726
                s->pred_dir_table[xy]= dir;
2727
                
2728
                s->error_status_table[xy]= AC_ERROR;
2729
            }else{ /* P/S_TYPE */
2730
                int mx, my, pred_x, pred_y, bits;
2731
                INT16 * const mot_val= s->motion_val[s->block_index[0]];
2732
                const int stride= s->block_wrap[0]*2;
2733

    
2734
                bits= show_bits(&s->gb, 17);
2735
                if(bits==MOTION_MARKER){
2736
                    return mb_num-1;
2737
                }
2738
                skip_bits1(&s->gb);
2739
                if(bits&0x10000){
2740
                    /* skip mb */
2741
                    s->mb_type[xy]= MB_TYPE_SKIPED;
2742
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2743
                        PRINT_MB_TYPE("G");
2744
                        mx= get_amv(s, 0);
2745
                        my= get_amv(s, 1);
2746
                    }else{
2747
                        PRINT_MB_TYPE("S");
2748
                        mx=my=0;
2749
                    }
2750
                    mot_val[0       ]= mot_val[2       ]=
2751
                    mot_val[0+stride]= mot_val[2+stride]= mx;
2752
                    mot_val[1       ]= mot_val[3       ]=
2753
                    mot_val[1+stride]= mot_val[3+stride]= my;
2754

    
2755
                    if(s->mbintra_table[xy])
2756
                        ff_clean_intra_table_entries(s);
2757

    
2758
                    s->error_status_table[xy]= AC_ERROR;
2759
                    continue;
2760
                }
2761
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2762
                if (cbpc < 0){
2763
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2764
                    return -1;
2765
                }
2766
                if (cbpc > 20)
2767
                    cbpc+=3;
2768
                else if (cbpc == 20)
2769
                    fprintf(stderr, "Stuffing !");
2770
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2771
    
2772
                s->mb_intra = ((cbpc & 4) != 0);
2773
        
2774
                if(s->mb_intra){
2775
                    PRINT_MB_TYPE("I");
2776
                    s->mbintra_table[xy]= 1;
2777
                    s->mb_type[xy]= MB_TYPE_INTRA;
2778
                    mot_val[0       ]= mot_val[2       ]= 
2779
                    mot_val[0+stride]= mot_val[2+stride]= 0;
2780
                    mot_val[1       ]= mot_val[3       ]=
2781
                    mot_val[1+stride]= mot_val[3+stride]= 0;
2782
                    s->error_status_table[xy]= DC_ERROR|AC_ERROR;
2783
                }else{
2784
                    if(s->mbintra_table[xy])
2785
                        ff_clean_intra_table_entries(s);
2786

    
2787
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2788
                        s->mcsel= get_bits1(&s->gb);
2789
                    else s->mcsel= 0;
2790
        
2791
                    if ((cbpc & 16) == 0) {
2792
                        PRINT_MB_TYPE("P");
2793
                        /* 16x16 motion prediction */
2794
                        s->mb_type[xy]= MB_TYPE_INTER;
2795

    
2796
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
2797
                        if(!s->mcsel){
2798
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2799
                            if (mx >= 0xffff)
2800
                                return -1;
2801

    
2802
                            my = h263_decode_motion(s, pred_y, s->f_code);
2803
                            if (my >= 0xffff)
2804
                                return -1;
2805
                        } else {
2806
                            mx = get_amv(s, 0);
2807
                            my = get_amv(s, 1);
2808
                        }
2809

    
2810
                        mot_val[0       ]= mot_val[2       ] =
2811
                        mot_val[0+stride]= mot_val[2+stride]= mx;
2812
                        mot_val[1       ]= mot_val[3       ]=
2813
                        mot_val[1+stride]= mot_val[3+stride]= my;
2814
                    } else {
2815
                        int i;
2816
                        PRINT_MB_TYPE("4");
2817
                        s->mb_type[xy]= MB_TYPE_INTER4V;
2818
                        for(i=0;i<4;i++) {
2819
                            INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2820
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2821
                            if (mx >= 0xffff)
2822
                                return -1;
2823
                
2824
                            my = h263_decode_motion(s, pred_y, s->f_code);
2825
                            if (my >= 0xffff)
2826
                                return -1;
2827
                            mot_val[0] = mx;
2828
                            mot_val[1] = my;
2829
                        }
2830
                    }
2831
                    s->error_status_table[xy]= AC_ERROR;
2832
                }
2833
            }
2834
        }
2835
        s->mb_x= 0;
2836
    }
2837

    
2838
    return mb_num;
2839
}
2840

    
2841
/**
2842
 * decode second partition.
2843
 * @return <0 if an error occured
2844
 */
2845
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
2846
    int mb_num=0;
2847
    static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2848

    
2849
    s->mb_x= s->resync_mb_x;
2850
    s->first_slice_line=1;
2851
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
2852
        ff_init_block_index(s);
2853
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
2854
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2855

    
2856
            mb_num++;
2857
            ff_update_block_index(s);
2858
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2859
                s->first_slice_line=0;
2860
            
2861
            if(s->pict_type==I_TYPE){
2862
                int ac_pred= get_bits1(&s->gb);
2863
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2864
                if(cbpy<0){
2865
                    fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2866
                    return -1;
2867
                }
2868
                
2869
                s->cbp_table[xy]|= cbpy<<2;
2870
                s->pred_dir_table[xy]|= ac_pred<<7;
2871
            }else{ /* P || S_TYPE */
2872
                if(s->mb_type[xy]&MB_TYPE_INTRA){          
2873
                    int dir=0,i;
2874
                    int ac_pred = get_bits1(&s->gb);
2875
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2876

    
2877
                    if(cbpy<0){
2878
                        fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2879
                        return -1;
2880
                    }
2881
                    
2882
                    if(s->cbp_table[xy] & 8) {
2883
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2884
                    }
2885
                    s->current_picture.qscale_table[xy]= s->qscale;
2886

    
2887
                    for(i=0; i<6; i++){
2888
                        int dc_pred_dir;
2889
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2890
                        if(dc < 0){
2891
                            fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2892
                            return -1;
2893
                        }
2894
                        dir<<=1;
2895
                        if(dc_pred_dir) dir|=1;
2896
                    }
2897
                    s->cbp_table[xy]&= 3; //remove dquant
2898
                    s->cbp_table[xy]|= cbpy<<2;
2899
                    s->pred_dir_table[xy]= dir | (ac_pred<<7);
2900
                    s->error_status_table[xy]&= ~DC_ERROR;
2901
                }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
2902
                    s->current_picture.qscale_table[xy]= s->qscale;
2903
                    s->cbp_table[xy]= 0;
2904
                }else{
2905
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2906

    
2907
                    if(cbpy<0){
2908
                        fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2909
                        return -1;
2910
                    }
2911
                    
2912
                    if(s->cbp_table[xy] & 8) {
2913
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2914
                    }
2915
                    s->current_picture.qscale_table[xy]= s->qscale;
2916

    
2917
                    s->cbp_table[xy]&= 3; //remove dquant
2918
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
2919
                }
2920
            }
2921
        }
2922
        if(mb_num >= mb_count) return 0;
2923
        s->mb_x= 0;
2924
    }
2925
    return 0;
2926
}
2927

    
2928
/**
2929
 * decodes the first & second partition
2930
 * @return <0 if error (and sets error type in the error_status_table)
2931
 */
2932
int ff_mpeg4_decode_partitions(MpegEncContext *s)
2933
{
2934
    int mb_num;
2935
    
2936
    mb_num= mpeg4_decode_partition_a(s);    
2937
    if(mb_num<0)
2938
        return -1;
2939
    
2940
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
2941
        fprintf(stderr, "slice below monitor ...\n");
2942
        return -1;
2943
    }
2944

    
2945
    s->mb_num_left= mb_num;
2946
        
2947
    if(s->pict_type==I_TYPE){
2948
        if(get_bits(&s->gb, 19)!=DC_MARKER){
2949
            fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
2950
            return -1;
2951
        }else
2952
            s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END|DC_END;
2953
    }else{
2954
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
2955
            fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
2956
            return -1;
2957
        }else
2958
            s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END;
2959
    }
2960
    
2961
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
2962
        return -1;
2963
    }
2964
    
2965
    s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= DC_END;
2966

    
2967
    return 0;        
2968
}
2969

    
2970
/**
2971
 * decode partition C of one MB.
2972
 * @return <0 if an error occured
2973
 */
2974
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
2975
{
2976
    int cbp, mb_type;
2977
    const int xy= s->mb_x + s->mb_y*s->mb_width;
2978

    
2979
    mb_type= s->mb_type[xy];
2980
    cbp = s->cbp_table[xy];
2981

    
2982
    if(s->current_picture.qscale_table[xy] != s->qscale){
2983
        s->qscale= s->current_picture.qscale_table[xy];
2984
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2985
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2986
    }
2987
    
2988
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2989
        int i;
2990
        for(i=0; i<4; i++){
2991
            s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
2992
            s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
2993
        }
2994
        s->mb_intra = mb_type&MB_TYPE_INTRA;
2995

    
2996
        if (mb_type&MB_TYPE_SKIPED) {
2997
            /* skip mb */
2998
            for(i=0;i<6;i++)
2999
                s->block_last_index[i] = -1;
3000
            s->mv_dir = MV_DIR_FORWARD;
3001
            s->mv_type = MV_TYPE_16X16;
3002
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3003
                s->mcsel=1;
3004
                s->mb_skiped = 0;
3005
            }else{
3006
                s->mcsel=0;
3007
                s->mb_skiped = 1;
3008
            }
3009
        }else if(s->mb_intra){
3010
            s->ac_pred = s->pred_dir_table[xy]>>7;
3011

    
3012
            /* decode each block */
3013
            for (i = 0; i < 6; i++) {
3014
                if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
3015
                    fprintf(stderr, "texture corrupted at %d %d\n", s->mb_x, s->mb_y);
3016
                    return -1;
3017
                }
3018
                cbp+=cbp;
3019
            }
3020
        }else if(!s->mb_intra){
3021
//            s->mcsel= 0; //FIXME do we need to init that
3022
            
3023
            s->mv_dir = MV_DIR_FORWARD;
3024
            if (mb_type&MB_TYPE_INTER4V) {
3025
                s->mv_type = MV_TYPE_8X8;
3026
            } else {
3027
                s->mv_type = MV_TYPE_16X16;
3028
            }
3029
            /* decode each block */
3030
            for (i = 0; i < 6; i++) {
3031
                if(mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0){
3032
                    fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
3033
                    return -1;
3034
                }
3035
                cbp+=cbp;
3036
            }
3037
        }
3038
    } else { /* I-Frame */
3039
        int i;
3040
        s->mb_intra = 1;
3041
        s->ac_pred = s->pred_dir_table[xy]>>7;
3042
        
3043
        /* decode each block */
3044
        for (i = 0; i < 6; i++) {
3045
            if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
3046
                fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
3047
                return -1;
3048
            }
3049
            cbp+=cbp;
3050
        }
3051
    }
3052

    
3053
    s->error_status_table[xy]&= ~AC_ERROR;
3054

    
3055
    /* per-MB end of slice check */
3056

    
3057
    if(--s->mb_num_left <= 0){
3058
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size*8 - get_bits_count(&s->gb));
3059
        if(mpeg4_is_resync(s))
3060
            return SLICE_END;
3061
        else
3062
            return SLICE_NOEND;     
3063
    }else{
3064
        if(s->cbp_table[xy+1] && mpeg4_is_resync(s))
3065
            return SLICE_END;
3066
        else
3067
            return SLICE_OK;
3068
    }
3069
}
3070

    
3071
int ff_h263_decode_mb(MpegEncContext *s,
3072
                      DCTELEM block[6][64])
3073
{
3074
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3075
    INT16 *mot_val;
3076
    static INT8 quant_tab[4] = { -1, -2, 1, 2 };
3077

    
3078
    s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
3079

    
3080
    if(s->mb_x==0) PRINT_MB_TYPE("\n");
3081

    
3082
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3083
        if (get_bits1(&s->gb)) {
3084
            /* skip mb */
3085
            s->mb_intra = 0;
3086
            for(i=0;i<6;i++)
3087
                s->block_last_index[i] = -1;
3088
            s->mv_dir = MV_DIR_FORWARD;
3089
            s->mv_type = MV_TYPE_16X16;
3090
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3091
                PRINT_MB_TYPE("G");
3092
                s->mcsel=1;
3093
                s->mv[0][0][0]= get_amv(s, 0);
3094
                s->mv[0][0][1]= get_amv(s, 1);
3095

    
3096
                s->mb_skiped = 0;
3097
            }else{
3098
                PRINT_MB_TYPE("S");
3099
                s->mcsel=0;
3100
                s->mv[0][0][0] = 0;
3101
                s->mv[0][0][1] = 0;
3102
                s->mb_skiped = 1;
3103
            }
3104
            goto end;
3105
        }
3106
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3107
        //fprintf(stderr, "\tCBPC: %d", cbpc);
3108
        if (cbpc < 0)
3109
            return -1;
3110
        if (cbpc > 20)
3111
            cbpc+=3;
3112
        else if (cbpc == 20)
3113
            fprintf(stderr, "Stuffing !");
3114
        
3115
        dquant = cbpc & 8;
3116
        s->mb_intra = ((cbpc & 4) != 0);
3117
        if (s->mb_intra) goto intra;
3118
        
3119
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3120
            s->mcsel= get_bits1(&s->gb);
3121
        else s->mcsel= 0;
3122
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3123
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
3124
        if (dquant) {
3125
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3126
        }
3127
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
3128
            s->interlaced_dct= get_bits1(&s->gb);
3129
        
3130
        s->mv_dir = MV_DIR_FORWARD;
3131
        if ((cbpc & 16) == 0) {
3132
            if(s->mcsel){
3133
                PRINT_MB_TYPE("G");
3134
                /* 16x16 global motion prediction */
3135
                s->mv_type = MV_TYPE_16X16;
3136
                mx= get_amv(s, 0);
3137
                my= get_amv(s, 1);
3138
                s->mv[0][0][0] = mx;
3139
                s->mv[0][0][1] = my;
3140
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
3141
                PRINT_MB_TYPE("f");
3142
                /* 16x8 field motion prediction */
3143
                s->mv_type= MV_TYPE_FIELD;
3144

    
3145
                s->field_select[0][0]= get_bits1(&s->gb);
3146
                s->field_select[0][1]= get_bits1(&s->gb);
3147

    
3148
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3149
                
3150
                for(i=0; i<2; i++){
3151
                    mx = h263_decode_motion(s, pred_x, s->f_code);
3152
                    if (mx >= 0xffff)
3153
                        return -1;
3154
            
3155
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
3156
                    if (my >= 0xffff)
3157
                        return -1;
3158

    
3159
                    s->mv[0][i][0] = mx;
3160
                    s->mv[0][i][1] = my;
3161
                }
3162
            }else{
3163
                PRINT_MB_TYPE("P");
3164
                /* 16x16 motion prediction */
3165
                s->mv_type = MV_TYPE_16X16;
3166
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3167
                if (s->umvplus_dec)
3168
                   mx = h263p_decode_umotion(s, pred_x);
3169
                else
3170
                   mx = h263_decode_motion(s, pred_x, s->f_code);
3171
            
3172
                if (mx >= 0xffff)
3173
                    return -1;
3174
            
3175
                if (s->umvplus_dec)
3176
                   my = h263p_decode_umotion(s, pred_y);
3177
                else
3178
                   my = h263_decode_motion(s, pred_y, s->f_code);
3179
            
3180
                if (my >= 0xffff)
3181
                    return -1;
3182
                s->mv[0][0][0] = mx;
3183
                s->mv[0][0][1] = my;
3184

    
3185
                if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
3186
                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3187
            }
3188
        } else {
3189
            PRINT_MB_TYPE("4");
3190
            s->mv_type = MV_TYPE_8X8;
3191
            for(i=0;i<4;i++) {
3192
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3193
                if (s->umvplus_dec)
3194
                  mx = h263p_decode_umotion(s, pred_x);
3195
                else
3196
                  mx = h263_decode_motion(s, pred_x, s->f_code);
3197
                if (mx >= 0xffff)
3198
                    return -1;
3199
                
3200
                if (s->umvplus_dec)
3201
                  my = h263p_decode_umotion(s, pred_y);
3202
                else    
3203
                  my = h263_decode_motion(s, pred_y, s->f_code);
3204
                if (my >= 0xffff)
3205
                    return -1;
3206
                s->mv[0][i][0] = mx;
3207
                s->mv[0][i][1] = my;
3208
                if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
3209
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3210
                mot_val[0] = mx;
3211
                mot_val[1] = my;
3212
            }
3213
        }
3214
    } else if(s->pict_type==B_TYPE) {
3215
        int modb1; // first bit of modb
3216
        int modb2; // second bit of modb
3217
        int mb_type;
3218
        int xy;
3219

    
3220
        s->mb_intra = 0; //B-frames never contain intra blocks
3221
        s->mcsel=0;      //     ...               true gmc blocks
3222

    
3223
        if(s->mb_x==0){
3224
            for(i=0; i<2; i++){
3225
                s->last_mv[i][0][0]= 
3226
                s->last_mv[i][0][1]= 
3227
                s->last_mv[i][1][0]= 
3228
                s->last_mv[i][1][1]= 0;
3229
            }
3230
        }
3231

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

    
3235
        if(s->mb_skiped){
3236
                /* skip mb */
3237
            for(i=0;i<6;i++)
3238
                s->block_last_index[i] = -1;
3239

    
3240
            s->mv_dir = MV_DIR_FORWARD;
3241
            s->mv_type = MV_TYPE_16X16;
3242
            s->mv[0][0][0] = 0;
3243
            s->mv[0][0][1] = 0;
3244
            s->mv[1][0][0] = 0;
3245
            s->mv[1][0][1] = 0;
3246
            PRINT_MB_TYPE("s");
3247
            goto end;
3248
        }
3249

    
3250
        modb1= get_bits1(&s->gb); 
3251
        if(modb1){
3252
            mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
3253
            cbp=0;
3254
        }else{
3255
            int field_mv;
3256
        
3257
            modb2= get_bits1(&s->gb);
3258
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3259
            if(modb2) cbp= 0;
3260
            else      cbp= get_bits(&s->gb, 6);
3261

    
3262
            if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
3263
                if(get_bits1(&s->gb)){
3264
                    change_qscale(s, get_bits1(&s->gb)*4 - 2);
3265
                }
3266
            }
3267
            field_mv=0;
3268

    
3269
            if(!s->progressive_sequence){
3270
                if(cbp)
3271
                    s->interlaced_dct= get_bits1(&s->gb);
3272

    
3273
                if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
3274
                    field_mv=1;
3275

    
3276
                    if(mb_type!=MB_TYPE_B_BACKW){
3277
                        s->field_select[0][0]= get_bits1(&s->gb);
3278
                        s->field_select[0][1]= get_bits1(&s->gb);
3279
                    }
3280
                    if(mb_type!=MB_TYPE_B_FORW){
3281
                        s->field_select[1][0]= get_bits1(&s->gb);
3282
                        s->field_select[1][1]= get_bits1(&s->gb);
3283
                    }
3284
                }
3285
            }
3286

    
3287
            s->mv_dir = 0;
3288
            if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
3289
                s->mv_type= MV_TYPE_16X16;
3290
                if(mb_type!=MB_TYPE_B_BACKW){
3291
                    s->mv_dir = MV_DIR_FORWARD;
3292

    
3293
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3294
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3295
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3296
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3297
                }
3298
    
3299
                if(mb_type!=MB_TYPE_B_FORW){
3300
                    s->mv_dir |= MV_DIR_BACKWARD;
3301

    
3302
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3303
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3304
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3305
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3306
                }
3307
                if(mb_type!=MB_TYPE_B_DIRECT)
3308
                    PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "F" : (mb_type==MB_TYPE_B_BACKW ? "B" : "T"));
3309
            }else if(mb_type!=MB_TYPE_B_DIRECT){
3310
                s->mv_type= MV_TYPE_FIELD;
3311

    
3312
                if(mb_type!=MB_TYPE_B_BACKW){
3313
                    s->mv_dir = MV_DIR_FORWARD;
3314
                
3315
                    for(i=0; i<2; i++){
3316
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3317
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3318
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3319
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3320
                    }
3321
                }
3322
    
3323
                if(mb_type!=MB_TYPE_B_FORW){
3324
                    s->mv_dir |= MV_DIR_BACKWARD;
3325

    
3326
                    for(i=0; i<2; i++){
3327
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
3328
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3329
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
3330
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3331
                    }
3332
                }
3333
                if(mb_type!=MB_TYPE_B_DIRECT)
3334
                    PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "f" : (mb_type==MB_TYPE_B_BACKW ? "b" : "t"));
3335
            }
3336
        }
3337
          
3338
        if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
3339
            if(mb_type==4)
3340
                mx=my=0;
3341
            else{
3342
                mx = h263_decode_motion(s, 0, 1);
3343
                my = h263_decode_motion(s, 0, 1);
3344
            }
3345
 
3346
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3347
            ff_mpeg4_set_direct_mv(s, mx, my);
3348
        }
3349
        
3350
        if(mb_type<0 || mb_type>4){
3351
            printf("illegal MB_type\n");
3352
            return -1;
3353
        }
3354
    } else { /* I-Frame */
3355
        cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
3356
        if (cbpc < 0)
3357
            return -1;
3358
        dquant = cbpc & 4;
3359
        s->mb_intra = 1;
3360
intra:
3361
        s->ac_pred = 0;
3362
        if (s->h263_pred || s->h263_aic) {
3363
            s->ac_pred = get_bits1(&s->gb);
3364
            if (s->ac_pred && s->h263_aic)
3365
                s->h263_aic_dir = get_bits1(&s->gb);
3366
        }
3367
        PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
3368
        
3369
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3370
        if(cbpy<0) return -1;
3371
        cbp = (cbpc & 3) | (cbpy << 2);
3372
        if (dquant) {
3373
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3374
        }
3375
        
3376
        if(!s->progressive_sequence)
3377
            s->interlaced_dct= get_bits1(&s->gb);
3378

    
3379
        /* decode each block */
3380
        if (s->h263_pred) {
3381
            for (i = 0; i < 6; i++) {
3382
                if (mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0)
3383
                    return -1;
3384
                cbp+=cbp;
3385
            }
3386
        } else {
3387
            for (i = 0; i < 6; i++) {
3388
                if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3389
                    return -1;
3390
                cbp+=cbp;
3391
            }
3392
        }
3393
        goto end;
3394
    }
3395

    
3396
    /* decode each block */
3397
    if (s->h263_pred) {
3398
        for (i = 0; i < 6; i++) {
3399
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0)
3400
                return -1;
3401
            cbp+=cbp;
3402
        }
3403
    } else {
3404
        for (i = 0; i < 6; i++) {
3405
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3406
                return -1;
3407
            cbp+=cbp;
3408
        }
3409
    }
3410
end:
3411

    
3412
        /* per-MB end of slice check */
3413
    if(s->codec_id==CODEC_ID_MPEG4){
3414
        if(mpeg4_is_resync(s)){
3415
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x+1])
3416
                return SLICE_OK;
3417
            return SLICE_END;
3418
        }
3419
    }else{
3420
        int v= show_bits(&s->gb, 16);
3421
    
3422
        if(get_bits_count(&s->gb) + 16 > s->gb.size*8){
3423
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size*8;
3424
        }
3425

    
3426
        if(v==0)
3427
            return SLICE_END;
3428
    }
3429

    
3430
    return SLICE_OK;     
3431
}
3432

    
3433
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3434
{
3435
    int code, val, sign, shift, l;
3436
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3437
    if (code < 0)
3438
        return 0xffff;
3439

    
3440
    if (code == 0)
3441
        return pred;
3442

    
3443
    sign = get_bits1(&s->gb);
3444
    shift = f_code - 1;
3445
    val = (code - 1) << shift;
3446
    if (shift > 0)
3447
        val |= get_bits(&s->gb, shift);
3448
    val++;
3449
    if (sign)
3450
        val = -val;
3451
    val += pred;
3452

    
3453
    /* modulo decoding */
3454
    if (!s->h263_long_vectors) {
3455
        l = 1 << (f_code + 4);
3456
        if (val < -l) {
3457
            val += l<<1;
3458
        } else if (val >= l) {
3459
            val -= l<<1;
3460
        }
3461
    } else {
3462
        /* horrible h263 long vector mode */
3463
        if (pred < -31 && val < -63)
3464
            val += 64;
3465
        if (pred > 32 && val > 63)
3466
            val -= 64;
3467
        
3468
    }
3469
    return val;
3470
}
3471

    
3472
/* Decodes RVLC of H.263+ UMV */
3473
static int h263p_decode_umotion(MpegEncContext * s, int pred)
3474
{
3475
   int code = 0, sign;
3476
   
3477
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
3478
      return pred;
3479
   
3480
   code = 2 + get_bits1(&s->gb);
3481
   
3482
   while (get_bits1(&s->gb))
3483
   {
3484
      code <<= 1;
3485
      code += get_bits1(&s->gb);
3486
   }
3487
   sign = code & 1;
3488
   code >>= 1;
3489
   
3490
   code = (sign) ? (pred - code) : (pred + code);
3491
#ifdef DEBUG
3492
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3493
#endif
3494
   return code;   
3495

    
3496
}
3497

    
3498
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3499
                             int n, int coded)
3500
{
3501
    int code, level, i, j, last, run;
3502
    RLTable *rl = &rl_inter;
3503
    const UINT8 *scan_table;
3504

    
3505
    scan_table = s->intra_scantable.permutated;
3506
    if (s->h263_aic && s->mb_intra) {
3507
        rl = &rl_intra_aic;
3508
        i = 0;
3509
        if (s->ac_pred) {
3510
            if (s->h263_aic_dir) 
3511
                scan_table = s->intra_v_scantable.permutated; /* left */
3512
            else
3513
                scan_table = s->intra_h_scantable.permutated; /* top */
3514
        }
3515
    } else if (s->mb_intra) {
3516
        /* DC coef */
3517
        if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
3518
            int component, diff;
3519
            component = (n <= 3 ? 0 : n - 4 + 1);
3520
            level = s->last_dc[component];
3521
            if (s->rv10_first_dc_coded[component]) {
3522
                diff = rv_decode_dc(s, n);
3523
                if (diff == 0xffff)
3524
                    return -1;
3525
                level += diff;
3526
                level = level & 0xff; /* handle wrap round */
3527
                s->last_dc[component] = level;
3528
            } else {
3529
                s->rv10_first_dc_coded[component] = 1;
3530
            }
3531
        } else {
3532
            level = get_bits(&s->gb, 8);
3533
            if (level == 255)
3534
                level = 128;
3535
        }
3536
        block[0] = level;
3537
        i = 1;
3538
    } else {
3539
        i = 0;
3540
    }
3541
    if (!coded) {
3542
        if (s->mb_intra && s->h263_aic)
3543
            goto not_coded;
3544
        s->block_last_index[n] = i - 1;
3545
        return 0;
3546
    }
3547

    
3548
    for(;;) {
3549
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3550
        if (code < 0){
3551
            fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3552
            return -1;
3553
        }
3554
        if (code == rl->n) {
3555
            /* escape */
3556
            last = get_bits1(&s->gb);
3557
            run = get_bits(&s->gb, 6);
3558
            level = (INT8)get_bits(&s->gb, 8);
3559
            if (s->h263_rv10 && level == -128) {
3560
                /* XXX: should patch encoder too */
3561
                level = get_bits(&s->gb, 12);
3562
                level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
3563
            }
3564
        } else {
3565
            run = rl->table_run[code];
3566
            level = rl->table_level[code];
3567
            last = code >= rl->last;
3568
            if (get_bits1(&s->gb))
3569
                level = -level;
3570
        }
3571
        i += run;
3572
        if (i >= 64){
3573
            fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
3574
            return -1;
3575
        }
3576
        j = scan_table[i];
3577
        block[j] = level;
3578
        if (last)
3579
            break;
3580
        i++;
3581
    }
3582
not_coded:    
3583
    if (s->mb_intra && s->h263_aic) {
3584
        h263_pred_acdc(s, block, n);
3585
        i = 63;
3586
    }
3587
    s->block_last_index[n] = i;
3588
    return 0;
3589
}
3590

    
3591
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3592
{
3593
    int level, pred, code;
3594
    UINT16 *dc_val;
3595

    
3596
    if (n < 4) 
3597
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3598
    else 
3599
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3600
    if (code < 0 || code > 9 /* && s->nbit<9 */){
3601
        fprintf(stderr, "illegal dc vlc\n");
3602
        return -1;
3603
    }
3604
    if (code == 0) {
3605
        level = 0;
3606
    } else {
3607
        level = get_bits(&s->gb, code);
3608
        if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
3609
            level = - (level ^ ((1 << code) - 1));
3610
        if (code > 8){
3611
            if(get_bits1(&s->gb)==0){ /* marker */
3612
                if(s->error_resilience>=2){
3613
                    fprintf(stderr, "dc marker bit missing\n");
3614
                    return -1;
3615
                }
3616
            }
3617
        }
3618
    }
3619
    pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3620
    level += pred;
3621
    if (level < 0){
3622
        if(s->error_resilience>=3){
3623
            fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3624
            return -1;
3625
        }
3626
        level = 0;
3627
    }
3628
    if (n < 4) {
3629
        *dc_val = level * s->y_dc_scale;
3630
    } else {
3631
        *dc_val = level * s->c_dc_scale;
3632
    }
3633
    if(s->error_resilience>=3){
3634
        if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3635
            fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3636
            return -1;
3637
        }
3638
    }
3639
    return level;
3640
}
3641

    
3642
/**
3643
 * decodes a block.
3644
 * @return <0 if an error occured
3645
 */
3646
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3647
                              int n, int coded, int intra)
3648
{
3649
    int level, i, last, run;
3650
    int dc_pred_dir;
3651
    RLTable * rl;
3652
    RL_VLC_ELEM * rl_vlc;
3653
    const UINT8 * scan_table;
3654
    int qmul, qadd;
3655

    
3656
    if(intra) {
3657
        /* DC coef */
3658
        if(s->partitioned_frame){
3659
            level = s->dc_val[0][ s->block_index[n] ];
3660
            if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
3661
            else    level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
3662
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
3663
        }else{
3664
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3665
            if (level < 0)
3666
                return -1;
3667
        }
3668
        block[0] = level;
3669
        i = 0;
3670
        if (!coded) 
3671
            goto not_coded;
3672
        rl = &rl_intra;
3673
        rl_vlc = rl_intra.rl_vlc[0];
3674
        if (s->ac_pred) {
3675
            if (dc_pred_dir == 0) 
3676
                scan_table = s->intra_v_scantable.permutated; /* left */
3677
            else
3678
                scan_table = s->intra_h_scantable.permutated; /* top */
3679
        } else {
3680
            scan_table = s->intra_scantable.permutated;
3681
        }
3682
        qmul=1;
3683
        qadd=0;
3684
    } else {
3685
        i = -1;
3686
        if (!coded) {
3687
            s->block_last_index[n] = i;
3688
            return 0;
3689
        }
3690
        rl = &rl_inter;
3691
   
3692
        scan_table = s->intra_scantable.permutated;
3693

    
3694
        if(s->mpeg_quant){
3695
            qmul=1;
3696
            qadd=0;
3697
            rl_vlc = rl_inter.rl_vlc[0];        
3698
        }else{
3699
            qmul = s->qscale << 1;
3700
            qadd = (s->qscale - 1) | 1;
3701
            rl_vlc = rl_inter.rl_vlc[s->qscale];
3702
        }
3703
    }
3704
  {
3705
    OPEN_READER(re, &s->gb);
3706
    for(;;) {
3707
        UPDATE_CACHE(re, &s->gb);
3708
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3709
        if (level==0) {
3710
            int cache;
3711
            cache= GET_CACHE(re, &s->gb);
3712
            /* escape */
3713
            if (cache&0x80000000) {
3714
                if (cache&0x40000000) {
3715
                    /* third escape */
3716
                    SKIP_CACHE(re, &s->gb, 2);
3717
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3718
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3719
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
3720
                    UPDATE_CACHE(re, &s->gb);
3721

    
3722
                    if(SHOW_UBITS(re, &s->gb, 1)==0){
3723
                        fprintf(stderr, "1. marker bit missing in 3. esc\n");
3724
                        return -1;
3725
                    }; SKIP_CACHE(re, &s->gb, 1);
3726
                    
3727
                    level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3728
 
3729
                    if(SHOW_UBITS(re, &s->gb, 1)==0){
3730
                        fprintf(stderr, "2. marker bit missing in 3. esc\n");
3731
                        return -1;
3732
                    }; LAST_SKIP_CACHE(re, &s->gb, 1);
3733
                    
3734
                    SKIP_COUNTER(re, &s->gb, 1+12+1);
3735
                    
3736
                    if(level*s->qscale>1024 || level*s->qscale<-1024){
3737
                        fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3738
                        return -1;
3739
                    }
3740
#if 1 
3741
                    {
3742
                        const int abs_level= ABS(level);
3743
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
3744
                            const int run1= run - rl->max_run[last][abs_level] - 1;
3745
                            if(abs_level <= rl->max_level[last][run]){
3746
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3747
                                return -1;
3748
                            }
3749
                            if(s->error_resilience > FF_ER_COMPLIANT){
3750
                                if(abs_level <= rl->max_level[last][run]*2){
3751
                                    fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3752
                                    return -1;
3753
                                }
3754
                                if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3755
                                    fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3756
                                    return -1;
3757
                                }
3758
                            }
3759
                        }
3760
                    }
3761
#endif
3762
                    if (level>0) level= level * qmul + qadd;
3763
                    else         level= level * qmul - qadd;
3764

    
3765
                    i+= run + 1;
3766
                    if(last) i+=192;
3767
                } else {
3768
                    /* second escape */
3769
#if MIN_CACHE_BITS < 20
3770
                    LAST_SKIP_BITS(re, &s->gb, 2);
3771
                    UPDATE_CACHE(re, &s->gb);
3772
#else
3773
                    SKIP_BITS(re, &s->gb, 2);
3774
#endif
3775
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3776
                    i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3777
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3778
                    LAST_SKIP_BITS(re, &s->gb, 1);
3779
                }
3780
            } else {
3781
                /* first escape */
3782
#if MIN_CACHE_BITS < 19
3783
                LAST_SKIP_BITS(re, &s->gb, 1);
3784
                UPDATE_CACHE(re, &s->gb);
3785
#else
3786
                SKIP_BITS(re, &s->gb, 1);
3787
#endif
3788
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3789
                i+= run;
3790
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3791
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3792
                LAST_SKIP_BITS(re, &s->gb, 1);
3793
            }
3794
        } else {
3795
            i+= run;
3796
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3797
            LAST_SKIP_BITS(re, &s->gb, 1);
3798
        }
3799
        if (i > 62){
3800
            i-= 192;
3801
            if(i&(~63)){
3802
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3803
                return -1;
3804
            }
3805

    
3806
            block[scan_table[i]] = level;
3807
            break;
3808
        }
3809

    
3810
        block[scan_table[i]] = level;
3811
    }
3812
    CLOSE_READER(re, &s->gb);
3813
  }
3814
 not_coded:
3815
    if (s->mb_intra) {
3816
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
3817
        if (s->ac_pred) {
3818
            i = 63; /* XXX: not optimal */
3819
        }
3820
    }
3821
    s->block_last_index[n] = i;
3822
    return 0;
3823
}
3824

    
3825
/* most is hardcoded. should extend to handle all h263 streams */
3826
int h263_decode_picture_header(MpegEncContext *s)
3827
{
3828
    int format, width, height;
3829

    
3830
    /* picture start code */
3831
    if (get_bits(&s->gb, 22) != 0x20) {
3832
        fprintf(stderr, "Bad picture start code\n");
3833
        return -1;
3834
    }
3835
    /* temporal reference */
3836
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3837

    
3838
    /* PTYPE starts here */    
3839
    if (get_bits1(&s->gb) != 1) {
3840
        /* marker */
3841
        fprintf(stderr, "Bad marker\n");
3842
        return -1;
3843
    }
3844
    if (get_bits1(&s->gb) != 0) {
3845
        fprintf(stderr, "Bad H263 id\n");
3846
        return -1;        /* h263 id */
3847
    }
3848
    skip_bits1(&s->gb);        /* split screen off */
3849
    skip_bits1(&s->gb);        /* camera  off */
3850
    skip_bits1(&s->gb);        /* freeze picture release off */
3851

    
3852
    /* Reset GOB number */
3853
    s->gob_number = 0;
3854
        
3855
    format = get_bits(&s->gb, 3);
3856
    /*
3857
        0    forbidden
3858
        1    sub-QCIF
3859
        10   QCIF
3860
        7        extended PTYPE (PLUSPTYPE)
3861
    */
3862

    
3863
    if (format != 7 && format != 6) {
3864
        s->h263_plus = 0;
3865
        /* H.263v1 */
3866
        width = h263_format[format][0];
3867
        height = h263_format[format][1];
3868
        if (!width)
3869
            return -1;
3870
        
3871
        s->width = width;
3872
        s->height = height;
3873
        s->pict_type = I_TYPE + get_bits1(&s->gb);
3874

    
3875
        s->unrestricted_mv = get_bits1(&s->gb); 
3876
        s->h263_long_vectors = s->unrestricted_mv;
3877

    
3878
        if (get_bits1(&s->gb) != 0) {
3879
            fprintf(stderr, "H263 SAC not supported\n");
3880
            return -1;        /* SAC: off */
3881
        }
3882
        if (get_bits1(&s->gb) != 0) {
3883
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3884
        }   
3885
        
3886
        if (get_bits1(&s->gb) != 0) {
3887
            fprintf(stderr, "H263 PB frame not supported\n");
3888
            return -1;        /* not PB frame */
3889
        }
3890
        s->qscale = get_bits(&s->gb, 5);
3891
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
3892
    } else {
3893
        int ufep;
3894
        
3895
        /* H.263v2 */
3896
        s->h263_plus = 1;
3897
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3898

    
3899
        /* ufep other than 0 and 1 are reserved */        
3900
        if (ufep == 1) {
3901
            /* OPPTYPE */       
3902
            format = get_bits(&s->gb, 3);
3903
            dprintf("ufep=1, format: %d\n", format);
3904
            skip_bits(&s->gb,1); /* Custom PCF */
3905
            s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3906
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3907
            if (get_bits1(&s->gb) != 0) {
3908
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3909
            }
3910
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3911
                s->h263_aic = 1;
3912
            }
3913
            
3914
            skip_bits(&s->gb, 7);
3915
            /* these are the 7 bits: (in order of appearence  */
3916
            /* Deblocking Filter */
3917
            /* Slice Structured */
3918
            /* Reference Picture Selection */
3919
            /* Independent Segment Decoding */
3920
            /* Alternative Inter VLC */
3921
            /* Modified Quantization */
3922
            /* Prevent start code emulation */
3923

    
3924
            skip_bits(&s->gb, 3); /* Reserved */
3925
        } else if (ufep != 0) {
3926
            fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3927
            return -1;
3928
        }
3929
            
3930
        /* MPPTYPE */
3931
        s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3932
        dprintf("pict_type: %d\n", s->pict_type);
3933
        if (s->pict_type != I_TYPE &&
3934
            s->pict_type != P_TYPE)
3935
            return -1;
3936
        skip_bits(&s->gb, 2);
3937
        s->no_rounding = get_bits1(&s->gb);
3938
        dprintf("RTYPE: %d\n", s->no_rounding);
3939
        skip_bits(&s->gb, 4);
3940
        
3941
        /* Get the picture dimensions */
3942
        if (ufep) {
3943
            if (format == 6) {
3944
                /* Custom Picture Format (CPFMT) */
3945
                s->aspect_ratio_info = get_bits(&s->gb, 4);
3946
                dprintf("aspect: %d\n", s->aspect_ratio_info);
3947
                /* aspect ratios:
3948
                0 - forbidden
3949
                1 - 1:1
3950
                2 - 12:11 (CIF 4:3)
3951
                3 - 10:11 (525-type 4:3)
3952
                4 - 16:11 (CIF 16:9)
3953
                5 - 40:33 (525-type 16:9)
3954
                6-14 - reserved
3955
                */
3956
                width = (get_bits(&s->gb, 9) + 1) * 4;
3957
                skip_bits1(&s->gb);
3958
                height = get_bits(&s->gb, 9) * 4;
3959
                dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
3960
                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
3961
                    /* aspected dimensions */
3962
                    s->aspected_width = get_bits(&s->gb, 8);
3963
                    s->aspected_height = get_bits(&s->gb, 8);
3964
                }else{
3965
                    s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
3966
                    s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
3967
                }
3968
            } else {
3969
                width = h263_format[format][0];
3970
                height = h263_format[format][1];
3971
            }
3972
            if ((width == 0) || (height == 0))
3973
                return -1;
3974
            s->width = width;
3975
            s->height = height;
3976
            if (s->umvplus_dec) {
3977
                skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
3978
            }
3979
        }
3980
            
3981
        s->qscale = get_bits(&s->gb, 5);
3982
    }
3983
    /* PEI */
3984
    while (get_bits1(&s->gb) != 0) {
3985
        skip_bits(&s->gb, 8);
3986
    }
3987
    s->f_code = 1;
3988
    
3989
    if(s->h263_aic){
3990
         s->y_dc_scale_table= 
3991
         s->c_dc_scale_table= h263_aic_dc_scale_table;
3992
    }else{
3993
        s->y_dc_scale_table=
3994
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
3995
    }
3996

    
3997
    return 0;
3998
}
3999

    
4000
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
4001
{
4002
    int i;
4003
    int a= 2<<s->sprite_warping_accuracy;
4004
    int rho= 3-s->sprite_warping_accuracy;
4005
    int r=16/a;
4006
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
4007
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
4008
    int sprite_ref[4][2];
4009
    int virtual_ref[2][2];
4010
    int w2, h2, w3, h3;
4011
    int alpha=0, beta=0;
4012
    int w= s->width;
4013
    int h= s->height;
4014
    int min_ab;
4015

    
4016
    for(i=0; i<s->num_sprite_warping_points; i++){
4017
        int length;
4018
        int x=0, y=0;
4019

    
4020
        length= get_vlc(&s->gb, &sprite_trajectory);
4021
        if(length){
4022
            x= get_bits(&s->gb, length);
4023

    
4024
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
4025
                x = - (x ^ ((1 << length) - 1));
4026
        }
4027
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4028
        
4029
        length= get_vlc(&s->gb, &sprite_trajectory);
4030
        if(length){
4031
            y=get_bits(&s->gb, length);
4032

    
4033
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
4034
                y = - (y ^ ((1 << length) - 1));
4035
        }
4036
        skip_bits1(&s->gb); /* marker bit */
4037
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4038
        d[i][0]= x;
4039
        d[i][1]= y;
4040
    }
4041

    
4042
    while((1<<alpha)<w) alpha++;
4043
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
4044
    w2= 1<<alpha;
4045
    h2= 1<<beta;
4046

    
4047
// Note, the 4th point isnt used for GMC
4048
    if(s->divx_version==500 && s->divx_build==413){
4049
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
4050
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
4051
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
4052
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
4053
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
4054
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
4055
    } else {
4056
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
4057
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
4058
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
4059
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
4060
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
4061
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
4062
    }
4063
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
4064
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
4065
    
4066
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
4067
// perhaps it should be reordered to be more readable ...
4068
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
4069
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
4070
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
4071
        + 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);
4072
    virtual_ref[0][1]= 16*vop_ref[0][1] 
4073
        + 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);
4074
    virtual_ref[1][0]= 16*vop_ref[0][0] 
4075
        + 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);
4076
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
4077
        + 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);
4078
        
4079
    switch(s->num_sprite_warping_points)
4080
    {
4081
        case 0:
4082
            s->sprite_offset[0][0]= 0;
4083
            s->sprite_offset[0][1]= 0;
4084
            s->sprite_offset[1][0]= 0;
4085
            s->sprite_offset[1][1]= 0;
4086
            s->sprite_delta[0][0]= a;
4087
            s->sprite_delta[0][1]= 0;
4088
            s->sprite_delta[1][0]= 0;
4089
            s->sprite_delta[1][1]= a;
4090
            s->sprite_shift[0]= 0;
4091
            s->sprite_shift[1]= 0;
4092
            break;
4093
        case 1: //GMC only
4094
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
4095
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
4096
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
4097
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
4098
            s->sprite_delta[0][0]= a;
4099
            s->sprite_delta[0][1]= 0;
4100
            s->sprite_delta[1][0]= 0;
4101
            s->sprite_delta[1][1]= a;
4102
            s->sprite_shift[0]= 0;
4103
            s->sprite_shift[1]= 0;
4104
            break;
4105
        case 2:
4106
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
4107
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
4108
                                                  + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
4109
                                                  + (1<<(alpha+rho-1));
4110
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
4111
                                                  + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
4112
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
4113
                                                  + (1<<(alpha+rho-1));
4114
            s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
4115
                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
4116
                                     +2*w2*r*sprite_ref[0][0] 
4117
                                     - 16*w2 
4118
                                     + (1<<(alpha+rho+1)));
4119
            s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
4120
                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
4121
                                     +2*w2*r*sprite_ref[0][1] 
4122
                                     - 16*w2
4123
                                     + (1<<(alpha+rho+1)));
4124
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4125
            s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
4126
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
4127
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4128
            
4129
            s->sprite_shift[0]= alpha+rho;
4130
            s->sprite_shift[1]= alpha+rho+2;
4131
            break;
4132
        case 3:
4133
            min_ab= FFMIN(alpha, beta);
4134
            w3= w2>>min_ab;
4135
            h3= h2>>min_ab;
4136
            s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
4137
                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
4138
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
4139
                                   + (1<<(alpha+beta+rho-min_ab-1));
4140
            s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
4141
                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
4142
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
4143
                                   + (1<<(alpha+beta+rho-min_ab-1));
4144
            s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
4145
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
4146
                                   + 2*w2*h3*r*sprite_ref[0][0]
4147
                                   - 16*w2*h3
4148
                                   + (1<<(alpha+beta+rho-min_ab+1));
4149
            s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4150
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4151
                                   + 2*w2*h3*r*sprite_ref[0][1]
4152
                                   - 16*w2*h3
4153
                                   + (1<<(alpha+beta+rho-min_ab+1));
4154
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4155
            s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4156
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4157
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4158
                                   
4159
            s->sprite_shift[0]= alpha + beta + rho - min_ab;
4160
            s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4161
            break;
4162
    }
4163
    /* try to simplify the situation */ 
4164
    if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4165
       && s->sprite_delta[0][1] == 0
4166
       && s->sprite_delta[1][0] == 0
4167
       && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4168
    {
4169
        s->sprite_offset[0][0]>>=s->sprite_shift[0];
4170
        s->sprite_offset[0][1]>>=s->sprite_shift[0];
4171
        s->sprite_offset[1][0]>>=s->sprite_shift[1];
4172
        s->sprite_offset[1][1]>>=s->sprite_shift[1];
4173
        s->sprite_delta[0][0]= a;
4174
        s->sprite_delta[0][1]= 0;
4175
        s->sprite_delta[1][0]= 0;
4176
        s->sprite_delta[1][1]= a;
4177
        s->sprite_shift[0]= 0;
4178
        s->sprite_shift[1]= 0;
4179
        s->real_sprite_warping_points=1;
4180
    }
4181
    else{
4182
        int shift_y= 16 - s->sprite_shift[0];
4183
        int shift_c= 16 - s->sprite_shift[1];
4184
//printf("shifts %d %d\n", shift_y, shift_c);
4185
        for(i=0; i<2; i++){
4186
            s->sprite_offset[0][i]<<= shift_y;
4187
            s->sprite_offset[1][i]<<= shift_c;
4188
            s->sprite_delta[0][i]<<= shift_y;
4189
            s->sprite_delta[1][i]<<= shift_y;
4190
            s->sprite_shift[i]= 16;
4191
        }
4192
        s->real_sprite_warping_points= s->num_sprite_warping_points;
4193
    }
4194
#if 0
4195
printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4196
    vop_ref[0][0], vop_ref[0][1],
4197
    vop_ref[1][0], vop_ref[1][1],
4198
    vop_ref[2][0], vop_ref[2][1],
4199
    sprite_ref[0][0], sprite_ref[0][1], 
4200
    sprite_ref[1][0], sprite_ref[1][1], 
4201
    sprite_ref[2][0], sprite_ref[2][1], 
4202
    virtual_ref[0][0], virtual_ref[0][1], 
4203
    virtual_ref[1][0], virtual_ref[1][1]
4204
    );
4205
    
4206
printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4207
    s->sprite_offset[0][0], s->sprite_offset[0][1],
4208
    s->sprite_delta[0][0], s->sprite_delta[0][1],
4209
    s->sprite_delta[1][0], s->sprite_delta[1][1],
4210
    s->sprite_shift[0]
4211
    );
4212
#endif
4213
}
4214

    
4215
static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
4216
    int hours, minutes, seconds;
4217

    
4218
    hours= get_bits(gb, 5);
4219
    minutes= get_bits(gb, 6);
4220
    skip_bits1(gb);
4221
    seconds= get_bits(gb, 6);
4222

    
4223
    s->time_base= seconds + 60*(minutes + 60*hours);
4224

    
4225
    skip_bits1(gb);
4226
    skip_bits1(gb);
4227
    
4228
    return 0;
4229
}
4230

    
4231
static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4232
    int width, height, vo_ver_id;
4233

    
4234
    /* vol header */
4235
    skip_bits(gb, 1); /* random access */
4236
    s->vo_type= get_bits(gb, 8);
4237
    if (get_bits1(gb) != 0) { /* is_ol_id */
4238
        vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4239
        skip_bits(gb, 3); /* vo_priority */
4240
    } else {
4241
        vo_ver_id = 1;
4242
    }
4243
//printf("vo type:%d\n",s->vo_type);
4244
    s->aspect_ratio_info= get_bits(gb, 4);
4245
    if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){            
4246
        s->aspected_width = get_bits(gb, 8); // par_width
4247
        s->aspected_height = get_bits(gb, 8); // par_height
4248
    }else{
4249
        s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4250
        s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4251
    }
4252

    
4253
    if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4254
        int chroma_format= get_bits(gb, 2);
4255
        if(chroma_format!=1){
4256
            printf("illegal chroma format\n");
4257
        }
4258
        s->low_delay= get_bits1(gb);
4259
        if(get_bits1(gb)){ /* vbv parameters */
4260
            get_bits(gb, 15);        /* first_half_bitrate */
4261
            skip_bits1(gb);        /* marker */
4262
            get_bits(gb, 15);        /* latter_half_bitrate */
4263
            skip_bits1(gb);        /* marker */
4264
            get_bits(gb, 15);        /* first_half_vbv_buffer_size */
4265
            skip_bits1(gb);        /* marker */
4266
            get_bits(gb, 3);        /* latter_half_vbv_buffer_size */
4267
            get_bits(gb, 11);        /* first_half_vbv_occupancy */
4268
            skip_bits1(gb);        /* marker */
4269
            get_bits(gb, 15);        /* latter_half_vbv_occupancy */
4270
            skip_bits1(gb);        /* marker */               
4271
        }
4272
    }else{
4273
        // set low delay flag only once so the smart? low delay detection wont be overriden
4274
        if(s->picture_number==0)
4275
            s->low_delay=0;
4276
    }
4277

    
4278
    s->shape = get_bits(gb, 2); /* vol shape */
4279
    if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4280
    if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4281
        printf("Gray shape not supported\n");
4282
        skip_bits(gb, 4);  //video_object_layer_shape_extension
4283
    }
4284

    
4285
    skip_bits1(gb);   /* marker */
4286
    
4287
    s->time_increment_resolution = get_bits(gb, 16);
4288
    
4289
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4290
    if (s->time_increment_bits < 1)
4291
        s->time_increment_bits = 1;
4292
    skip_bits1(gb);   /* marker */
4293

    
4294
    if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
4295
        skip_bits(gb, s->time_increment_bits);
4296
    }
4297

    
4298
    if (s->shape != BIN_ONLY_SHAPE) {
4299
        if (s->shape == RECT_SHAPE) {
4300
            skip_bits1(gb);   /* marker */
4301
            width = get_bits(gb, 13);
4302
            skip_bits1(gb);   /* marker */
4303
            height = get_bits(gb, 13);
4304
            skip_bits1(gb);   /* marker */
4305
            if(width && height){ /* they should be non zero but who knows ... */
4306
                s->width = width;
4307
                s->height = height;
4308
//                printf("width/height: %d %d\n", width, height);
4309
            }
4310
        }
4311
        
4312
        s->progressive_sequence= get_bits1(gb)^1;
4313
        if(!get_bits1(gb)) printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
4314
        if (vo_ver_id == 1) {
4315
            s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4316
        } else {
4317
            s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4318
        }
4319
        if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4320
        if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4321
            if(s->vol_sprite_usage==STATIC_SPRITE){
4322
                s->sprite_width = get_bits(gb, 13);
4323
                skip_bits1(gb); /* marker */
4324
                s->sprite_height= get_bits(gb, 13);
4325
                skip_bits1(gb); /* marker */
4326
                s->sprite_left  = get_bits(gb, 13);
4327
                skip_bits1(gb); /* marker */
4328
                s->sprite_top   = get_bits(gb, 13);
4329
                skip_bits1(gb); /* marker */
4330
            }
4331
            s->num_sprite_warping_points= get_bits(gb, 6);
4332
            s->sprite_warping_accuracy = get_bits(gb, 2);
4333
            s->sprite_brightness_change= get_bits1(gb);
4334
            if(s->vol_sprite_usage==STATIC_SPRITE)
4335
                s->low_latency_sprite= get_bits1(gb);            
4336
        }
4337
        // FIXME sadct disable bit if verid!=1 && shape not rect
4338
        
4339
        if (get_bits1(gb) == 1) {   /* not_8_bit */
4340
            s->quant_precision = get_bits(gb, 4); /* quant_precision */
4341
            if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4342
            if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4343
        } else {
4344
            s->quant_precision = 5;
4345
        }
4346
        
4347
        // FIXME a bunch of grayscale shape things
4348

    
4349
        if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4350
            int i, j, v;
4351
            
4352
            /* load default matrixes */
4353
            for(i=0; i<64; i++){
4354
                int j= s->idct_permutation[i];
4355
                v= ff_mpeg4_default_intra_matrix[i];
4356
                s->intra_matrix[j]= v;
4357
                s->chroma_intra_matrix[j]= v;
4358
                
4359
                v= ff_mpeg4_default_non_intra_matrix[i];
4360
                s->inter_matrix[j]= v;
4361
                s->chroma_inter_matrix[j]= v;
4362
            }
4363

    
4364
            /* load custom intra matrix */
4365
            if(get_bits1(gb)){
4366
                int last=0;
4367
                for(i=0; i<64; i++){
4368
                    v= get_bits(gb, 8);
4369
                    if(v==0) break;
4370
                    
4371
                    last= v;
4372
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4373
                    s->intra_matrix[j]= v;
4374
                    s->chroma_intra_matrix[j]= v;
4375
                }
4376

    
4377
                /* replicate last value */
4378
                for(; i<64; i++){
4379
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4380
                    s->intra_matrix[j]= v;
4381
                    s->chroma_intra_matrix[j]= v;
4382
                }
4383
            }
4384

    
4385
            /* load custom non intra matrix */
4386
            if(get_bits1(gb)){
4387
                int last=0;
4388
                for(i=0; i<64; i++){
4389
                    v= get_bits(gb, 8);
4390
                    if(v==0) break;
4391

    
4392
                    last= v;
4393
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4394
                    s->inter_matrix[j]= v;
4395
                    s->chroma_inter_matrix[j]= v;
4396
                }
4397

    
4398
                /* replicate last value */
4399
                for(; i<64; i++){
4400
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4401
                    s->inter_matrix[j]= last;
4402
                    s->chroma_inter_matrix[j]= last;
4403
                }
4404
            }
4405

    
4406
            // FIXME a bunch of grayscale shape things
4407
        }
4408

    
4409
        if(vo_ver_id != 1)
4410
             s->quarter_sample= get_bits1(gb);
4411
        else s->quarter_sample=0;
4412

    
4413
        if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4414

    
4415
        s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4416

    
4417
        s->data_partitioning= get_bits1(gb);
4418
        if(s->data_partitioning){
4419
            s->rvlc= get_bits1(gb);
4420
            if(s->rvlc){
4421
                printf("reversible vlc not supported\n");
4422
            }
4423
        }
4424
        
4425
        if(vo_ver_id != 1) {
4426
            s->new_pred= get_bits1(gb);
4427
            if(s->new_pred){
4428
                printf("new pred not supported\n");
4429
                skip_bits(gb, 2); /* requested upstream message type */
4430
                skip_bits1(gb); /* newpred segment type */
4431
            }
4432
            s->reduced_res_vop= get_bits1(gb);
4433
            if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4434
        }
4435
        else{
4436
            s->new_pred=0;
4437
            s->reduced_res_vop= 0;
4438
        }
4439

    
4440
        s->scalability= get_bits1(gb);
4441

    
4442
        if (s->scalability) {
4443
            GetBitContext bak= *gb;
4444
            int ref_layer_id;
4445
            int ref_layer_sampling_dir;
4446
            int h_sampling_factor_n;
4447
            int h_sampling_factor_m;
4448
            int v_sampling_factor_n;
4449
            int v_sampling_factor_m;
4450
            
4451
            s->hierachy_type= get_bits1(gb);
4452
            ref_layer_id= get_bits(gb, 4);
4453
            ref_layer_sampling_dir= get_bits1(gb);
4454
            h_sampling_factor_n= get_bits(gb, 5);
4455
            h_sampling_factor_m= get_bits(gb, 5);
4456
            v_sampling_factor_n= get_bits(gb, 5);
4457
            v_sampling_factor_m= get_bits(gb, 5);
4458
            s->enhancement_type= get_bits1(gb);
4459
            
4460
            if(   h_sampling_factor_n==0 || h_sampling_factor_m==0 
4461
               || v_sampling_factor_n==0 || v_sampling_factor_m==0){
4462
               
4463
//                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4464
                s->scalability=0;
4465
               
4466
                *gb= bak;
4467
            }else
4468
                printf("scalability not supported\n");
4469
            
4470
            // bin shape stuff FIXME
4471
        }
4472
    }
4473
    return 0;
4474
}
4475

    
4476
static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
4477
    char buf[256];
4478
    int i;
4479
    int e;
4480
    int ver, build, ver2, ver3;
4481

    
4482
    buf[0]= show_bits(gb, 8);
4483
    for(i=1; i<256; i++){
4484
        buf[i]= show_bits(gb, 16)&0xFF;
4485
        if(buf[i]==0) break;
4486
        skip_bits(gb, 8);
4487
    }
4488
    buf[255]=0;
4489
    
4490
    /* divx detection */
4491
    e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
4492
    if(e!=2)
4493
        e=sscanf(buf, "DivX%db%d", &ver, &build);
4494
    if(e==2){
4495
        s->divx_version= ver;
4496
        s->divx_build= build;
4497
        if(s->picture_number==0){
4498
            printf("This file was encoded with DivX%d Build%d\n", ver, build);
4499
        }
4500
    }
4501
    
4502
    /* ffmpeg detection */
4503
    e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
4504
    if(e!=4)
4505
        e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); 
4506
    if(e!=4){
4507
        if(strcmp(buf, "ffmpeg")==0){
4508
            s->ffmpeg_version= 0x000406;
4509
            s->lavc_build= 4600;
4510
        }
4511
    }
4512
    if(e==4){
4513
        s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
4514
        s->lavc_build= build;
4515
        if(s->picture_number==0)
4516
            printf("This file was encoded with libavcodec build %d\n", build);
4517
    }
4518
    
4519
    /* xvid detection */
4520
    e=sscanf(buf, "XviD%d", &build);
4521
    if(e==1){
4522
        s->xvid_build= build;
4523
        if(s->picture_number==0)
4524
            printf("This file was encoded with XviD build %d\n", build);
4525
    }
4526

    
4527
//printf("User Data: %s\n", buf);
4528
    return 0;
4529
}
4530

    
4531
static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
4532
    int time_incr, time_increment;
4533

    
4534
    s->pict_type = get_bits(gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
4535
    if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
4536
        printf("low_delay flag set, but shouldnt, clearing it\n");
4537
        s->low_delay=0;
4538
    }
4539
 
4540
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
4541
    if(s->partitioned_frame)
4542
        s->decode_mb= mpeg4_decode_partitioned_mb;
4543
    else
4544
        s->decode_mb= ff_h263_decode_mb;
4545

    
4546
    if(s->time_increment_resolution==0){
4547
        s->time_increment_resolution=1;
4548
//        fprintf(stderr, "time_increment_resolution is illegal\n");
4549
    }
4550
    time_incr=0;
4551
    while (get_bits1(gb) != 0) 
4552
        time_incr++;
4553

    
4554
    check_marker(gb, "before time_increment");
4555
    time_increment= get_bits(gb, s->time_increment_bits);
4556
//printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4557
    if(s->pict_type!=B_TYPE){
4558
        s->last_time_base= s->time_base;
4559
        s->time_base+= time_incr;
4560
        s->time= s->time_base*s->time_increment_resolution + time_increment;
4561
        if(s->workaround_bugs&FF_BUG_UMP4){
4562
            if(s->time < s->last_non_b_time){
4563
//                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4564
                s->time_base++;
4565
                s->time+= s->time_increment_resolution;
4566
            }
4567
        }
4568
        s->pp_time= s->time - s->last_non_b_time;
4569
        s->last_non_b_time= s->time;
4570
    }else{
4571
        s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4572
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4573
        if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4574
//            printf("messed up order, seeking?, skiping current b frame\n");
4575
            return FRAME_SKIPED;
4576
        }
4577
        
4578
        if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4579
        if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4580
//printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4581
        s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame) 
4582
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4583
        s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame) 
4584
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4585
    }
4586
    
4587
    s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4588
    if(s->avctx->debug&FF_DEBUG_PTS)
4589
        printf("MPEG4 PTS: %f\n", s->current_picture.pts/(1000.0*1000.0));
4590
    
4591
    if(check_marker(gb, "before vop_coded")==0 && s->picture_number==0){
4592
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4593
        for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
4594
            if(get_bits1(gb)) break;
4595
        }
4596
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
4597
    }
4598
    /* vop coded */
4599
    if (get_bits1(gb) != 1){
4600
        printf("vop not coded\n");
4601
        return FRAME_SKIPED;
4602
    }
4603
//printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4604
//s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);  
4605
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4606
                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4607
        /* rounding type for motion estimation */
4608
        s->no_rounding = get_bits1(gb);
4609
    } else {
4610
        s->no_rounding = 0;
4611
    }
4612
//FIXME reduced res stuff
4613

    
4614
     if (s->shape != RECT_SHAPE) {
4615
         if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4616
             int width, height, hor_spat_ref, ver_spat_ref;
4617
 
4618
             width = get_bits(gb, 13);
4619
             skip_bits1(gb);   /* marker */
4620
             height = get_bits(gb, 13);
4621
             skip_bits1(gb);   /* marker */
4622
             hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
4623
             skip_bits1(gb);   /* marker */
4624
             ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
4625
         }
4626
         skip_bits1(gb); /* change_CR_disable */
4627
 
4628
         if (get_bits1(gb) != 0) {
4629
             skip_bits(gb, 8); /* constant_alpha_value */
4630
         }
4631
     }
4632
//FIXME complexity estimation stuff
4633
     
4634
     if (s->shape != BIN_ONLY_SHAPE) {
4635
         int t;
4636
         t=get_bits(gb, 3); /* intra dc VLC threshold */
4637
//printf("threshold %d\n", t);
4638
         if(!s->progressive_sequence){
4639
             s->top_field_first= get_bits1(gb);
4640
             s->alternate_scan= get_bits1(gb);
4641
         }else
4642
             s->alternate_scan= 0;
4643
     }
4644

    
4645
     if(s->alternate_scan){
4646
         ff_init_scantable(s, &s->inter_scantable  , ff_alternate_vertical_scan);
4647
         ff_init_scantable(s, &s->intra_scantable  , ff_alternate_vertical_scan);
4648
         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
4649
         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4650
     } else{
4651
         ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
4652
         ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
4653
         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
4654
         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4655
     }
4656
 
4657
     if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
4658
         mpeg4_decode_sprite_trajectory(s);
4659
         if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
4660
         if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
4661
     }
4662

    
4663
     if (s->shape != BIN_ONLY_SHAPE) {
4664
         s->qscale = get_bits(gb, s->quant_precision);
4665
         if(s->qscale==0){
4666
             printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
4667
             return -1; // makes no sense to continue, as there is nothing left from the image then
4668
         }
4669
  
4670
         if (s->pict_type != I_TYPE) {
4671
             s->f_code = get_bits(gb, 3);        /* fcode_for */
4672
             if(s->f_code==0){
4673
                 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
4674
                 return -1; // makes no sense to continue, as the MV decoding will break very quickly
4675
             }
4676
         }else
4677
             s->f_code=1;
4678
     
4679
         if (s->pict_type == B_TYPE) {
4680
             s->b_code = get_bits(gb, 3);
4681
         }else
4682
             s->b_code=1;
4683

    
4684
         if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4685
             printf("qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d\n", 
4686
                 s->qscale, s->f_code, s->b_code, 
4687
                 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), 
4688
                 gb->size,s->progressive_sequence, s->alternate_scan, s->top_field_first, 
4689
                 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
4690
                 s->sprite_warping_accuracy); 
4691