Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 4d2a4834

History | View | Annotate | Download (164 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
/**
27
 * @file h263.c
28
 * h263/mpeg4 codec.
29
 */
30
 
31
//#define DEBUG
32
#include "common.h"
33
#include "dsputil.h"
34
#include "avcodec.h"
35
#include "mpegvideo.h"
36
#include "h263data.h"
37
#include "mpeg4data.h"
38

    
39
//#undef NDEBUG
40
//#include <assert.h>
41

    
42
#if 1
43
#define PRINT_MB_TYPE(a) {}
44
#else
45
#define PRINT_MB_TYPE(a) printf(a)
46
#endif
47

    
48
#define INTRA_MCBPC_VLC_BITS 6
49
#define INTER_MCBPC_VLC_BITS 6
50
#define CBPY_VLC_BITS 6
51
#define MV_VLC_BITS 9
52
#define DC_VLC_BITS 9
53
#define SPRITE_TRAJ_VLC_BITS 6
54
#define MB_TYPE_B_VLC_BITS 4
55
#define TEX_VLC_BITS 9
56

    
57
#ifdef CONFIG_ENCODERS
58
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
59
                              int n);
60
static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
61
static void h263p_encode_umotion(MpegEncContext * s, int val);
62
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
63
                               int n, int dc, uint8_t *scan_table, 
64
                               PutBitContext *dc_pb, PutBitContext *ac_pb);
65
#endif
66

    
67
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
68
static int h263p_decode_umotion(MpegEncContext * s, int pred);
69
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
70
                             int n, int coded);
71
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
72
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
73
                              int n, int coded, int intra, int rvlc);
74
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
75
#ifdef CONFIG_ENCODERS
76
static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
77
                              int dir);
78
#endif //CONFIG_ENCODERS
79
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
80
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
81

    
82
extern uint32_t inverse[256];
83

    
84
#ifdef CONFIG_ENCODERS
85
static uint8_t uni_DCtab_lum_len[512];
86
static uint8_t uni_DCtab_chrom_len[512];
87
static uint16_t uni_DCtab_lum_bits[512];
88
static uint16_t uni_DCtab_chrom_bits[512];
89

    
90
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
91
static uint8_t fcode_tab[MAX_MV*2+1];
92
static uint8_t umv_fcode_tab[MAX_MV*2+1];
93

    
94
static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
95
static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
96
static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
97
static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
98
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
99
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
100
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
101

    
102
/* mpeg4
103
inter
104
max level: 24/6
105
max run: 53/63
106

107
intra
108
max level: 53/16
109
max run: 29/41
110
*/
111
#endif
112

    
113

    
114
int h263_get_picture_format(int width, int height)
115
{
116
    int format;
117

    
118
    if (width == 128 && height == 96)
119
        format = 1;
120
    else if (width == 176 && height == 144)
121
        format = 2;
122
    else if (width == 352 && height == 288)
123
        format = 3;
124
    else if (width == 704 && height == 576)
125
        format = 4;
126
    else if (width == 1408 && height == 1152)
127
        format = 5;
128
    else
129
        format = 7;
130
    return format;
131
}
132

    
133
#ifdef CONFIG_ENCODERS
134

    
135
static void float_aspect_to_info(MpegEncContext * s, float aspect){
136
    int i;
137

    
138
    aspect*= s->height/(double)s->width;
139
//printf("%f\n", aspect);
140
    
141
    if(aspect==0) aspect= 1.0;
142

    
143
    ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
144

    
145
//printf("%d %d\n", s->aspected_width, s->aspected_height);
146
    for(i=1; i<6; i++){
147
        if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
148
            s->aspect_ratio_info=i;
149
            return;
150
        }
151
    }
152
    
153
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
154
}
155

    
156
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
157
{
158
    int format;
159

    
160
    align_put_bits(&s->pb);
161

    
162
    /* Update the pointer to last GOB */
163
    s->ptr_lastgob = pbBufPtr(&s->pb);
164
    s->gob_number = 0;
165

    
166
    put_bits(&s->pb, 22, 0x20); /* PSC */
167
    put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / 
168
                         s->avctx->frame_rate) & 0xff);
169

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

    
230
            put_bits(&s->pb,4,s->aspect_ratio_info);
231
            put_bits(&s->pb,9,(s->width >> 2) - 1);
232
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
233
            put_bits(&s->pb,9,(s->height >> 2));
234
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
235
            {
236
                put_bits(&s->pb, 8, s->aspected_width);
237
                put_bits(&s->pb, 8, s->aspected_height);
238
            }
239
        }
240
        
241
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
242
        if (s->umvplus)
243
//            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
244
            put_bits(&s->pb,2,1); /* unlimited */
245

    
246
        put_bits(&s->pb, 5, s->qscale);
247
    }
248

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

    
251
    if(s->h263_aic){
252
         s->y_dc_scale_table= 
253
         s->c_dc_scale_table= h263_aic_dc_scale_table;
254
    }else{
255
        s->y_dc_scale_table=
256
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
257
    }
258
}
259

    
260
/**
261
 * Encodes a group of blocks header.
262
 */
263
int h263_encode_gob_header(MpegEncContext * s, int mb_line)
264
{
265
           align_put_bits(&s->pb);
266
           flush_put_bits(&s->pb);
267
           /* Call the RTP callback to send the last GOB */
268
           if (s->rtp_callback) {
269
               int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
270
               s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
271
           }
272
           put_bits(&s->pb, 17, 1); /* GBSC */
273
           s->gob_number = mb_line / s->gob_index;
274
           put_bits(&s->pb, 5, s->gob_number); /* GN */
275
           put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
276
           put_bits(&s->pb, 5, s->qscale); /* GQUANT */
277
           //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
278
    return 0;
279
}
280

    
281
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
282
{
283
    int score0=0, score1=0;
284
    int i, n;
285
    int8_t * const qscale_table= s->current_picture.qscale_table;
286

    
287
    for(n=0; n<6; n++){
288
        int16_t *ac_val, *ac_val1;
289

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

    
341
    return score0 > score1 ? 1 : 0;    
342
}
343

    
344
/**
345
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
346
 */
347
void ff_clean_h263_qscales(MpegEncContext *s){
348
    int i;
349
    int8_t * const qscale_table= s->current_picture.qscale_table;
350
    
351
    for(i=1; i<s->mb_num; i++){
352
        if(qscale_table[i] - qscale_table[i-1] >2)
353
            qscale_table[i]= qscale_table[i-1]+2;
354
    }
355
    for(i=s->mb_num-2; i>=0; i--){
356
        if(qscale_table[i] - qscale_table[i+1] >2)
357
            qscale_table[i]= qscale_table[i+1]+2;
358
    }
359
}
360

    
361
/**
362
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
363
 */
364
void ff_clean_mpeg4_qscales(MpegEncContext *s){
365
    int i;
366
    int8_t * const qscale_table= s->current_picture.qscale_table;
367

    
368
    ff_clean_h263_qscales(s);
369
    
370
    for(i=1; i<s->mb_num; i++){
371
        if(qscale_table[i] != qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_INTER4V)){
372
            s->mb_type[i]&= ~MB_TYPE_INTER4V;
373
            s->mb_type[i]|= MB_TYPE_INTER;
374
        }
375
    }
376

    
377
    if(s->pict_type== B_TYPE){
378
        int odd=0;
379
        /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
380
           for the actual adaptive quantization */
381
        
382
        for(i=0; i<s->mb_num; i++){
383
            odd += qscale_table[i]&1;
384
        }
385
        
386
        if(2*odd > s->mb_num) odd=1;
387
        else                  odd=0;
388
        
389
        for(i=0; i<s->mb_num; i++){
390
            if((qscale_table[i]&1) != odd)
391
                qscale_table[i]++;
392
            if(qscale_table[i] > 31)
393
                qscale_table[i]= 31;
394
        }            
395
    
396
        for(i=1; i<s->mb_num; i++){
397
            if(qscale_table[i] != qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_DIRECT)){
398
                s->mb_type[i]&= ~MB_TYPE_DIRECT;
399
                s->mb_type[i]|= MB_TYPE_BIDIR;
400
            }
401
        }
402
    }
403
}
404

    
405
#endif //CONFIG_ENCODERS
406

    
407
void ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
408
    const int mb_index= s->mb_x + s->mb_y*s->mb_width;
409
    int xy= s->block_index[0];
410
    uint16_t time_pp= s->pp_time;
411
    uint16_t time_pb= s->pb_time;
412
    int i;
413
    
414
    //FIXME avoid divides
415
    switch(s->co_located_type_table[mb_index]){
416
    case 0:
417
        s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
418
        s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
419
        s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
420
                            : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
421
        s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
422
                            : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
423
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
424
            s->mv_type= MV_TYPE_16X16;
425
        else
426
            s->mv_type= MV_TYPE_8X8;
427
        break;
428
    case CO_LOCATED_TYPE_4MV:
429
        s->mv_type = MV_TYPE_8X8;
430
        for(i=0; i<4; i++){
431
            xy= s->block_index[i];
432
            s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
433
            s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
434
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
435
                                : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
436
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1] 
437
                                : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
438
        }
439
        break;
440
    case CO_LOCATED_TYPE_FIELDMV:
441
        s->mv_type = MV_TYPE_FIELD;
442
        for(i=0; i<2; i++){
443
            if(s->top_field_first){
444
                time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
445
                time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
446
            }else{
447
                time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
448
                time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
449
            }
450
            s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
451
            s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
452
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
453
                                : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
454
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] 
455
                                : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
456
        }
457
        break;
458
    }
459
}
460

    
461
#ifdef CONFIG_ENCODERS
462
void mpeg4_encode_mb(MpegEncContext * s,
463
                    DCTELEM block[6][64],
464
                    int motion_x, int motion_y)
465
{
466
    int cbpc, cbpy, pred_x, pred_y;
467
    int bits;
468
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
469
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
470
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
471
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
472
    const int dquant_code[5]= {1,0,9,2,3};
473
    
474
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
475
    if (!s->mb_intra) {
476
        /* compute cbp */
477
        int i, cbp = 0;
478
        for (i = 0; i < 6; i++) {
479
            if (s->block_last_index[i] >= 0)
480
                cbp |= 1 << (5 - i);
481
        }
482

    
483
        if(s->pict_type==B_TYPE){
484
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
485
            int mb_type=  mb_type_table[s->mv_dir];
486
            
487
            if(s->mb_x==0){
488
                s->last_mv[0][0][0]= 
489
                s->last_mv[0][0][1]= 
490
                s->last_mv[1][0][0]= 
491
                s->last_mv[1][0][1]= 0;
492
            }
493
            
494
            assert(s->dquant>=-2 && s->dquant<=2);
495
            assert((s->dquant&1)==0);
496
            assert(mb_type>=0);
497

    
498
            /* nothing to do if this MB was skiped in the next P Frame */
499
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x]){ //FIXME avoid DCT & ...
500
                s->skip_count++;
501
                s->mv[0][0][0]= 
502
                s->mv[0][0][1]= 
503
                s->mv[1][0][0]= 
504
                s->mv[1][0][1]= 0;
505
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
506
                s->qscale -= s->dquant;
507
//                s->mb_skiped=1;
508

    
509
                return;
510
            }
511
            
512
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
513
                /* direct MB with MV={0,0} */
514
                assert(s->dquant==0);
515
                
516
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
517

    
518
                if(interleaved_stats){
519
                    s->misc_bits++;
520
                    s->last_bits++;
521
                }
522
                s->skip_count++;
523
                return;
524
            }
525
            
526
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
527
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
528
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
529
            if(cbp) put_bits(&s->pb, 6, cbp);
530
            
531
            if(cbp && mb_type){
532
                if(s->dquant)
533
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
534
                else
535
                    put_bits(&s->pb, 1, 0);
536
            }else
537
                s->qscale -= s->dquant;
538
            
539
            if(!s->progressive_sequence){
540
                if(cbp)
541
                    put_bits(&s->pb, 1, s->interlaced_dct);
542
                if(mb_type) // not diect mode
543
                    put_bits(&s->pb, 1, 0); // no interlaced ME yet
544
            }
545

    
546
            if(interleaved_stats){
547
                s->misc_bits+= get_bits_diff(s);
548
            }
549

    
550
            switch(mb_type)
551
            {
552
            case 0: /* direct */
553
                h263_encode_motion(s, motion_x, 1);
554
                h263_encode_motion(s, motion_y, 1);                
555
                s->b_count++;
556
                s->f_count++;
557
                break;
558
            case 1: /* bidir */
559
                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
560
                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
561
                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
562
                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
563
                s->last_mv[0][0][0]= s->mv[0][0][0];
564
                s->last_mv[0][0][1]= s->mv[0][0][1];
565
                s->last_mv[1][0][0]= s->mv[1][0][0];
566
                s->last_mv[1][0][1]= s->mv[1][0][1];
567
                s->b_count++;
568
                s->f_count++;
569
                break;
570
            case 2: /* backward */
571
                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
572
                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
573
                s->last_mv[1][0][0]= motion_x;
574
                s->last_mv[1][0][1]= motion_y;
575
                s->b_count++;
576
                break;
577
            case 3: /* forward */
578
                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
579
                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
580
                s->last_mv[0][0][0]= motion_x;
581
                s->last_mv[0][0][1]= motion_y;
582
                s->f_count++;
583
                break;
584
            default:
585
                printf("unknown mb type\n");
586
                return;
587
            }
588

    
589
            if(interleaved_stats){
590
                s->mv_bits+= get_bits_diff(s);
591
            }
592

    
593
            /* encode each block */
594
            for (i = 0; i < 6; i++) {
595
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
596
            }
597

    
598
            if(interleaved_stats){
599
                s->p_tex_bits+= get_bits_diff(s);
600
            }
601
        }else{ /* s->pict_type==B_TYPE */
602
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
603
                /* check if the B frames can skip it too, as we must skip it if we skip here 
604
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
605
                if(s->max_b_frames>0){
606
                    int i;
607
                    int x,y, offset;
608
                    uint8_t *p_pic;
609

    
610
                    x= s->mb_x*16;
611
                    y= s->mb_y*16;
612
                    if(x+16 > s->width)  x= s->width-16;
613
                    if(y+16 > s->height) y= s->height-16;
614

    
615
                    offset= x + y*s->linesize;
616
                    p_pic= s->new_picture.data[0] + offset;
617
                    
618
                    s->mb_skiped=1;
619
                    for(i=0; i<s->max_b_frames; i++){
620
                        uint8_t *b_pic;
621
                        int diff;
622
                        Picture *pic= s->reordered_input_picture[i+1];
623

    
624
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
625

    
626
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
627
                        diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
628
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
629
                            s->mb_skiped=0;
630
                            break;
631
                        }
632
                    }
633
                }else
634
                    s->mb_skiped=1; 
635

    
636
                if(s->mb_skiped==1){
637
                    /* skip macroblock */
638
                    put_bits(&s->pb, 1, 1);
639

    
640
                    if(interleaved_stats){
641
                        s->misc_bits++;
642
                        s->last_bits++;
643
                    }
644
                    s->skip_count++;
645
                    return;
646
                }
647
            }
648

    
649
            put_bits(&s->pb, 1, 0);        /* mb coded */
650
            if(s->mv_type==MV_TYPE_16X16){
651
                cbpc = cbp & 3;
652
                if(s->dquant) cbpc+= 8;
653
                put_bits(&s->pb,
654
                        inter_MCBPC_bits[cbpc],
655
                        inter_MCBPC_code[cbpc]);
656

    
657
                cbpy = cbp >> 2;
658
                cbpy ^= 0xf;
659
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
660
                if(s->dquant)
661
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
662

    
663
                if(!s->progressive_sequence){
664
                    if(cbp)
665
                        put_bits(pb2, 1, s->interlaced_dct);
666
                    put_bits(pb2, 1, 0); // no interlaced ME yet
667
                }
668
                    
669
                if(interleaved_stats){
670
                    s->misc_bits+= get_bits_diff(s);
671
                }
672

    
673
                /* motion vectors: 16x16 mode */
674
                h263_pred_motion(s, 0, &pred_x, &pred_y);
675
            
676
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
677
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
678
            }else{
679
                cbpc = (cbp & 3)+16;
680
                put_bits(&s->pb,
681
                        inter_MCBPC_bits[cbpc],
682
                        inter_MCBPC_code[cbpc]);
683
                cbpy = cbp >> 2;
684
                cbpy ^= 0xf;
685
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
686

    
687
                if(!s->progressive_sequence){
688
                    if(cbp)
689
                        put_bits(pb2, 1, s->interlaced_dct);
690
                }
691
    
692
                if(interleaved_stats){
693
                    s->misc_bits+= get_bits_diff(s);
694
                }
695

    
696
                for(i=0; i<4; i++){
697
                    /* motion vectors: 8x8 mode*/
698
                    h263_pred_motion(s, i, &pred_x, &pred_y);
699

    
700
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
701
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
702
                }
703
            }
704

    
705
            if(interleaved_stats){ 
706
                s->mv_bits+= get_bits_diff(s);
707
            }
708

    
709
            /* encode each block */
710
            for (i = 0; i < 6; i++) {
711
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
712
            }
713

    
714
            if(interleaved_stats){
715
                s->p_tex_bits+= get_bits_diff(s);
716
            }
717
            s->f_count++;
718
        }
719
    } else {
720
        int cbp;
721
        int dc_diff[6];   //dc values with the dc prediction subtracted 
722
        int dir[6];  //prediction direction
723
        int zigzag_last_index[6];
724
        uint8_t *scan_table[6];
725
        int i;
726

    
727
        for(i=0; i<6; i++){
728
            const int level= block[i][0];
729
            uint16_t *dc_ptr;
730

    
731
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
732
            if (i < 4) {
733
                *dc_ptr = level * s->y_dc_scale;
734
            } else {
735
                *dc_ptr = level * s->c_dc_scale;
736
            }
737
        }
738

    
739
        s->ac_pred= decide_ac_pred(s, block, dir);
740

    
741
        if(s->ac_pred){
742
            for(i=0; i<6; i++){
743
                uint8_t *st;
744
                int last_index;
745

    
746
                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
747
                if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
748
                else           st = s->intra_h_scantable.permutated; /* top */
749

    
750
                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
751
                    if(block[i][st[last_index]]) break;
752
                zigzag_last_index[i]= s->block_last_index[i];
753
                s->block_last_index[i]= last_index;
754
                scan_table[i]= st;
755
            }
756
        }else{
757
            for(i=0; i<6; i++)
758
                scan_table[i]= s->intra_scantable.permutated;
759
        }
760

    
761
        /* compute cbp */
762
        cbp = 0;
763
        for (i = 0; i < 6; i++) {
764
            if (s->block_last_index[i] >= 1)
765
                cbp |= 1 << (5 - i);
766
        }
767

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

    
787
        if(!s->progressive_sequence){
788
            put_bits(dc_pb, 1, s->interlaced_dct);
789
        }
790

    
791
        if(interleaved_stats){
792
            s->misc_bits+= get_bits_diff(s);
793
        }
794

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

    
800
        if(interleaved_stats){
801
            s->i_tex_bits+= get_bits_diff(s);
802
        }
803
        s->i_count++;
804

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

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

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

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

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

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

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

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

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

    
1002
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1003
{
1004
    int x, y, wrap, a, c, pred_dc, scale, i;
1005
    int16_t *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->dsp.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->dsp.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->dsp.idct_permutation[i<<3]];
1081
    /* top copy */
1082
    for(i=1;i<8;i++)
1083
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1084
}
1085

    
1086
int16_t *h263_pred_motion(MpegEncContext * s, int block, 
1087
                        int *px, int *py)
1088
{
1089
    int xy, wrap;
1090
    int16_t *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(uint8_t)*(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
#ifdef CONFIG_ENCODERS
1282

    
1283
static void init_uni_dc_tab(void)
1284
{
1285
    int level, uni_code, uni_len;
1286

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

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

    
1302
        /* luminance */
1303
        uni_code= DCtab_lum[size][0];
1304
        uni_len = DCtab_lum[size][1];
1305

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

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

    
1332
    }
1333
}
1334

    
1335
#endif //CONFIG_ENCODERS
1336

    
1337
#ifdef CONFIG_ENCODERS
1338
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1339
    int slevel, run, last;
1340
    
1341
    assert(MAX_LEVEL >= 64);
1342
    assert(MAX_RUN   >= 63);
1343

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

    
1423
void h263_encode_init(MpegEncContext *s)
1424
{
1425
    static int done = 0;
1426

    
1427
    if (!done) {
1428
        done = 1;
1429

    
1430
        init_uni_dc_tab();
1431

    
1432
        init_rl(&rl_inter);
1433
        init_rl(&rl_intra);
1434
        init_rl(&rl_intra_aic);
1435
        
1436
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1437
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1438

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

    
1471
/**
1472
 * encodes a 8x8 block.
1473
 * @param block the 8x8 block
1474
 * @param n block index (0-3 are luma, 4-5 are chroma)
1475
 */
1476
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1477
{
1478
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1479
    RLTable *rl;
1480

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

    
1529
                if(slevel < 128 && slevel > -128) 
1530
                    put_bits(&s->pb, 8, slevel & 0xff);
1531
                else{
1532
                    put_bits(&s->pb, 8, 128);
1533
                    put_bits(&s->pb, 5, slevel & 0x1f);
1534
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
1535
                }
1536
            } else {
1537
                put_bits(&s->pb, 1, sign);
1538
            }
1539
                last_non_zero = i;
1540
            }
1541
    }
1542
}
1543
#endif
1544

    
1545
#ifdef CONFIG_ENCODERS
1546

    
1547
/***************************************************/
1548
/**
1549
 * add mpeg4 stuffing bits (01...1)
1550
 */
1551
void ff_mpeg4_stuffing(PutBitContext * pbc)
1552
{
1553
    int length;
1554
    put_bits(pbc, 1, 0);
1555
    length= (-get_bit_count(pbc))&7;
1556
    if(length) put_bits(pbc, length, (1<<length)-1);
1557
}
1558

    
1559
/* must be called before writing the header */
1560
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1561
    int time_div, time_mod;
1562

    
1563
    if(s->pict_type==I_TYPE){ //we will encode a vol header
1564
        int dummy;
1565
        av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1566
        
1567
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1568
    }
1569
    
1570
    if(s->current_picture.pts)
1571
        s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1572
    else
1573
        s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
1574
    time_div= s->time/s->time_increment_resolution;
1575
    time_mod= s->time%s->time_increment_resolution;
1576

    
1577
    if(s->pict_type==B_TYPE){
1578
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1579
    }else{
1580
        s->last_time_base= s->time_base;
1581
        s->time_base= time_div;
1582
        s->pp_time= s->time - s->last_non_b_time;
1583
        s->last_non_b_time= s->time;
1584
    }
1585
}
1586

    
1587
static void mpeg4_encode_gop_header(MpegEncContext * s){
1588
    int hours, minutes, seconds;
1589
    
1590
    put_bits(&s->pb, 16, 0);
1591
    put_bits(&s->pb, 16, GOP_STARTCODE);
1592
    
1593
    seconds= s->time/s->time_increment_resolution;
1594
    minutes= seconds/60; seconds %= 60;
1595
    hours= minutes/60; minutes %= 60;
1596
    hours%=24;
1597

    
1598
    put_bits(&s->pb, 5, hours);
1599
    put_bits(&s->pb, 6, minutes);
1600
    put_bits(&s->pb, 1, 1);
1601
    put_bits(&s->pb, 6, seconds);
1602
    
1603
    put_bits(&s->pb, 1, 0); //closed gov == NO
1604
    put_bits(&s->pb, 1, 0); //broken link == NO
1605

    
1606
    ff_mpeg4_stuffing(&s->pb);
1607
}
1608

    
1609
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1610
    int profile_and_level_indication;
1611
    int vo_ver_id;
1612
    
1613
    if(s->max_b_frames || s->quarter_sample){
1614
        profile_and_level_indication= 0xF1; // adv simple level 1
1615
        vo_ver_id= 5;
1616
    }else{
1617
        profile_and_level_indication= 0x01; // simple level 1
1618
        vo_ver_id= 1;
1619
    }
1620
    //FIXME levels
1621

    
1622
    put_bits(&s->pb, 16, 0);
1623
    put_bits(&s->pb, 16, VOS_STARTCODE);
1624
    
1625
    put_bits(&s->pb, 8, profile_and_level_indication);
1626
    
1627
    put_bits(&s->pb, 16, 0);
1628
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1629
    
1630
    put_bits(&s->pb, 1, 1);
1631
        put_bits(&s->pb, 4, vo_ver_id);
1632
        put_bits(&s->pb, 3, 1); //priority
1633
 
1634
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
1635
    
1636
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1637

    
1638
    ff_mpeg4_stuffing(&s->pb);
1639
}
1640

    
1641
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
1642
{
1643
    int vo_ver_id;
1644

    
1645
    if(s->max_b_frames || s->quarter_sample){
1646
        vo_ver_id= 5;
1647
        s->vo_type= ADV_SIMPLE_VO_TYPE;
1648
    }else{
1649
        vo_ver_id= 1;
1650
        s->vo_type= SIMPLE_VO_TYPE;
1651
    }
1652

    
1653
    put_bits(&s->pb, 16, 0);
1654
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
1655
    put_bits(&s->pb, 16, 0);
1656
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
1657

    
1658
    put_bits(&s->pb, 1, 0);                /* random access vol */
1659
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1660
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1661
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1662
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1663
    
1664
    float_aspect_to_info(s, s->avctx->aspect_ratio);
1665

    
1666
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1667
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1668
    {
1669
        put_bits(&s->pb, 8, s->aspected_width);
1670
        put_bits(&s->pb, 8, s->aspected_height);
1671
    }
1672

    
1673
    if(s->low_delay){
1674
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1675
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1676
        put_bits(&s->pb, 1, s->low_delay);
1677
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1678
    }else{
1679
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1680
    }
1681

    
1682
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1683
    put_bits(&s->pb, 1, 1);                /* marker bit */
1684
    
1685
    put_bits(&s->pb, 16, s->time_increment_resolution);
1686
    if (s->time_increment_bits < 1)
1687
        s->time_increment_bits = 1;
1688
    put_bits(&s->pb, 1, 1);                /* marker bit */
1689
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1690
    put_bits(&s->pb, 1, 1);                /* marker bit */
1691
    put_bits(&s->pb, 13, s->width);        /* vol width */
1692
    put_bits(&s->pb, 1, 1);                /* marker bit */
1693
    put_bits(&s->pb, 13, s->height);        /* vol height */
1694
    put_bits(&s->pb, 1, 1);                /* marker bit */
1695
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1696
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1697
    if (vo_ver_id == 1) {
1698
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1699
    }else{
1700
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1701
    }
1702
    
1703
    s->quant_precision=5;
1704
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
1705
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
1706
    if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1707

    
1708
    if (vo_ver_id != 1)
1709
        put_bits(&s->pb, 1, s->quarter_sample);
1710
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1711
    s->resync_marker= s->rtp_mode;
1712
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1713
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1714
    if(s->data_partitioning){
1715
        put_bits(&s->pb, 1, 0);                /* no rvlc */
1716
    }
1717

    
1718
    if (vo_ver_id != 1){
1719
        put_bits(&s->pb, 1, 0);                /* newpred */
1720
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1721
    }
1722
    put_bits(&s->pb, 1, 0);                /* scalability */
1723
    
1724
    ff_mpeg4_stuffing(&s->pb);
1725

    
1726
    /* user data */
1727
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
1728
        put_bits(&s->pb, 16, 0);
1729
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1730
        put_string(&s->pb, LIBAVCODEC_IDENT);
1731
        ff_mpeg4_stuffing(&s->pb);
1732
    }
1733
}
1734

    
1735
/* write mpeg4 VOP header */
1736
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1737
{
1738
    int time_incr;
1739
    int time_div, time_mod;
1740
    
1741
    if(s->pict_type==I_TYPE){
1742
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
1743
            mpeg4_encode_visual_object_header(s);
1744
            mpeg4_encode_vol_header(s, 0, 0);
1745
        }
1746
        mpeg4_encode_gop_header(s);
1747
    }
1748
    
1749
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1750

    
1751
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1752
    
1753
    put_bits(&s->pb, 16, 0);                /* vop header */
1754
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
1755
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1756

    
1757
    time_div= s->time/s->time_increment_resolution;
1758
    time_mod= s->time%s->time_increment_resolution;
1759
    time_incr= time_div - s->last_time_base;
1760
    while(time_incr--)
1761
        put_bits(&s->pb, 1, 1);
1762
        
1763
    put_bits(&s->pb, 1, 0);
1764

    
1765
    put_bits(&s->pb, 1, 1);        /* marker */
1766
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1767
    put_bits(&s->pb, 1, 1);        /* marker */
1768
    put_bits(&s->pb, 1, 1);        /* vop coded */
1769
    if (    s->pict_type == P_TYPE 
1770
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1771
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1772
    }
1773
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1774
    if(!s->progressive_sequence){
1775
         put_bits(&s->pb, 1, s->top_field_first);
1776
         put_bits(&s->pb, 1, s->alternate_scan);
1777
    }
1778
    //FIXME sprite stuff
1779

    
1780
    put_bits(&s->pb, 5, s->qscale);
1781

    
1782
    if (s->pict_type != I_TYPE)
1783
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1784
    if (s->pict_type == B_TYPE)
1785
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1786
    //    printf("****frame %d\n", picture_number);
1787

    
1788
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
1789
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1790
     s->h_edge_pos= s->width;
1791
     s->v_edge_pos= s->height;
1792
}
1793

    
1794
#endif //CONFIG_ENCODERS
1795

    
1796
/**
1797
 * change qscale by given dquant and update qscale dependant variables.
1798
 */
1799
static void change_qscale(MpegEncContext * s, int dquant)
1800
{
1801
    s->qscale += dquant;
1802

    
1803
    if (s->qscale < 1)
1804
        s->qscale = 1;
1805
    else if (s->qscale > 31)
1806
        s->qscale = 31;
1807

    
1808
    s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1809
    s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1810
}
1811

    
1812
/**
1813
 * predicts the dc.
1814
 * @param n block index (0-3 are luma, 4-5 are chroma)
1815
 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
1816
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
1817
 * @return the quantized predicted dc
1818
 */
1819
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
1820
{
1821
    int a, b, c, wrap, pred, scale;
1822
    uint16_t *dc_val;
1823
    int dummy;
1824

    
1825
    /* find prediction */
1826
    if (n < 4) {
1827
        scale = s->y_dc_scale;
1828
    } else {
1829
        scale = s->c_dc_scale;
1830
    }
1831
    wrap= s->block_wrap[n];
1832
    dc_val = s->dc_val[0] + s->block_index[n];
1833

    
1834
    /* B C
1835
     * A X 
1836
     */
1837
    a = dc_val[ - 1];
1838
    b = dc_val[ - 1 - wrap];
1839
    c = dc_val[ - wrap];
1840

    
1841
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
1842
    if(s->first_slice_line && n!=3){
1843
        if(n!=2) b=c= 1024;
1844
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
1845
    }
1846
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
1847
        if(n==0 || n==4 || n==5)
1848
            b=1024;
1849
    }
1850

    
1851
    if (abs(a - b) < abs(b - c)) {
1852
        pred = c;
1853
        *dir_ptr = 1; /* top */
1854
    } else {
1855
        pred = a;
1856
        *dir_ptr = 0; /* left */
1857
    }
1858
    /* we assume pred is positive */
1859
#ifdef ARCH_X86
1860
        asm volatile (
1861
                "xorl %%edx, %%edx        \n\t"
1862
                "mul %%ecx                \n\t"
1863
                : "=d" (pred), "=a"(dummy)
1864
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1865
        );
1866
#else
1867
    pred = (pred + (scale >> 1)) / scale;
1868
#endif
1869

    
1870
    /* prepare address for prediction update */
1871
    *dc_val_ptr = &dc_val[0];
1872

    
1873
    return pred;
1874
}
1875

    
1876
/**
1877
 * predicts the ac.
1878
 * @param n block index (0-3 are luma, 4-5 are chroma)
1879
 * @param dir the ac prediction direction
1880
 */
1881
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
1882
                   int dir)
1883
{
1884
    int i;
1885
    int16_t *ac_val, *ac_val1;
1886
    int8_t * const qscale_table= s->current_picture.qscale_table;
1887

    
1888
    /* find prediction */
1889
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1890
    ac_val1 = ac_val;
1891
    if (s->ac_pred) {
1892
        if (dir == 0) {
1893
            const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1894
            /* left prediction */
1895
            ac_val -= 16;
1896
            
1897
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1898
                /* same qscale */
1899
                for(i=1;i<8;i++) {
1900
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1901
                }
1902
            }else{
1903
                /* different qscale, we must rescale */
1904
                for(i=1;i<8;i++) {
1905
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1906
                }
1907
            }
1908
        } else {
1909
            const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1910
            /* top prediction */
1911
            ac_val -= 16 * s->block_wrap[n];
1912

    
1913
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1914
                /* same qscale */
1915
                for(i=1;i<8;i++) {
1916
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
1917
                }
1918
            }else{
1919
                /* different qscale, we must rescale */
1920
                for(i=1;i<8;i++) {
1921
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1922
                }
1923
            }
1924
        }
1925
    }
1926
    /* left copy */
1927
    for(i=1;i<8;i++)
1928
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1929

    
1930
    /* top copy */
1931
    for(i=1;i<8;i++)
1932
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1933

    
1934
}
1935

    
1936
#ifdef CONFIG_ENCODERS
1937

    
1938
static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
1939
                              int dir)
1940
{
1941
    int i;
1942
    int16_t *ac_val;
1943
    int8_t * const qscale_table= s->current_picture.qscale_table;
1944

    
1945
    /* find prediction */
1946
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1947
 
1948
    if (dir == 0) {
1949
        const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1950
        /* left prediction */
1951
        ac_val -= 16;
1952
        if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1953
            /* same qscale */
1954
            for(i=1;i<8;i++) {
1955
                block[s->dsp.idct_permutation[i<<3]] -= ac_val[i];
1956
            }
1957
        }else{
1958
            /* different qscale, we must rescale */
1959
            for(i=1;i<8;i++) {
1960
                block[s->dsp.idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1961
            }
1962
        }
1963
    } else {
1964
        const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1965
        /* top prediction */
1966
        ac_val -= 16 * s->block_wrap[n];
1967
        if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1968
            /* same qscale */
1969
            for(i=1;i<8;i++) {
1970
                block[s->dsp.idct_permutation[i]] -= ac_val[i + 8];
1971
            }
1972
        }else{
1973
            /* different qscale, we must rescale */
1974
            for(i=1;i<8;i++) {
1975
                block[s->dsp.idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1976
            }
1977
        }
1978
    }
1979
}
1980

    
1981
/**
1982
 * encodes the dc value.
1983
 * @param n block index (0-3 are luma, 4-5 are chroma)
1984
 */
1985
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1986
{
1987
#if 1
1988
//    if(level<-255 || level>255) printf("dc overflow\n");
1989
    level+=256;
1990
    if (n < 4) {
1991
        /* luminance */
1992
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
1993
    } else {
1994
        /* chrominance */
1995
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
1996
    }
1997
#else
1998
    int size, v;
1999
    /* find number of bits */
2000
    size = 0;
2001
    v = abs(level);
2002
    while (v) {
2003
        v >>= 1;
2004
        size++;
2005
    }
2006

    
2007
    if (n < 4) {
2008
        /* luminance */
2009
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2010
    } else {
2011
        /* chrominance */
2012
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2013
    }
2014

    
2015
    /* encode remaining bits */
2016
    if (size > 0) {
2017
        if (level < 0)
2018
            level = (-level) ^ ((1 << size) - 1);
2019
        put_bits(&s->pb, size, level);
2020
        if (size > 8)
2021
            put_bits(&s->pb, 1, 1);
2022
    }
2023
#endif
2024
}
2025

    
2026
/**
2027
 * encodes a 8x8 block
2028
 * @param n block index (0-3 are luma, 4-5 are chroma)
2029
 */
2030
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2031
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2032
{
2033
    int i, last_non_zero;
2034
#if 0 //variables for the outcommented version
2035
    int code, sign, last;
2036
#endif
2037
    const RLTable *rl;
2038
    uint32_t *bits_tab;
2039
    uint8_t *len_tab;
2040
    const int last_index = s->block_last_index[n];
2041

    
2042
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2043
        /* mpeg4 based DC predictor */
2044
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2045
        if(last_index<1) return;
2046
        i = 1;
2047
        rl = &rl_intra;
2048
        bits_tab= uni_mpeg4_intra_rl_bits;
2049
        len_tab = uni_mpeg4_intra_rl_len;
2050
    } else {
2051
        if(last_index<0) return;
2052
        i = 0;
2053
        rl = &rl_inter;
2054
        bits_tab= uni_mpeg4_inter_rl_bits;
2055
        len_tab = uni_mpeg4_inter_rl_len;
2056
    }
2057

    
2058
    /* AC coefs */
2059
    last_non_zero = i - 1;
2060
#if 1
2061
    for (; i < last_index; i++) {
2062
        int level = block[ scan_table[i] ];
2063
        if (level) {
2064
            int run = i - last_non_zero - 1;
2065
            level+=64;
2066
            if((level&(~127)) == 0){
2067
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2068
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2069
            }else{ //ESC3
2070
                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);
2071
            }
2072
            last_non_zero = i;
2073
        }
2074
    }
2075
    /*if(i<=last_index)*/{
2076
        int level = block[ scan_table[i] ];
2077
        int run = i - last_non_zero - 1;
2078
        level+=64;
2079
        if((level&(~127)) == 0){
2080
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2081
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2082
        }else{ //ESC3
2083
            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);
2084
        }
2085
    }
2086
#else
2087
    for (; i <= last_index; i++) {
2088
        const int slevel = block[ scan_table[i] ];
2089
        if (slevel) {
2090
            int level;
2091
            int run = i - last_non_zero - 1;
2092
            last = (i == last_index);
2093
            sign = 0;
2094
            level = slevel;
2095
            if (level < 0) {
2096
                sign = 1;
2097
                level = -level;
2098
            }
2099
            code = get_rl_index(rl, last, run, level);
2100
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2101
            if (code == rl->n) {
2102
                int level1, run1;
2103
                level1 = level - rl->max_level[last][run];
2104
                if (level1 < 1) 
2105
                    goto esc2;
2106
                code = get_rl_index(rl, last, run, level1);
2107
                if (code == rl->n) {
2108
                esc2:
2109
                    put_bits(ac_pb, 1, 1);
2110
                    if (level > MAX_LEVEL)
2111
                        goto esc3;
2112
                    run1 = run - rl->max_run[last][level] - 1;
2113
                    if (run1 < 0)
2114
                        goto esc3;
2115
                    code = get_rl_index(rl, last, run1, level);
2116
                    if (code == rl->n) {
2117
                    esc3:
2118
                        /* third escape */
2119
                        put_bits(ac_pb, 1, 1);
2120
                        put_bits(ac_pb, 1, last);
2121
                        put_bits(ac_pb, 6, run);
2122
                        put_bits(ac_pb, 1, 1);
2123
                        put_bits(ac_pb, 12, slevel & 0xfff);
2124
                        put_bits(ac_pb, 1, 1);
2125
                    } else {
2126
                        /* second escape */
2127
                        put_bits(ac_pb, 1, 0);
2128
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2129
                        put_bits(ac_pb, 1, sign);
2130
                    }
2131
                } else {
2132
                    /* first escape */
2133
                    put_bits(ac_pb, 1, 0);
2134
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2135
                    put_bits(ac_pb, 1, sign);
2136
                }
2137
            } else {
2138
                put_bits(ac_pb, 1, sign);
2139
            }
2140
            last_non_zero = i;
2141
        }
2142
    }
2143
#endif
2144
}
2145

    
2146
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2147
                               uint8_t *scan_table)
2148
{
2149
    int i, last_non_zero;
2150
    const RLTable *rl;
2151
    uint8_t *len_tab;
2152
    const int last_index = s->block_last_index[n];
2153
    int len=0;
2154

    
2155
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2156
        /* mpeg4 based DC predictor */
2157
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2158
        if(last_index<1) return len;
2159
        i = 1;
2160
        rl = &rl_intra;
2161
        len_tab = uni_mpeg4_intra_rl_len;
2162
    } else {
2163
        if(last_index<0) return 0;
2164
        i = 0;
2165
        rl = &rl_inter;
2166
        len_tab = uni_mpeg4_inter_rl_len;
2167
    }
2168

    
2169
    /* AC coefs */
2170
    last_non_zero = i - 1;
2171
    for (; i < last_index; i++) {
2172
        int level = block[ scan_table[i] ];
2173
        if (level) {
2174
            int run = i - last_non_zero - 1;
2175
            level+=64;
2176
            if((level&(~127)) == 0){
2177
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2178
                len += len_tab[index];
2179
            }else{ //ESC3
2180
                len += 7+2+1+6+1+12+1;
2181
            }
2182
            last_non_zero = i;
2183
        }
2184
    }
2185
    /*if(i<=last_index)*/{
2186
        int level = block[ scan_table[i] ];
2187
        int run = i - last_non_zero - 1;
2188
        level+=64;
2189
        if((level&(~127)) == 0){
2190
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2191
            len += len_tab[index];
2192
        }else{ //ESC3
2193
            len += 7+2+1+6+1+12+1;
2194
        }
2195
    }
2196
    
2197
    return len;
2198
}
2199

    
2200
#endif
2201

    
2202

    
2203
/***********************************************/
2204
/* decoding */
2205

    
2206
static VLC intra_MCBPC_vlc;
2207
static VLC inter_MCBPC_vlc;
2208
static VLC cbpy_vlc;
2209
static VLC mv_vlc;
2210
static VLC dc_lum, dc_chrom;
2211
static VLC sprite_trajectory;
2212
static VLC mb_type_b_vlc;
2213

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

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

    
2261
/* init vlcs */
2262

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

    
2268
    if (!done) {
2269
        done = 1;
2270

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

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

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

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

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

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

    
2367
#ifdef CONFIG_ENCODERS
2368

    
2369
void ff_mpeg4_init_partitions(MpegEncContext *s)
2370
{
2371
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2372
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
2373
}
2374

    
2375
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2376
{
2377
    const int pb2_len   = get_bit_count(&s->pb2   );
2378
    const int tex_pb_len= get_bit_count(&s->tex_pb);
2379
    const int bits= get_bit_count(&s->pb);
2380

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

    
2392
    flush_put_bits(&s->pb2);
2393
    flush_put_bits(&s->tex_pb);
2394

    
2395
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2396
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2397
    s->last_bits= get_bit_count(&s->pb);
2398
}
2399

    
2400
#endif //CONFIG_ENCODERS
2401

    
2402
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2403
    switch(s->pict_type){
2404
        case I_TYPE:
2405
            return 16;
2406
        case P_TYPE:
2407
        case S_TYPE:
2408
            return s->f_code+15;
2409
        case B_TYPE:
2410
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2411
        default:
2412
            return -1;
2413
    }
2414
}
2415

    
2416
#ifdef CONFIG_ENCODERS
2417

    
2418
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2419
{
2420
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2421

    
2422
    ff_mpeg4_stuffing(&s->pb);
2423
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2424
    put_bits(&s->pb, 1, 1);
2425
    
2426
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2427
    put_bits(&s->pb, s->quant_precision, s->qscale);
2428
    put_bits(&s->pb, 1, 0); /* no HEC */
2429
}
2430

    
2431
#endif //CONFIG_ENCODERS
2432

    
2433
/**
2434
 * check if the next stuff is a resync marker or the end.
2435
 * @return 0 if not
2436
 */
2437
static inline int mpeg4_is_resync(MpegEncContext *s){
2438
    const int bits_count= get_bits_count(&s->gb);
2439
    
2440
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
2441
        return 0;
2442
    }
2443

    
2444
    if(bits_count + 8 >= s->gb.size_in_bits){
2445
        int v= show_bits(&s->gb, 8);
2446
        v|= 0x7F >> (7-(bits_count&7));
2447
                
2448
        if(v==0x7F)
2449
            return 1;
2450
    }else{
2451
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2452
            int len;
2453
            GetBitContext gb= s->gb;
2454
        
2455
            skip_bits(&s->gb, 1);
2456
            align_get_bits(&s->gb);
2457
        
2458
            for(len=0; len<32; len++){
2459
                if(get_bits1(&s->gb)) break;
2460
            }
2461

    
2462
            s->gb= gb;
2463

    
2464
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2465
                return 1;
2466
        }
2467
    }
2468
    return 0;
2469
}
2470

    
2471
/**
2472
 * decodes the next video packet.
2473
 * @return <0 if something went wrong
2474
 */
2475
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2476
{
2477
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2478
    int header_extension=0, mb_num, len;
2479
    
2480
    /* is there enough space left for a video packet + header */
2481
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
2482

    
2483
    for(len=0; len<32; len++){
2484
        if(get_bits1(&s->gb)) break;
2485
    }
2486

    
2487
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2488
        printf("marker does not match f_code\n");
2489
        return -1;
2490
    }
2491
    
2492
    if(s->shape != RECT_SHAPE){
2493
        header_extension= get_bits1(&s->gb);
2494
        //FIXME more stuff here
2495
    }
2496

    
2497
    mb_num= get_bits(&s->gb, mb_num_bits);
2498
    if(mb_num>=s->mb_num){
2499
        fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2500
        return -1;
2501
    }
2502
    s->mb_x= mb_num % s->mb_width;
2503
    s->mb_y= mb_num / s->mb_width;
2504

    
2505
    if(s->shape != BIN_ONLY_SHAPE){
2506
        int qscale= get_bits(&s->gb, s->quant_precision); 
2507
        if(qscale)
2508
            s->qscale= qscale;
2509
    }
2510

    
2511
    if(s->shape == RECT_SHAPE){
2512
        header_extension= get_bits1(&s->gb);
2513
    }
2514
    if(header_extension){
2515
        int time_increment;
2516
        int time_incr=0;
2517

    
2518
        while (get_bits1(&s->gb) != 0) 
2519
            time_incr++;
2520

    
2521
        check_marker(&s->gb, "before time_increment in video packed header");
2522
        time_increment= get_bits(&s->gb, s->time_increment_bits);
2523
        check_marker(&s->gb, "before vop_coding_type in video packed header");
2524
        
2525
        skip_bits(&s->gb, 2); /* vop coding type */
2526
        //FIXME not rect stuff here
2527

    
2528
        if(s->shape != BIN_ONLY_SHAPE){
2529
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2530
//FIXME dont just ignore everything
2531
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2532
                mpeg4_decode_sprite_trajectory(s);
2533
                fprintf(stderr, "untested\n");
2534
            }
2535

    
2536
            //FIXME reduced res stuff here
2537
            
2538
            if (s->pict_type != I_TYPE) {
2539
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
2540
                if(f_code==0){
2541
                    printf("Error, video packet header damaged (f_code=0)\n");
2542
                }
2543
            }
2544
            if (s->pict_type == B_TYPE) {
2545
                int b_code = get_bits(&s->gb, 3);
2546
                if(b_code==0){
2547
                    printf("Error, video packet header damaged (b_code=0)\n");
2548
                }
2549
            }       
2550
        }
2551
    }
2552
    //FIXME new-pred stuff
2553
    
2554
//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));
2555

    
2556
    return 0;
2557
}
2558

    
2559
void ff_mpeg4_clean_buffers(MpegEncContext *s)
2560
{
2561
    int c_wrap, c_xy, l_wrap, l_xy;
2562

    
2563
    l_wrap= s->block_wrap[0];
2564
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2565
    c_wrap= s->block_wrap[4];
2566
    c_xy= s->mb_y*c_wrap + s->mb_x;
2567

    
2568
#if 0
2569
    /* clean DC */
2570
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2571
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2572
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2573
#endif
2574

    
2575
    /* clean AC */
2576
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
2577
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2578
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2579

    
2580
    /* clean MV */
2581
    // we cant clear the MVs as they might be needed by a b frame
2582
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
2583
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2584
    s->last_mv[0][0][0]=
2585
    s->last_mv[0][0][1]=
2586
    s->last_mv[1][0][0]=
2587
    s->last_mv[1][0][1]= 0;
2588
}
2589

    
2590
/**
2591
 * decodes the group of blocks / video packet header.
2592
 * @return <0 if no resync found
2593
 */
2594
int ff_h263_resync(MpegEncContext *s){
2595
    int left, ret;
2596
    
2597
    if(s->codec_id==CODEC_ID_MPEG4)
2598
        skip_bits1(&s->gb);
2599
    
2600
    align_get_bits(&s->gb);
2601

    
2602
    if(show_bits(&s->gb, 16)==0){
2603
        if(s->codec_id==CODEC_ID_MPEG4)
2604
            ret= mpeg4_decode_video_packet_header(s);
2605
        else
2606
            ret= h263_decode_gob_header(s);
2607
        if(ret>=0)
2608
            return 0;
2609
    }
2610
    //ok, its not where its supposed to be ...
2611
    s->gb= s->last_resync_gb;
2612
    align_get_bits(&s->gb);
2613
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2614
    
2615
    for(;left>16+1+5+5; left-=8){ 
2616
        if(show_bits(&s->gb, 16)==0){
2617
            GetBitContext bak= s->gb;
2618

    
2619
            if(s->codec_id==CODEC_ID_MPEG4)
2620
                ret= mpeg4_decode_video_packet_header(s);
2621
            else
2622
                ret= h263_decode_gob_header(s);
2623
            if(ret>=0)
2624
                return 0;
2625

    
2626
            s->gb= bak;
2627
        }
2628
        skip_bits(&s->gb, 8);
2629
    }
2630
    
2631
    return -1;
2632
}
2633

    
2634
/**
2635
 * gets the average motion vector for a GMC MB.
2636
 * @param n either 0 for the x component or 1 for y
2637
 * @returns the average MV for a GMC MB
2638
 */
2639
static inline int get_amv(MpegEncContext *s, int n){
2640
    int x, y, mb_v, sum, dx, dy, shift;
2641
    int len = 1 << (s->f_code + 4);
2642
    const int a= s->sprite_warping_accuracy;
2643

    
2644
    if(s->real_sprite_warping_points==1){
2645
        if(s->divx_version==500 && s->divx_build==413)
2646
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2647
        else
2648
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2649
    }else{
2650
        dx= s->sprite_delta[n][0];
2651
        dy= s->sprite_delta[n][1];
2652
        shift= s->sprite_shift[0];
2653
        if(n) dy -= 1<<(shift + a + 1);
2654
        else  dx -= 1<<(shift + a + 1);
2655
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2656

    
2657
        sum=0;
2658
        for(y=0; y<16; y++){
2659
            int v;
2660
        
2661
            v= mb_v + dy*y;
2662
            //XXX FIXME optimize
2663
            for(x=0; x<16; x++){
2664
                sum+= v>>shift;
2665
                v+= dx;
2666
            }
2667
        }
2668
        sum= RSHIFT(sum, a+8-s->quarter_sample);
2669
    }
2670

    
2671
    if      (sum < -len) sum= -len;
2672
    else if (sum >= len) sum= len-1;
2673

    
2674
    return sum;
2675
}
2676

    
2677
/**
2678
 * decodes first partition.
2679
 * @return number of MBs decoded or <0 if an error occured
2680
 */
2681
static int mpeg4_decode_partition_a(MpegEncContext *s){
2682
    int mb_num;
2683
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2684
    
2685
    /* decode first partition */
2686
    mb_num=0;
2687
    s->first_slice_line=1;
2688
    for(; s->mb_y<s->mb_height; s->mb_y++){
2689
        ff_init_block_index(s);
2690
        for(; s->mb_x<s->mb_width; s->mb_x++){
2691
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2692
            int cbpc;
2693
            int dir=0;
2694
            
2695
            mb_num++;
2696
            ff_update_block_index(s);
2697
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2698
                s->first_slice_line=0;
2699
            
2700
            if(s->mb_x==0) PRINT_MB_TYPE("\n");
2701

    
2702
            if(s->pict_type==I_TYPE){
2703
                int i;
2704

    
2705
                if(show_bits(&s->gb, 19)==DC_MARKER){
2706
                    return mb_num-1;
2707
                }
2708

    
2709
                PRINT_MB_TYPE("I");
2710
                cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2711
                if (cbpc < 0){
2712

    
2713
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2714
                    return -1;
2715
                }
2716
                s->cbp_table[xy]= cbpc & 3;
2717
                s->mb_type[xy]= MB_TYPE_INTRA;
2718
                s->mb_intra = 1;
2719

    
2720
                if(cbpc & 4) {
2721
                    change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2722
                }
2723
                s->current_picture.qscale_table[xy]= s->qscale;
2724

    
2725
                s->mbintra_table[xy]= 1;
2726
                for(i=0; i<6; i++){
2727
                    int dc_pred_dir;
2728
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2729
                    if(dc < 0){
2730
                        fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2731
                        return -1;
2732
                    }
2733
                    dir<<=1;
2734
                    if(dc_pred_dir) dir|=1;
2735
                }
2736
                s->pred_dir_table[xy]= dir;
2737
            }else{ /* P/S_TYPE */
2738
                int mx, my, pred_x, pred_y, bits;
2739
                int16_t * const mot_val= s->motion_val[s->block_index[0]];
2740
                const int stride= s->block_wrap[0]*2;
2741

    
2742
                bits= show_bits(&s->gb, 17);
2743
                if(bits==MOTION_MARKER){
2744
                    return mb_num-1;
2745
                }
2746
                skip_bits1(&s->gb);
2747
                if(bits&0x10000){
2748
                    /* skip mb */
2749
                    s->mb_type[xy]= MB_TYPE_SKIPED;
2750
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2751
                        PRINT_MB_TYPE("G");
2752
                        mx= get_amv(s, 0);
2753
                        my= get_amv(s, 1);
2754
                    }else{
2755
                        PRINT_MB_TYPE("S");
2756
                        mx=my=0;
2757
                    }
2758
                    mot_val[0       ]= mot_val[2       ]=
2759
                    mot_val[0+stride]= mot_val[2+stride]= mx;
2760
                    mot_val[1       ]= mot_val[3       ]=
2761
                    mot_val[1+stride]= mot_val[3+stride]= my;
2762

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

    
2792
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2793
                        s->mcsel= get_bits1(&s->gb);
2794
                    else s->mcsel= 0;
2795
        
2796
                    if ((cbpc & 16) == 0) {
2797
                        PRINT_MB_TYPE("P");
2798
                        /* 16x16 motion prediction */
2799
                        s->mb_type[xy]= MB_TYPE_INTER;
2800

    
2801
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
2802
                        if(!s->mcsel){
2803
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2804
                            if (mx >= 0xffff)
2805
                                return -1;
2806

    
2807
                            my = h263_decode_motion(s, pred_y, s->f_code);
2808
                            if (my >= 0xffff)
2809
                                return -1;
2810
                        } else {
2811
                            mx = get_amv(s, 0);
2812
                            my = get_amv(s, 1);
2813
                        }
2814

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

    
2842
    return mb_num;
2843
}
2844

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

    
2853
    s->mb_x= s->resync_mb_x;
2854
    s->first_slice_line=1;
2855
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
2856
        ff_init_block_index(s);
2857
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
2858
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2859

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

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

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

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

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

    
2931
/**
2932
 * decodes the first & second partition
2933
 * @return <0 if error (and sets error type in the error_status_table)
2934
 */
2935
int ff_mpeg4_decode_partitions(MpegEncContext *s)
2936
{
2937
    int mb_num;
2938
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
2939
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
2940
    
2941
    mb_num= mpeg4_decode_partition_a(s);    
2942
    if(mb_num<0){
2943
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
2944
        return -1;
2945
    }
2946
    
2947
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
2948
        fprintf(stderr, "slice below monitor ...\n");
2949
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
2950
        return -1;
2951
    }
2952

    
2953
    s->mb_num_left= mb_num;
2954
        
2955
    if(s->pict_type==I_TYPE){
2956
        if(get_bits(&s->gb, 19)!=DC_MARKER){
2957
            fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
2958
            return -1;
2959
        }
2960
    }else{
2961
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
2962
            fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
2963
            return -1;
2964
        }
2965
    }
2966
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
2967
    
2968
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
2969
        if(s->pict_type==P_TYPE)
2970
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
2971
        return -1;
2972
    }else{
2973
        if(s->pict_type==P_TYPE)
2974
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
2975
    }
2976

    
2977
    return 0;        
2978
}
2979

    
2980
/**
2981
 * decode partition C of one MB.
2982
 * @return <0 if an error occured
2983
 */
2984
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
2985
{
2986
    int cbp, mb_type;
2987
    const int xy= s->mb_x + s->mb_y*s->mb_width;
2988

    
2989
    mb_type= s->mb_type[xy];
2990
    cbp = s->cbp_table[xy];
2991

    
2992
    if(s->current_picture.qscale_table[xy] != s->qscale){
2993
        s->qscale= s->current_picture.qscale_table[xy];
2994
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2995
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2996
    }
2997
    
2998
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2999
        int i;
3000
        for(i=0; i<4; i++){
3001
            s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
3002
            s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
3003
        }
3004
        s->mb_intra = mb_type&MB_TYPE_INTRA;
3005

    
3006
        if (mb_type&MB_TYPE_SKIPED) {
3007
            /* skip mb */
3008
            for(i=0;i<6;i++)
3009
                s->block_last_index[i] = -1;
3010
            s->mv_dir = MV_DIR_FORWARD;
3011
            s->mv_type = MV_TYPE_16X16;
3012
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3013
                s->mcsel=1;
3014
                s->mb_skiped = 0;
3015
            }else{
3016
                s->mcsel=0;
3017
                s->mb_skiped = 1;
3018
            }
3019
        }else if(s->mb_intra){
3020
            s->ac_pred = s->pred_dir_table[xy]>>7;
3021
        }else if(!s->mb_intra){
3022
//            s->mcsel= 0; //FIXME do we need to init that
3023
            
3024
            s->mv_dir = MV_DIR_FORWARD;
3025
            if (mb_type&MB_TYPE_INTER4V) {
3026
                s->mv_type = MV_TYPE_8X8;
3027
            } else {
3028
                s->mv_type = MV_TYPE_16X16;
3029
            }
3030
        }
3031
    } else { /* I-Frame */
3032
        s->mb_intra = 1;
3033
        s->ac_pred = s->pred_dir_table[xy]>>7;
3034
    }
3035

    
3036
    if (!(mb_type&MB_TYPE_SKIPED)) {
3037
        int i;
3038
        /* decode each block */
3039
        for (i = 0; i < 6; i++) {
3040
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3041
                fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3042
                return -1;
3043
            }
3044
            cbp+=cbp;
3045
        }
3046
    }
3047

    
3048
    /* per-MB end of slice check */
3049

    
3050
    if(--s->mb_num_left <= 0){
3051
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3052
        if(mpeg4_is_resync(s))
3053
            return SLICE_END;
3054
        else
3055
            return SLICE_NOEND;     
3056
    }else{
3057
        if(s->cbp_table[xy+1] && mpeg4_is_resync(s))
3058
            return SLICE_END;
3059
        else
3060
            return SLICE_OK;
3061
    }
3062
}
3063

    
3064
int ff_h263_decode_mb(MpegEncContext *s,
3065
                      DCTELEM block[6][64])
3066
{
3067
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3068
    int16_t *mot_val;
3069
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
3070

    
3071
    if(s->mb_x==0) PRINT_MB_TYPE("\n");
3072

    
3073
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3074
        if (get_bits1(&s->gb)) {
3075
            /* skip mb */
3076
            s->mb_intra = 0;
3077
            for(i=0;i<6;i++)
3078
                s->block_last_index[i] = -1;
3079
            s->mv_dir = MV_DIR_FORWARD;
3080
            s->mv_type = MV_TYPE_16X16;
3081
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3082
                PRINT_MB_TYPE("G");
3083
                s->mcsel=1;
3084
                s->mv[0][0][0]= get_amv(s, 0);
3085
                s->mv[0][0][1]= get_amv(s, 1);
3086

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

    
3136
                s->field_select[0][0]= get_bits1(&s->gb);
3137
                s->field_select[0][1]= get_bits1(&s->gb);
3138

    
3139
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3140
                
3141
                for(i=0; i<2; i++){
3142
                    mx = h263_decode_motion(s, pred_x, s->f_code);
3143
                    if (mx >= 0xffff)
3144
                        return -1;
3145
            
3146
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
3147
                    if (my >= 0xffff)
3148
                        return -1;
3149

    
3150
                    s->mv[0][i][0] = mx;
3151
                    s->mv[0][i][1] = my;
3152
                }
3153
            }else{
3154
                PRINT_MB_TYPE("P");
3155
                /* 16x16 motion prediction */
3156
                s->mv_type = MV_TYPE_16X16;
3157
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3158
                if (s->umvplus)
3159
                   mx = h263p_decode_umotion(s, pred_x);
3160
                else
3161
                   mx = h263_decode_motion(s, pred_x, s->f_code);
3162
            
3163
                if (mx >= 0xffff)
3164
                    return -1;
3165
            
3166
                if (s->umvplus)
3167
                   my = h263p_decode_umotion(s, pred_y);
3168
                else
3169
                   my = h263_decode_motion(s, pred_y, s->f_code);
3170
            
3171
                if (my >= 0xffff)
3172
                    return -1;
3173
                s->mv[0][0][0] = mx;
3174
                s->mv[0][0][1] = my;
3175

    
3176
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3177
                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3178
            }
3179
        } else {
3180
            PRINT_MB_TYPE("4");
3181
            s->mv_type = MV_TYPE_8X8;
3182
            for(i=0;i<4;i++) {
3183
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3184
                if (s->umvplus)
3185
                  mx = h263p_decode_umotion(s, pred_x);
3186
                else
3187
                  mx = h263_decode_motion(s, pred_x, s->f_code);
3188
                if (mx >= 0xffff)
3189
                    return -1;
3190
                
3191
                if (s->umvplus)
3192
                  my = h263p_decode_umotion(s, pred_y);
3193
                else    
3194
                  my = h263_decode_motion(s, pred_y, s->f_code);
3195
                if (my >= 0xffff)
3196
                    return -1;
3197
                s->mv[0][i][0] = mx;
3198
                s->mv[0][i][1] = my;
3199
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3200
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3201
                mot_val[0] = mx;
3202
                mot_val[1] = my;
3203
            }
3204
        }
3205
    } else if(s->pict_type==B_TYPE) {
3206
        int modb1; // first bit of modb
3207
        int modb2; // second bit of modb
3208
        int mb_type;
3209

    
3210
        s->mb_intra = 0; //B-frames never contain intra blocks
3211
        s->mcsel=0;      //     ...               true gmc blocks
3212

    
3213
        if(s->mb_x==0){
3214
            for(i=0; i<2; i++){
3215
                s->last_mv[i][0][0]= 
3216
                s->last_mv[i][0][1]= 
3217
                s->last_mv[i][1][0]= 
3218
                s->last_mv[i][1][1]= 0;
3219
            }
3220
        }
3221

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

    
3225
        if(s->mb_skiped){
3226
                /* skip mb */
3227
            for(i=0;i<6;i++)
3228
                s->block_last_index[i] = -1;
3229

    
3230
            s->mv_dir = MV_DIR_FORWARD;
3231
            s->mv_type = MV_TYPE_16X16;
3232
            s->mv[0][0][0] = 0;
3233
            s->mv[0][0][1] = 0;
3234
            s->mv[1][0][0] = 0;
3235
            s->mv[1][0][1] = 0;
3236
            PRINT_MB_TYPE("s");
3237
            goto end;
3238
        }
3239

    
3240
        modb1= get_bits1(&s->gb); 
3241
        if(modb1){
3242
            mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
3243
            cbp=0;
3244
        }else{
3245
            int field_mv;
3246
        
3247
            modb2= get_bits1(&s->gb);
3248
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3249
            if(modb2) cbp= 0;
3250
            else      cbp= get_bits(&s->gb, 6);
3251

    
3252
            if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
3253
                if(get_bits1(&s->gb)){
3254
                    change_qscale(s, get_bits1(&s->gb)*4 - 2);
3255
                }
3256
            }
3257
            field_mv=0;
3258

    
3259
            if(!s->progressive_sequence){
3260
                if(cbp)
3261
                    s->interlaced_dct= get_bits1(&s->gb);
3262

    
3263
                if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
3264
                    field_mv=1;
3265

    
3266
                    if(mb_type!=MB_TYPE_B_BACKW){
3267
                        s->field_select[0][0]= get_bits1(&s->gb);
3268
                        s->field_select[0][1]= get_bits1(&s->gb);
3269
                    }
3270
                    if(mb_type!=MB_TYPE_B_FORW){
3271
                        s->field_select[1][0]= get_bits1(&s->gb);
3272
                        s->field_select[1][1]= get_bits1(&s->gb);
3273
                    }
3274
                }
3275
            }
3276

    
3277
            s->mv_dir = 0;
3278
            if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
3279
                s->mv_type= MV_TYPE_16X16;
3280
                if(mb_type!=MB_TYPE_B_BACKW){
3281
                    s->mv_dir = MV_DIR_FORWARD;
3282

    
3283
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3284
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3285
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3286
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3287
                }
3288
    
3289
                if(mb_type!=MB_TYPE_B_FORW){
3290
                    s->mv_dir |= MV_DIR_BACKWARD;
3291

    
3292
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3293
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3294
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3295
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3296
                }
3297
                if(mb_type!=MB_TYPE_B_DIRECT)
3298
                    PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "F" : (mb_type==MB_TYPE_B_BACKW ? "B" : "T"));
3299
            }else if(mb_type!=MB_TYPE_B_DIRECT){
3300
                s->mv_type= MV_TYPE_FIELD;
3301

    
3302
                if(mb_type!=MB_TYPE_B_BACKW){
3303
                    s->mv_dir = MV_DIR_FORWARD;
3304
                
3305
                    for(i=0; i<2; i++){
3306
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3307
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3308
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3309
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3310
                    }
3311
                }
3312
    
3313
                if(mb_type!=MB_TYPE_B_FORW){
3314
                    s->mv_dir |= MV_DIR_BACKWARD;
3315

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

    
3369
        /* decode each block */
3370
        if (s->h263_pred) {
3371
            for (i = 0; i < 6; i++) {
3372
                if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
3373
                    return -1;
3374
                cbp+=cbp;
3375
            }
3376
        } else {
3377
            for (i = 0; i < 6; i++) {
3378
                if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3379
                    return -1;
3380
                cbp+=cbp;
3381
            }
3382
        }
3383
        goto end;
3384
    }
3385

    
3386
    /* decode each block */
3387
    if (s->h263_pred) {
3388
        for (i = 0; i < 6; i++) {
3389
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
3390
                return -1;
3391
            cbp+=cbp;
3392
        }
3393
    } else {
3394
        for (i = 0; i < 6; i++) {
3395
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3396
                return -1;
3397
            cbp+=cbp;
3398
        }
3399
    }
3400
end:
3401

    
3402
        /* per-MB end of slice check */
3403
    if(s->codec_id==CODEC_ID_MPEG4){
3404
        if(mpeg4_is_resync(s)){
3405
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x+1])
3406
                return SLICE_OK;
3407
            return SLICE_END;
3408
        }
3409
    }else{
3410
        int v= show_bits(&s->gb, 16);
3411
    
3412
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3413
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3414
        }
3415

    
3416
        if(v==0)
3417
            return SLICE_END;
3418
    }
3419

    
3420
    return SLICE_OK;     
3421
}
3422

    
3423
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3424
{
3425
    int code, val, sign, shift, l;
3426
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3427
    if (code < 0)
3428
        return 0xffff;
3429

    
3430
    if (code == 0)
3431
        return pred;
3432

    
3433
    sign = get_bits1(&s->gb);
3434
    shift = f_code - 1;
3435
    val = (code - 1) << shift;
3436
    if (shift > 0)
3437
        val |= get_bits(&s->gb, shift);
3438
    val++;
3439
    if (sign)
3440
        val = -val;
3441
    val += pred;
3442

    
3443
    /* modulo decoding */
3444
    if (!s->h263_long_vectors) {
3445
        l = 1 << (f_code + 4);
3446
        if (val < -l) {
3447
            val += l<<1;
3448
        } else if (val >= l) {
3449
            val -= l<<1;
3450
        }
3451
    } else {
3452
        /* horrible h263 long vector mode */
3453
        if (pred < -31 && val < -63)
3454
            val += 64;
3455
        if (pred > 32 && val > 63)
3456
            val -= 64;
3457
        
3458
    }
3459
    return val;
3460
}
3461

    
3462
/* Decodes RVLC of H.263+ UMV */
3463
static int h263p_decode_umotion(MpegEncContext * s, int pred)
3464
{
3465
   int code = 0, sign;
3466
   
3467
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
3468
      return pred;
3469
   
3470
   code = 2 + get_bits1(&s->gb);
3471
   
3472
   while (get_bits1(&s->gb))
3473
   {
3474
      code <<= 1;
3475
      code += get_bits1(&s->gb);
3476
   }
3477
   sign = code & 1;
3478
   code >>= 1;
3479
   
3480
   code = (sign) ? (pred - code) : (pred + code);
3481
#ifdef DEBUG
3482
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3483
#endif
3484
   return code;   
3485

    
3486
}
3487

    
3488
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3489
                             int n, int coded)
3490
{
3491
    int code, level, i, j, last, run;
3492
    RLTable *rl = &rl_inter;
3493
    const uint8_t *scan_table;
3494

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

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

    
3595
/**
3596
 * decodes the dc value.
3597
 * @param n block index (0-3 are luma, 4-5 are chroma)
3598
 * @param dir_ptr the prediction direction will be stored here
3599
 * @return the quantized dc
3600
 */
3601
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3602
{
3603
    int level, pred, code;
3604
    uint16_t *dc_val;
3605

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

    
3652
/**
3653
 * decodes a block.
3654
 * @return <0 if an error occured
3655
 */
3656
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3657
                              int n, int coded, int intra, int rvlc)
3658
{
3659
    int level, i, last, run;
3660
    int dc_pred_dir;
3661
    RLTable * rl;
3662
    RL_VLC_ELEM * rl_vlc;
3663
    const uint8_t * scan_table;
3664
    int qmul, qadd;
3665

    
3666
    //Note intra & rvlc should be optimized away if this is inlined
3667
    
3668
    if(intra) {
3669
        /* DC coef */
3670
        if(s->partitioned_frame){
3671
            level = s->dc_val[0][ s->block_index[n] ];
3672
            if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
3673
            else    level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
3674
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
3675
        }else{
3676
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3677
            if (level < 0)
3678
                return -1;
3679
        }
3680
        block[0] = level;
3681
        i = 0;
3682
        if (!coded) 
3683
            goto not_coded;
3684
        
3685
        if(rvlc){        
3686
            rl = &rvlc_rl_intra;
3687
            rl_vlc = rvlc_rl_intra.rl_vlc[0];
3688
        }else{
3689
            rl = &rl_intra;
3690
            rl_vlc = rl_intra.rl_vlc[0];
3691
        }
3692
        if (s->ac_pred) {
3693
            if (dc_pred_dir == 0) 
3694
                scan_table = s->intra_v_scantable.permutated; /* left */
3695
            else
3696
                scan_table = s->intra_h_scantable.permutated; /* top */
3697
        } else {
3698
            scan_table = s->intra_scantable.permutated;
3699
        }
3700
        qmul=1;
3701
        qadd=0;
3702
    } else {
3703
        i = -1;
3704
        if (!coded) {
3705
            s->block_last_index[n] = i;
3706
            return 0;
3707
        }
3708
        if(rvlc) rl = &rvlc_rl_inter;
3709
        else     rl = &rl_inter;
3710
   
3711
        scan_table = s->intra_scantable.permutated;
3712

    
3713
        if(s->mpeg_quant){
3714
            qmul=1;
3715
            qadd=0;
3716
            if(rvlc){        
3717
                rl_vlc = rvlc_rl_inter.rl_vlc[0];        
3718
            }else{
3719
                rl_vlc = rl_inter.rl_vlc[0];        
3720
            }
3721
        }else{
3722
            qmul = s->qscale << 1;
3723
            qadd = (s->qscale - 1) | 1;
3724
            if(rvlc){        
3725
                rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];        
3726
            }else{
3727
                rl_vlc = rl_inter.rl_vlc[s->qscale];        
3728
            }
3729
        }
3730
    }
3731
  {
3732
    OPEN_READER(re, &s->gb);
3733
    for(;;) {
3734
        UPDATE_CACHE(re, &s->gb);
3735
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3736
        if (level==0) {
3737
          /* escape */                
3738
          if(rvlc){
3739
                if(SHOW_UBITS(re, &s->gb, 1)==0){
3740
                    fprintf(stderr, "1. marker bit missing in rvlc esc\n");
3741
                    return -1;
3742
                }; SKIP_CACHE(re, &s->gb, 1);
3743
 
3744
                last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3745
                run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3746
                SKIP_COUNTER(re, &s->gb, 1+1+6);
3747
                UPDATE_CACHE(re, &s->gb);
3748
              
3749
                if(SHOW_UBITS(re, &s->gb, 1)==0){
3750
                    fprintf(stderr, "2. marker bit missing in rvlc esc\n");
3751
                    return -1;
3752
                }; SKIP_CACHE(re, &s->gb, 1);
3753
 
3754
                level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
3755
 
3756
                if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
3757
                    fprintf(stderr, "reverse esc missing\n");
3758
                    return -1;
3759
                }; SKIP_CACHE(re, &s->gb, 5);
3760

    
3761
                level=  level * qmul + qadd;
3762
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
3763
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
3764

    
3765
                i+= run + 1;
3766
                if(last) i+=192;    
3767
          }else{
3768
            int cache;
3769
            cache= GET_CACHE(re, &s->gb);
3770
            if (cache&0x80000000) {
3771
                if (cache&0x40000000) {
3772
                    /* third escape */
3773
                    SKIP_CACHE(re, &s->gb, 2);
3774
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3775
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3776
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
3777
                    UPDATE_CACHE(re, &s->gb);
3778

    
3779
                    if(SHOW_UBITS(re, &s->gb, 1)==0){
3780
                        fprintf(stderr, "1. marker bit missing in 3. esc\n");
3781
                        return -1;
3782
                    }; SKIP_CACHE(re, &s->gb, 1);
3783
                    
3784
                    level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3785
 
3786
                    if(SHOW_UBITS(re, &s->gb, 1)==0){
3787
                        fprintf(stderr, "2. marker bit missing in 3. esc\n");
3788
                        return -1;
3789
                    }; LAST_SKIP_CACHE(re, &s->gb, 1);
3790
                    
3791
                    SKIP_COUNTER(re, &s->gb, 1+12+1);
3792
                    
3793
                    if(level*s->qscale>1024 || level*s->qscale<-1024){
3794
                        fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3795
                        return -1;
3796
                    }
3797
#if 1 
3798
                    {
3799
                        const int abs_level= ABS(level);
3800
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
3801
                            const int run1= run - rl->max_run[last][abs_level] - 1;
3802
                            if(abs_level <= rl->max_level[last][run]){
3803
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3804
                                return -1;
3805
                            }
3806
                            if(s->error_resilience > FF_ER_COMPLIANT){
3807
                                if(abs_level <= rl->max_level[last][run]*2){
3808
                                    fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3809
                                    return -1;
3810
                                }
3811
                                if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3812
                                    fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3813
                                    return -1;
3814
                                }
3815
                            }
3816
                        }
3817
                    }
3818
#endif
3819
                    if (level>0) level= level * qmul + qadd;
3820
                    else         level= level * qmul - qadd;
3821

    
3822
                    i+= run + 1;
3823
                    if(last) i+=192;
3824
                } else {
3825
                    /* second escape */
3826
#if MIN_CACHE_BITS < 20
3827
                    LAST_SKIP_BITS(re, &s->gb, 2);
3828
                    UPDATE_CACHE(re, &s->gb);
3829
#else
3830
                    SKIP_BITS(re, &s->gb, 2);
3831
#endif
3832
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3833
                    i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3834
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3835
                    LAST_SKIP_BITS(re, &s->gb, 1);
3836
                }
3837
            } else {
3838
                /* first escape */
3839
#if MIN_CACHE_BITS < 19
3840
                LAST_SKIP_BITS(re, &s->gb, 1);
3841
                UPDATE_CACHE(re, &s->gb);
3842
#else
3843
                SKIP_BITS(re, &s->gb, 1);
3844
#endif
3845
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3846
                i+= run;
3847
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3848
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3849
                LAST_SKIP_BITS(re, &s->gb, 1);
3850
            }
3851
          }
3852
        } else {
3853
            i+= run;
3854
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3855
            LAST_SKIP_BITS(re, &s->gb, 1);
3856
        }
3857
        if (i > 62){
3858
            i-= 192;
3859
            if(i&(~63)){
3860
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3861
                return -1;
3862
            }
3863

    
3864
            block[scan_table[i]] = level;
3865
            break;
3866
        }
3867

    
3868
        block[scan_table[i]] = level;
3869
    }
3870
    CLOSE_READER(re, &s->gb);
3871
  }
3872
 not_coded:
3873
    if (s->mb_intra) {
3874
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
3875
        if (s->ac_pred) {
3876
            i = 63; /* XXX: not optimal */
3877
        }
3878
    }
3879
    s->block_last_index[n] = i;
3880
    return 0;
3881
}
3882

    
3883
/* most is hardcoded. should extend to handle all h263 streams */
3884
int h263_decode_picture_header(MpegEncContext *s)
3885
{
3886
    int format, width, height;
3887

    
3888
    /* picture start code */
3889
    if (get_bits(&s->gb, 22) != 0x20) {
3890
        fprintf(stderr, "Bad picture start code\n");
3891
        return -1;
3892
    }
3893
    /* temporal reference */
3894
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3895

    
3896
    /* PTYPE starts here */    
3897
    if (get_bits1(&s->gb) != 1) {
3898
        /* marker */
3899
        fprintf(stderr, "Bad marker\n");
3900
        return -1;
3901
    }
3902
    if (get_bits1(&s->gb) != 0) {
3903
        fprintf(stderr, "Bad H263 id\n");
3904
        return -1;        /* h263 id */
3905
    }
3906
    skip_bits1(&s->gb);        /* split screen off */
3907
    skip_bits1(&s->gb);        /* camera  off */
3908
    skip_bits1(&s->gb);        /* freeze picture release off */
3909

    
3910
    /* Reset GOB number */
3911
    s->gob_number = 0;
3912
        
3913
    format = get_bits(&s->gb, 3);
3914
    /*
3915
        0    forbidden
3916
        1    sub-QCIF
3917
        10   QCIF
3918
        7        extended PTYPE (PLUSPTYPE)
3919
    */
3920

    
3921
    if (format != 7 && format != 6) {
3922
        s->h263_plus = 0;
3923
        /* H.263v1 */
3924
        width = h263_format[format][0];
3925
        height = h263_format[format][1];
3926
        if (!width)
3927
            return -1;
3928
        
3929
        s->width = width;
3930
        s->height = height;
3931
        s->pict_type = I_TYPE + get_bits1(&s->gb);
3932

    
3933
        s->unrestricted_mv = get_bits1(&s->gb); 
3934
        s->h263_long_vectors = s->unrestricted_mv;
3935

    
3936
        if (get_bits1(&s->gb) != 0) {
3937
            fprintf(stderr, "H263 SAC not supported\n");
3938
            return -1;        /* SAC: off */
3939
        }
3940
        if (get_bits1(&s->gb) != 0) {
3941
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3942
        }   
3943
        
3944
        if (get_bits1(&s->gb) != 0) {
3945
            fprintf(stderr, "H263 PB frame not supported\n");
3946
            return -1;        /* not PB frame */
3947
        }
3948
        s->qscale = get_bits(&s->gb, 5);
3949
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
3950
    } else {
3951
        int ufep;
3952
        
3953
        /* H.263v2 */
3954
        s->h263_plus = 1;
3955
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3956

    
3957
        /* ufep other than 0 and 1 are reserved */        
3958
        if (ufep == 1) {
3959
            /* OPPTYPE */       
3960
            format = get_bits(&s->gb, 3);
3961
            dprintf("ufep=1, format: %d\n", format);
3962
            skip_bits(&s->gb,1); /* Custom PCF */
3963
            s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3964
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3965
            if (get_bits1(&s->gb) != 0) {
3966
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3967
            }
3968
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3969
                s->h263_aic = 1;
3970
            }
3971
            
3972
            skip_bits(&s->gb, 7);
3973
            /* these are the 7 bits: (in order of appearence  */
3974
            /* Deblocking Filter */
3975
            /* Slice Structured */
3976
            /* Reference Picture Selection */
3977
            /* Independent Segment Decoding */
3978
            /* Alternative Inter VLC */
3979
            /* Modified Quantization */
3980
            /* Prevent start code emulation */
3981

    
3982
            skip_bits(&s->gb, 3); /* Reserved */
3983
        } else if (ufep != 0) {
3984
            fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3985
            return -1;
3986
        }
3987
            
3988
        /* MPPTYPE */
3989
        s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3990
        dprintf("pict_type: %d\n", s->pict_type);
3991
        if (s->pict_type != I_TYPE &&
3992
            s->pict_type != P_TYPE)
3993
            return -1;
3994
        skip_bits(&s->gb, 2);
3995
        s->no_rounding = get_bits1(&s->gb);
3996
        dprintf("RTYPE: %d\n", s->no_rounding);
3997
        skip_bits(&s->gb, 4);
3998
        
3999
        /* Get the picture dimensions */
4000
        if (ufep) {
4001
            if (format == 6) {
4002
                /* Custom Picture Format (CPFMT) */
4003
                s->aspect_ratio_info = get_bits(&s->gb, 4);
4004
                dprintf("aspect: %d\n", s->aspect_ratio_info);
4005
                /* aspect ratios:
4006
                0 - forbidden
4007
                1 - 1:1
4008
                2 - 12:11 (CIF 4:3)
4009
                3 - 10:11 (525-type 4:3)
4010
                4 - 16:11 (CIF 16:9)
4011
                5 - 40:33 (525-type 16:9)
4012
                6-14 - reserved
4013
                */
4014
                width = (get_bits(&s->gb, 9) + 1) * 4;
4015
                skip_bits1(&s->gb);
4016
                height = get_bits(&s->gb, 9) * 4;
4017
                dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
4018
                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
4019
                    /* aspected dimensions */
4020
                    s->aspected_width = get_bits(&s->gb, 8);
4021
                    s->aspected_height = get_bits(&s->gb, 8);
4022
                }else{
4023
                    s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4024
                    s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4025
                }
4026
            } else {
4027
                width = h263_format[format][0];
4028
                height = h263_format[format][1];
4029
            }
4030
            if ((width == 0) || (height == 0))
4031
                return -1;
4032
            s->width = width;
4033
            s->height = height;
4034
            if (s->umvplus) {
4035
                if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
4036
                    skip_bits1(&s->gb); 
4037
            }
4038
        }
4039
            
4040
        s->qscale = get_bits(&s->gb, 5);
4041
    }
4042
    /* PEI */
4043
    while (get_bits1(&s->gb) != 0) {
4044
        skip_bits(&s->gb, 8);
4045
    }
4046
    s->f_code = 1;
4047
    
4048
    if(s->h263_aic){
4049
         s->y_dc_scale_table= 
4050
         s->c_dc_scale_table= h263_aic_dc_scale_table;
4051
    }else{
4052
        s->y_dc_scale_table=
4053
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4054
    }
4055

    
4056
    return 0;
4057
}
4058

    
4059
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
4060
{
4061
    int i;
4062
    int a= 2<<s->sprite_warping_accuracy;
4063
    int rho= 3-s->sprite_warping_accuracy;
4064
    int r=16/a;
4065
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
4066
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
4067
    int sprite_ref[4][2];
4068
    int virtual_ref[2][2];
4069
    int w2, h2, w3, h3;
4070
    int alpha=0, beta=0;
4071
    int w= s->width;
4072
    int h= s->height;
4073
    int min_ab;
4074

    
4075
    for(i=0; i<s->num_sprite_warping_points; i++){
4076
        int length;
4077
        int x=0, y=0;
4078

    
4079
        length= get_vlc(&s->gb, &sprite_trajectory);
4080
        if(length){
4081
            x= get_bits(&s->gb, length);
4082

    
4083
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
4084
                x = - (x ^ ((1 << length) - 1));
4085
        }
4086
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4087
        
4088
        length= get_vlc(&s->gb, &sprite_trajectory);
4089
        if(length){
4090
            y=get_bits(&s->gb, length);
4091

    
4092
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
4093
                y = - (y ^ ((1 << length) - 1));
4094
        }
4095
        skip_bits1(&s->gb); /* marker bit */
4096
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4097
        d[i][0]= x;
4098
        d[i][1]= y;
4099
    }
4100

    
4101
    while((1<<alpha)<w) alpha++;
4102
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
4103
    w2= 1<<alpha;
4104
    h2= 1<<beta;
4105

    
4106
// Note, the 4th point isnt used for GMC
4107
    if(s->divx_version==500 && s->divx_build==413){
4108
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
4109
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
4110
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
4111
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
4112
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
4113
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
4114
    } else {
4115
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
4116
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
4117
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
4118
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
4119
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
4120
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
4121
    }
4122
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
4123
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
4124
    
4125
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
4126
// perhaps it should be reordered to be more readable ...
4127
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
4128
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
4129
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
4130
        + 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);
4131
    virtual_ref[0][1]= 16*vop_ref[0][1] 
4132
        + 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);
4133
    virtual_ref[1][0]= 16*vop_ref[0][0] 
4134
        + 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);
4135
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
4136
        + 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);
4137
        
4138
    switch(s->num_sprite_warping_points)
4139
    {
4140
        case 0:
4141
            s->sprite_offset[0][0]= 0;
4142
            s->sprite_offset[0][1]= 0;
4143
            s->sprite_offset[1][0]= 0;
4144
            s->sprite_offset[1][1]= 0;
4145
            s->sprite_delta[0][0]= a;
4146
            s->sprite_delta[0][1]= 0;
4147
            s->sprite_delta[1][0]= 0;
4148
            s->sprite_delta[1][1]= a;
4149
            s->sprite_shift[0]= 0;
4150
            s->sprite_shift[1]= 0;
4151
            break;
4152
        case 1: //GMC only
4153
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
4154
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
4155
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
4156
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
4157
            s->sprite_delta[0][0]= a;
4158
            s->sprite_delta[0][1]= 0;
4159
            s->sprite_delta[1][0]= 0;
4160
            s->sprite_delta[1][1]= a;
4161
            s->sprite_shift[0]= 0;
4162
            s->sprite_shift[1]= 0;
4163
            break;
4164
        case 2:
4165
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
4166
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
4167
                                                  + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
4168
                                                  + (1<<(alpha+rho-1));
4169
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
4170
                                                  + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
4171
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
4172
                                                  + (1<<(alpha+rho-1));
4173
            s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
4174
                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
4175
                                     +2*w2*r*sprite_ref[0][0] 
4176
                                     - 16*w2 
4177
                                     + (1<<(alpha+rho+1)));
4178
            s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
4179
                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
4180
                                     +2*w2*r*sprite_ref[0][1] 
4181
                                     - 16*w2
4182
                                     + (1<<(alpha+rho+1)));
4183
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4184
            s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
4185
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
4186
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4187
            
4188
            s->sprite_shift[0]= alpha+rho;
4189
            s->sprite_shift[1]= alpha+rho+2;
4190
            break;
4191
        case 3:
4192
            min_ab= FFMIN(alpha, beta);
4193
            w3= w2>>min_ab;
4194
            h3= h2>>min_ab;
4195
            s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
4196
                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
4197
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
4198
                                   + (1<<(alpha+beta+rho-min_ab-1));
4199
            s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
4200
                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
4201
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
4202
                                   + (1<<(alpha+beta+rho-min_ab-1));
4203
            s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
4204
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
4205
                                   + 2*w2*h3*r*sprite_ref[0][0]
4206
                                   - 16*w2*h3
4207
                                   + (1<<(alpha+beta+rho-min_ab+1));
4208
            s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4209
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4210
                                   + 2*w2*h3*r*sprite_ref[0][1]
4211
                                   - 16*w2*h3
4212
                                   + (1<<(alpha+beta+rho-min_ab+1));
4213
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4214
            s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4215
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4216
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4217
                                   
4218
            s->sprite_shift[0]= alpha + beta + rho - min_ab;
4219
            s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4220
            break;
4221
    }
4222
    /* try to simplify the situation */ 
4223
    if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4224
       && s->sprite_delta[0][1] == 0
4225
       && s->sprite_delta[1][0] == 0
4226
       && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4227
    {
4228
        s->sprite_offset[0][0]>>=s->sprite_shift[0];
4229
        s->sprite_offset[0][1]>>=s->sprite_shift[0];
4230
        s->sprite_offset[1][0]>>=s->sprite_shift[1];
4231
        s->sprite_offset[1][1]>>=s->sprite_shift[1];
4232
        s->sprite_delta[0][0]= a;
4233
        s->sprite_delta[0][1]= 0;
4234
        s->sprite_delta[1][0]= 0;
4235
        s->sprite_delta[1][1]= a;
4236
        s->sprite_shift[0]= 0;
4237
        s->sprite_shift[1]= 0;
4238
        s->real_sprite_warping_points=1;
4239
    }
4240
    else{
4241
        int shift_y= 16 - s->sprite_shift[0];
4242
        int shift_c= 16 - s->sprite_shift[1];
4243
//printf("shifts %d %d\n", shift_y, shift_c);
4244
        for(i=0; i<2; i++){
4245
            s->sprite_offset[0][i]<<= shift_y;
4246
            s->sprite_offset[1][i]<<= shift_c;
4247
            s->sprite_delta[0][i]<<= shift_y;
4248
            s->sprite_delta[1][i]<<= shift_y;
4249
            s->sprite_shift[i]= 16;
4250
        }
4251
        s->real_sprite_warping_points= s->num_sprite_warping_points;
4252
    }
4253
#if 0
4254
printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4255
    vop_ref[0][0], vop_ref[0][1],
4256
    vop_ref[1][0], vop_ref[1][1],
4257
    vop_ref[2][0], vop_ref[2][1],
4258
    sprite_ref[0][0], sprite_ref[0][1], 
4259
    sprite_ref[1][0], sprite_ref[1][1], 
4260
    sprite_ref[2][0], sprite_ref[2][1], 
4261
    virtual_ref[0][0], virtual_ref[0][1], 
4262
    virtual_ref[1][0], virtual_ref[1][1]
4263
    );
4264
    
4265
printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4266
    s->sprite_offset[0][0], s->sprite_offset[0][1],
4267
    s->sprite_delta[0][0], s->sprite_delta[0][1],
4268
    s->sprite_delta[1][0], s->sprite_delta[1][1],
4269
    s->sprite_shift[0]
4270
    );
4271
#endif
4272
}
4273

    
4274
static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
4275
    int hours, minutes, seconds;
4276

    
4277
    hours= get_bits(gb, 5);
4278
    minutes= get_bits(gb, 6);
4279
    skip_bits1(gb);
4280
    seconds= get_bits(gb, 6);
4281

    
4282
    s->time_base= seconds + 60*(minutes + 60*hours);
4283

    
4284
    skip_bits1(gb);
4285
    skip_bits1(gb);
4286
    
4287
    return 0;
4288
}
4289

    
4290
static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4291
    int width, height, vo_ver_id;
4292

    
4293
    /* vol header */
4294
    skip_bits(gb, 1); /* random access */
4295
    s->vo_type= get_bits(gb, 8);
4296
    if (get_bits1(gb) != 0) { /* is_ol_id */
4297
        vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4298
        skip_bits(gb, 3); /* vo_priority */
4299
    } else {
4300
        vo_ver_id = 1;
4301
    }
4302
//printf("vo type:%d\n",s->vo_type);
4303
    s->aspect_ratio_info= get_bits(gb, 4);
4304
    if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){            
4305
        s->aspected_width = get_bits(gb, 8); // par_width
4306
        s->aspected_height = get_bits(gb, 8); // par_height
4307
    }else{
4308
        s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4309
        s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4310
    }
4311

    
4312
    if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4313
        int chroma_format= get_bits(gb, 2);
4314
        if(chroma_format!=1){
4315
            printf("illegal chroma format\n");
4316
        }
4317
        s->low_delay= get_bits1(gb);
4318
        if(get_bits1(gb)){ /* vbv parameters */
4319
            get_bits(gb, 15);        /* first_half_bitrate */
4320
            skip_bits1(gb);        /* marker */
4321
            get_bits(gb, 15);        /* latter_half_bitrate */
4322
            skip_bits1(gb);        /* marker */
4323
            get_bits(gb, 15);        /* first_half_vbv_buffer_size */
4324
            skip_bits1(gb);        /* marker */
4325
            get_bits(gb, 3);        /* latter_half_vbv_buffer_size */
4326
            get_bits(gb, 11);        /* first_half_vbv_occupancy */
4327
            skip_bits1(gb);        /* marker */
4328
            get_bits(gb, 15);        /* latter_half_vbv_occupancy */
4329
            skip_bits1(gb);        /* marker */               
4330
        }
4331
    }else{
4332
        // set low delay flag only once so the smart? low delay detection wont be overriden
4333
        if(s->picture_number==0)
4334
            s->low_delay=0;
4335
    }
4336

    
4337
    s->shape = get_bits(gb, 2); /* vol shape */
4338
    if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4339
    if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4340
        printf("Gray shape not supported\n");
4341
        skip_bits(gb, 4);  //video_object_layer_shape_extension
4342
    }
4343

    
4344
    skip_bits1(gb);   /* marker */
4345
    
4346
    s->time_increment_resolution = get_bits(gb, 16);
4347
    
4348
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4349
    if (s->time_increment_bits < 1)
4350
        s->time_increment_bits = 1;
4351
    skip_bits1(gb);   /* marker */
4352

    
4353
    if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
4354
        skip_bits(gb, s->time_increment_bits);
4355
    }
4356

    
4357
    if (s->shape != BIN_ONLY_SHAPE) {
4358
        if (s->shape == RECT_SHAPE) {
4359
            skip_bits1(gb);   /* marker */
4360
            width = get_bits(gb, 13);
4361
            skip_bits1(gb);   /* marker */
4362
            height = get_bits(gb, 13);
4363
            skip_bits1(gb);   /* marker */
4364
            if(width && height){ /* they should be non zero but who knows ... */
4365
                s->width = width;
4366
                s->height = height;
4367
//                printf("width/height: %d %d\n", width, height);
4368
            }
4369
        }
4370
        
4371
        s->progressive_sequence= get_bits1(gb)^1;
4372
        if(!get_bits1(gb)) printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
4373
        if (vo_ver_id == 1) {
4374
            s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4375
        } else {
4376
            s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4377
        }
4378
        if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4379
        if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4380
            if(s->vol_sprite_usage==STATIC_SPRITE){
4381
                s->sprite_width = get_bits(gb, 13);
4382
                skip_bits1(gb); /* marker */
4383
                s->sprite_height= get_bits(gb, 13);
4384
                skip_bits1(gb); /* marker */
4385
                s->sprite_left  = get_bits(gb, 13);
4386
                skip_bits1(gb); /* marker */
4387
                s->sprite_top   = get_bits(gb, 13);
4388
                skip_bits1(gb); /* marker */
4389
            }
4390
            s->num_sprite_warping_points= get_bits(gb, 6);
4391
            s->sprite_warping_accuracy = get_bits(gb, 2);
4392
            s->sprite_brightness_change= get_bits1(gb);
4393
            if(s->vol_sprite_usage==STATIC_SPRITE)
4394
                s->low_latency_sprite= get_bits1(gb);            
4395
        }
4396
        // FIXME sadct disable bit if verid!=1 && shape not rect
4397
        
4398
        if (get_bits1(gb) == 1) {   /* not_8_bit */
4399
            s->quant_precision = get_bits(gb, 4); /* quant_precision */
4400
            if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4401
            if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4402
        } else {
4403
            s->quant_precision = 5;
4404
        }
4405
        
4406
        // FIXME a bunch of grayscale shape things
4407

    
4408
        if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4409
            int i, v;
4410
            
4411
            /* load default matrixes */
4412
            for(i=0; i<64; i++){
4413
                int j= s->dsp.idct_permutation[i];
4414
                v= ff_mpeg4_default_intra_matrix[i];
4415
                s->intra_matrix[j]= v;
4416
                s->chroma_intra_matrix[j]= v;
4417
                
4418
                v= ff_mpeg4_default_non_intra_matrix[i];
4419
                s->inter_matrix[j]= v;
4420
                s->chroma_inter_matrix[j]= v;
4421
            }
4422

    
4423
            /* load custom intra matrix */
4424
            if(get_bits1(gb)){
4425
                int last=0;
4426
                for(i=0; i<64; i++){
4427
                    int j;
4428
                    v= get_bits(gb, 8);
4429
                    if(v==0) break;
4430
                    
4431
                    last= v;
4432
                    j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4433
                    s->intra_matrix[j]= v;
4434
                    s->chroma_intra_matrix[j]= v;
4435
                }
4436

    
4437
                /* replicate last value */
4438
                for(; i<64; i++){
4439
                    int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4440
                    s->intra_matrix[j]= v;
4441
                    s->chroma_intra_matrix[j]= v;
4442
                }
4443
            }
4444

    
4445
            /* load custom non intra matrix */
4446
            if(get_bits1(gb)){
4447
                int last=0;
4448
                for(i=0; i<64; i++){
4449
                    int j;
4450
                    v= get_bits(gb, 8);
4451
                    if(v==0) break;
4452

    
4453
                    last= v;
4454
                    j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4455
                    s->inter_matrix[j]= v;
4456
                    s->chroma_inter_matrix[j]= v;
4457
                }
4458

    
4459
                /* replicate last value */
4460
                for(; i<64; i++){
4461
                    int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4462
                    s->inter_matrix[j]= last;
4463
                    s->chroma_inter_matrix[j]= last;
4464
                }
4465
            }
4466

    
4467
            // FIXME a bunch of grayscale shape things
4468
        }
4469

    
4470
        if(vo_ver_id != 1)
4471
             s->quarter_sample= get_bits1(gb);
4472
        else s->quarter_sample=0;
4473

    
4474
        if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4475

    
4476
        s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4477

    
4478
        s->data_partitioning= get_bits1(gb);
4479
        if(s->data_partitioning){
4480
            s->rvlc= get_bits1(gb);
4481
        }
4482
        
4483
        if(vo_ver_id != 1) {
4484
            s->new_pred= get_bits1(gb);
4485
            if(s->new_pred){
4486
                printf("new pred not supported\n");
4487
                skip_bits(gb, 2); /* requested upstream message type */
4488
                skip_bits1(gb); /* newpred segment type */
4489
            }
4490
            s->reduced_res_vop= get_bits1(gb);
4491
            if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4492
        }
4493
        else{
4494
            s->new_pred=0;
4495
            s->reduced_res_vop= 0;
4496
        }
4497

    
4498
        s->scalability= get_bits1(gb);
4499

    
4500
        if (s->scalability) {
4501
            GetBitContext bak= *gb;
4502
            int ref_layer_id;
4503
            int ref_layer_sampling_dir;
4504
            int h_sampling_factor_n;
4505
            int h_sampling_factor_m;
4506
            int v_sampling_factor_n;
4507
            int v_sampling_factor_m;
4508
            
4509
            s->hierachy_type= get_bits1(gb);
4510
            ref_layer_id= get_bits(gb, 4);
4511
            ref_layer_sampling_dir= get_bits1(gb);
4512
            h_sampling_factor_n= get_bits(gb, 5);
4513
            h_sampling_factor_m= get_bits(gb, 5);
4514
            v_sampling_factor_n= get_bits(gb, 5);
4515
            v_sampling_factor_m= get_bits(gb, 5);
4516
            s->enhancement_type= get_bits1(gb);
4517
            
4518
            if(   h_sampling_factor_n==0 || h_sampling_factor_m==0 
4519
               || v_sampling_factor_n==0 || v_sampling_factor_m==0){
4520
               
4521
//                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4522
                s->scalability=0;
4523
               
4524
                *gb= bak;
4525
            }else
4526
                printf("scalability not supported\n");
4527
            
4528
            // bin shape stuff FIXME
4529
        }
4530
    }
4531
    return 0;
4532
}
4533

    
4534
/**
4535
 * decodes the user data stuff in the header.
4536
 * allso inits divx/xvid/lavc_version/build
4537
 */
4538
static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
4539
    char buf[256];
4540
    int i;
4541
    int e;
4542
    int ver, build, ver2, ver3;
4543
    char last;
4544

    
4545
    buf[0]= show_bits(gb, 8);
4546
    for(i=1; i<256; i++){
4547
        buf[i]= show_bits(gb, 16)&0xFF;
4548
        if(buf[i]==0) break;
4549
        skip_bits(gb, 8);
4550
    }
4551
    buf[255]=0;
4552

    
4553
    /* divx detection */
4554
    e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
4555
    if(e<2)
4556
        e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
4557
    if(e>=2){
4558
        s->divx_version= ver;
4559
        s->divx_build= build;
4560
        s->divx_packed= e==3 && last=='p';
4561
        if(s->picture_number==0){
4562
            printf("This file was encoded with DivX%d Build%d", ver, build);
4563
            if(s->divx_packed)
4564
                printf("p\n");
4565
            else
4566
                printf("\n");
4567
        }
4568
    }
4569
    
4570
    /* ffmpeg detection */
4571
    e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
4572
    if(e!=4)
4573
        e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); 
4574
    if(e!=4){
4575
        if(strcmp(buf, "ffmpeg")==0){
4576
            s->ffmpeg_version= 0x000406;
4577
            s->lavc_build= 4600;
4578
        }
4579
    }
4580
    if(e==4){
4581
        s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
4582
        s->lavc_build= build;
4583
        if(s->picture_number==0)
4584
            printf("This file was encoded with libavcodec build %d\n", build);
4585
    }
4586
    
4587
    /* xvid detection */
4588
    e=sscanf(buf, "XviD%d", &build);
4589
    if(e==1){
4590
        s->xvid_build= build;
4591
        if(s->picture_number==0)
4592
            printf("This file was encoded with XviD build %d\n", build);
4593
    }
4594

    
4595
//printf("User Data: %s\n", buf);
4596
    return 0;
4597
}
4598

    
4599
static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
4600
    int time_incr, time_increment;
4601

    
4602
    s->pict_type = get_bits(gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
4603
    if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
4604
        printf("low_delay flag set, but shouldnt, clearing it\n");
4605
        s->low_delay=0;
4606
    }
4607
 
4608
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
4609
    if(s->partitioned_frame)
4610
        s->decode_mb= mpeg4_decode_partitioned_mb;
4611
    else
4612
        s->decode_mb= ff_h263_decode_mb;
4613

    
4614
    if(s->time_increment_resolution==0){
4615
        s->time_increment_resolution=1;
4616
//        fprintf(stderr, "time_increment_resolution is illegal\n");
4617
    }
4618
    time_incr=0;
4619
    while (get_bits1(gb) != 0) 
4620
        time_incr++;
4621

    
4622
    check_marker(gb, "before time_increment");
4623
    
4624
    if(s->picture_number==0 && (show_bits(gb, s->time_increment_bits+1)&1)==0){
4625
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4626
        
4627

    
4628
        for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
4629
            if(show_bits(gb, s->time_increment_bits+1)&1) break;
4630
        }
4631
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
4632
    }
4633
    
4634
    time_increment= get_bits(gb, s->time_increment_bits);
4635
//printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4636
    if(s->pict_type!=B_TYPE){
4637
        s->last_time_base= s->time_base;
4638
        s->time_base+= time_incr;
4639
        s->time= s->time_base*s->time_increment_resolution + time_increment;
4640
        if(s->workaround_bugs&FF_BUG_UMP4){
4641
            if(s->time < s->last_non_b_time){
4642
//                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4643
                s->time_base++;
4644
                s->time+= s->time_increment_resolution;
4645
            }
4646
        }
4647
        s->pp_time= s->time - s->last_non_b_time;
4648
        s->last_non_b_time= s->time;
4649
    }else{
4650
        s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4651
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4652
        if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4653
//            printf("messed up order, seeking?, skiping current b frame\n");
4654
            return FRAME_SKIPED;
4655
        }
4656
        
4657
        if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4658
        if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4659
//printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4660
        s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame) 
4661
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4662
        s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame) 
4663
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4664
    }
4665
    
4666
    s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4667
    if(s->avctx->debug&FF_DEBUG_PTS)
4668
        printf("MPEG4 PTS: %f\n", s->current_picture.pts/(1000.0*1000.0));
4669
    
4670
    check_marker(gb, "before vop_coded");
4671
    
4672
    /* vop coded */
4673
    if (get_bits1(gb) != 1){
4674
        printf("vop not coded\n");
4675
        return FRAME_SKIPED;
4676
    }
4677
//printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4678
//s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);  
4679
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4680
                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4681
        /* rounding type for motion estimation */
4682
        s->no_rounding = get_bits1(gb);
4683
    } else {
4684
        s->no_rounding = 0;
4685
    }
4686
//FIXME reduced res stuff
4687

    
4688
     if (s->shape != RECT_SHAPE) {
4689
         if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4690
             int width, height