Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 46b4feec

History | View | Annotate | Download (165 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 uint16_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
                bits= get_bit_count(&s->pb);
548
                s->misc_bits+= bits - s->last_bits;
549
                s->last_bits=bits;
550
            }
551

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

    
591
            if(interleaved_stats){
592
                bits= get_bit_count(&s->pb);
593
                s->mv_bits+= bits - s->last_bits;
594
                s->last_bits=bits;
595
            }
596

    
597
            /* encode each block */
598
            for (i = 0; i < 6; i++) {
599
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
600
            }
601

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

    
616
                    x= s->mb_x*16;
617
                    y= s->mb_y*16;
618
                    if(x+16 > s->width)  x= s->width-16;
619
                    if(y+16 > s->height) y= s->height-16;
620

    
621
                    offset= x + y*s->linesize;
622
                    p_pic= s->new_picture.data[0] + offset;
623
                    
624
                    s->mb_skiped=1;
625
                    for(i=0; i<s->max_b_frames; i++){
626
                        uint8_t *b_pic;
627
                        int diff;
628
                        Picture *pic= s->reordered_input_picture[i+1];
629

    
630
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
631

    
632
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
633
                        diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
634
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
635
                            s->mb_skiped=0;
636
                            break;
637
                        }
638
                    }
639
                }else
640
                    s->mb_skiped=1; 
641

    
642
                if(s->mb_skiped==1){
643
                    /* skip macroblock */
644
                    put_bits(&s->pb, 1, 1);
645

    
646
                    if(interleaved_stats){
647
                        s->misc_bits++;
648
                        s->last_bits++;
649
                    }
650
                    s->skip_count++;
651
                    return;
652
                }
653
            }
654

    
655
            put_bits(&s->pb, 1, 0);        /* mb coded */
656
            if(s->mv_type==MV_TYPE_16X16){
657
                cbpc = cbp & 3;
658
                if(s->dquant) cbpc+= 8;
659
                put_bits(&s->pb,
660
                        inter_MCBPC_bits[cbpc],
661
                        inter_MCBPC_code[cbpc]);
662

    
663
                cbpy = cbp >> 2;
664
                cbpy ^= 0xf;
665
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
666
                if(s->dquant)
667
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
668

    
669
                if(!s->progressive_sequence){
670
                    if(cbp)
671
                        put_bits(pb2, 1, s->interlaced_dct);
672
                    put_bits(pb2, 1, 0); // no interlaced ME yet
673
                }
674
                    
675
                if(interleaved_stats){
676
                    bits= get_bit_count(&s->pb);
677
                    s->misc_bits+= bits - s->last_bits;
678
                    s->last_bits=bits;
679
                }
680

    
681
                /* motion vectors: 16x16 mode */
682
                h263_pred_motion(s, 0, &pred_x, &pred_y);
683
            
684
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
685
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
686
            }else{
687
                cbpc = (cbp & 3)+16;
688
                put_bits(&s->pb,
689
                        inter_MCBPC_bits[cbpc],
690
                        inter_MCBPC_code[cbpc]);
691
                cbpy = cbp >> 2;
692
                cbpy ^= 0xf;
693
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
694

    
695
                if(!s->progressive_sequence){
696
                    if(cbp)
697
                        put_bits(pb2, 1, s->interlaced_dct);
698
                }
699
    
700
                if(interleaved_stats){
701
                    bits= get_bit_count(&s->pb);
702
                    s->misc_bits+= bits - s->last_bits;
703
                    s->last_bits=bits;
704
                }
705

    
706
                for(i=0; i<4; i++){
707
                    /* motion vectors: 8x8 mode*/
708
                    h263_pred_motion(s, i, &pred_x, &pred_y);
709

    
710
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
711
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
712
                }
713
            }
714

    
715
            if(interleaved_stats){ 
716
                bits= get_bit_count(&s->pb);
717
                s->mv_bits+= bits - s->last_bits;
718
                s->last_bits=bits;
719
            }
720

    
721
            /* encode each block */
722
            for (i = 0; i < 6; i++) {
723
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
724
            }
725

    
726
            if(interleaved_stats){
727
                bits= get_bit_count(&s->pb);
728
                s->p_tex_bits+= bits - s->last_bits;
729
                s->last_bits=bits;
730
            }
731
            s->f_count++;
732
        }
733
    } else {
734
        int cbp;
735
        int dc_diff[6];   //dc values with the dc prediction subtracted 
736
        int dir[6];  //prediction direction
737
        int zigzag_last_index[6];
738
        uint8_t *scan_table[6];
739
        int i;
740

    
741
        for(i=0; i<6; i++){
742
            const int level= block[i][0];
743
            uint16_t *dc_ptr;
744

    
745
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
746
            if (i < 4) {
747
                *dc_ptr = level * s->y_dc_scale;
748
            } else {
749
                *dc_ptr = level * s->c_dc_scale;
750
            }
751
        }
752

    
753
        s->ac_pred= decide_ac_pred(s, block, dir);
754

    
755
        if(s->ac_pred){
756
            for(i=0; i<6; i++){
757
                uint8_t *st;
758
                int last_index;
759

    
760
                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
761
                if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
762
                else           st = s->intra_h_scantable.permutated; /* top */
763

    
764
                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
765
                    if(block[i][st[last_index]]) break;
766
                zigzag_last_index[i]= s->block_last_index[i];
767
                s->block_last_index[i]= last_index;
768
                scan_table[i]= st;
769
            }
770
        }else{
771
            for(i=0; i<6; i++)
772
                scan_table[i]= s->intra_scantable.permutated;
773
        }
774

    
775
        /* compute cbp */
776
        cbp = 0;
777
        for (i = 0; i < 6; i++) {
778
            if (s->block_last_index[i] >= 1)
779
                cbp |= 1 << (5 - i);
780
        }
781

    
782
        cbpc = cbp & 3;
783
        if (s->pict_type == I_TYPE) {
784
            if(s->dquant) cbpc+=4;
785
            put_bits(&s->pb,
786
                intra_MCBPC_bits[cbpc],
787
                intra_MCBPC_code[cbpc]);
788
        } else {
789
            if(s->dquant) cbpc+=8;
790
            put_bits(&s->pb, 1, 0);        /* mb coded */
791
            put_bits(&s->pb,
792
                inter_MCBPC_bits[cbpc + 4],
793
                inter_MCBPC_code[cbpc + 4]);
794
        }
795
        put_bits(pb2, 1, s->ac_pred);
796
        cbpy = cbp >> 2;
797
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
798
        if(s->dquant)
799
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
800

    
801
        if(!s->progressive_sequence){
802
            put_bits(dc_pb, 1, s->interlaced_dct);
803
        }
804

    
805
        if(interleaved_stats){
806
            bits= get_bit_count(&s->pb);
807
            s->misc_bits+= bits - s->last_bits;
808
            s->last_bits=bits;
809
        }
810

    
811
        /* encode each block */
812
        for (i = 0; i < 6; i++) {
813
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
814
        }
815

    
816
        if(interleaved_stats){
817
            bits= get_bit_count(&s->pb);
818
            s->i_tex_bits+= bits - s->last_bits;
819
            s->last_bits=bits;
820
        }
821
        s->i_count++;
822

    
823
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
824
        if(s->ac_pred){
825
            for(i=0; i<6; i++){
826
                int j;    
827
                int16_t *ac_val;
828

    
829
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
830

    
831
                if(dir[i]){
832
                    for(j=1; j<8; j++) 
833
                        block[i][s->dsp.idct_permutation[j   ]]= ac_val[j+8];
834
                }else{
835
                    for(j=1; j<8; j++) 
836
                        block[i][s->dsp.idct_permutation[j<<3]]= ac_val[j  ];
837
                }
838
                s->block_last_index[i]= zigzag_last_index[i];
839
            }
840
        }
841
    }
842
}
843

    
844
void h263_encode_mb(MpegEncContext * s,
845
                    DCTELEM block[6][64],
846
                    int motion_x, int motion_y)
847
{
848
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
849
    int16_t pred_dc;
850
    int16_t rec_intradc[6];
851
    uint16_t *dc_ptr[6];
852
    const int dquant_code[5]= {1,0,9,2,3};
853
           
854
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
855
    if (!s->mb_intra) {
856
        /* compute cbp */
857
        cbp = 0;
858
        for (i = 0; i < 6; i++) {
859
            if (s->block_last_index[i] >= 0)
860
                cbp |= 1 << (5 - i);
861
        }
862
        if ((cbp | motion_x | motion_y | s->dquant) == 0) {
863
            /* skip macroblock */
864
            put_bits(&s->pb, 1, 1);
865
            return;
866
        }
867
        put_bits(&s->pb, 1, 0);        /* mb coded */
868
        cbpc = cbp & 3;
869
        if(s->dquant) cbpc+= 8;
870
        put_bits(&s->pb,
871
                    inter_MCBPC_bits[cbpc],
872
                    inter_MCBPC_code[cbpc]);
873
        cbpy = cbp >> 2;
874
        cbpy ^= 0xf;
875
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
876
        if(s->dquant)
877
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
878

    
879
        /* motion vectors: 16x16 mode only now */
880
        h263_pred_motion(s, 0, &pred_x, &pred_y);
881
      
882
        if (!s->umvplus) {  
883
            h263_encode_motion(s, motion_x - pred_x, s->f_code);
884
            h263_encode_motion(s, motion_y - pred_y, s->f_code);
885
        }
886
        else {
887
            h263p_encode_umotion(s, motion_x - pred_x);
888
            h263p_encode_umotion(s, motion_y - pred_y);
889
            if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
890
                /* To prevent Start Code emulation */
891
                put_bits(&s->pb,1,1);
892
        }
893
    } else {
894
        int li = s->h263_aic ? 0 : 1;
895
        
896
        cbp = 0;
897
        for(i=0; i<6; i++) {
898
            /* Predict DC */
899
            if (s->h263_aic && s->mb_intra) {
900
                int16_t level = block[i][0];
901
            
902
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
903
                level -= pred_dc;
904
                /* Quant */
905
                if (level < 0)
906
                    level = (level + (s->qscale >> 1))/(s->y_dc_scale);
907
                else
908
                    level = (level - (s->qscale >> 1))/(s->y_dc_scale);
909
                    
910
                /* AIC can change CBP */
911
                if (level == 0 && s->block_last_index[i] == 0)
912
                    s->block_last_index[i] = -1;
913
                else if (level < -127)
914
                    level = -127;
915
                else if (level > 127)
916
                    level = 127;
917
                
918
                block[i][0] = level;
919
                /* Reconstruction */ 
920
                rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
921
                /* Oddify */
922
                rec_intradc[i] |= 1;
923
                //if ((rec_intradc[i] % 2) == 0)
924
                //    rec_intradc[i]++;
925
                /* Clipping */
926
                if (rec_intradc[i] < 0)
927
                    rec_intradc[i] = 0;
928
                else if (rec_intradc[i] > 2047)
929
                    rec_intradc[i] = 2047;
930
                                
931
                /* Update AC/DC tables */
932
                *dc_ptr[i] = rec_intradc[i];
933
            }
934
            /* compute cbp */
935
            if (s->block_last_index[i] >= li)
936
                cbp |= 1 << (5 - i);
937
        }
938

    
939
        cbpc = cbp & 3;
940
        if (s->pict_type == I_TYPE) {
941
            if(s->dquant) cbpc+=4;
942
            put_bits(&s->pb,
943
                intra_MCBPC_bits[cbpc],
944
                intra_MCBPC_code[cbpc]);
945
        } else {
946
            if(s->dquant) cbpc+=8;
947
            put_bits(&s->pb, 1, 0);        /* mb coded */
948
            put_bits(&s->pb,
949
                inter_MCBPC_bits[cbpc + 4],
950
                inter_MCBPC_code[cbpc + 4]);
951
        }
952
        if (s->h263_aic) {
953
            /* XXX: currently, we do not try to use ac prediction */
954
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
955
        }
956
        cbpy = cbp >> 2;
957
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
958
        if(s->dquant)
959
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
960
    }
961

    
962
    for(i=0; i<6; i++) {
963
        /* encode each block */
964
        h263_encode_block(s, block[i], i);
965
    
966
        /* Update INTRADC for decoding */
967
        if (s->h263_aic && s->mb_intra) {
968
            block[i][0] = rec_intradc[i];
969
            
970
        }
971
    }
972
}
973
#endif
974

    
975
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
976
{
977
    int x, y, wrap, a, c, pred_dc, scale;
978
    int16_t *dc_val, *ac_val;
979

    
980
    /* find prediction */
981
    if (n < 4) {
982
        x = 2 * s->mb_x + 1 + (n & 1);
983
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
984
        wrap = s->mb_width * 2 + 2;
985
        dc_val = s->dc_val[0];
986
        ac_val = s->ac_val[0][0];
987
        scale = s->y_dc_scale;
988
    } else {
989
        x = s->mb_x + 1;
990
        y = s->mb_y + 1;
991
        wrap = s->mb_width + 2;
992
        dc_val = s->dc_val[n - 4 + 1];
993
        ac_val = s->ac_val[n - 4 + 1][0];
994
        scale = s->c_dc_scale;
995
    }
996
    /* B C
997
     * A X 
998
     */
999
    a = dc_val[(x - 1) + (y) * wrap];
1000
    c = dc_val[(x) + (y - 1) * wrap];
1001
    
1002
    /* No prediction outside GOB boundary */
1003
    if (s->first_slice_line && ((n < 2) || (n > 3)))
1004
        c = 1024;
1005
    pred_dc = 1024;
1006
    /* just DC prediction */
1007
    if (a != 1024 && c != 1024)
1008
        pred_dc = (a + c) >> 1;
1009
    else if (a != 1024)
1010
        pred_dc = a;
1011
    else
1012
        pred_dc = c;
1013
    
1014
    /* we assume pred is positive */
1015
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1016
    *dc_val_ptr = &dc_val[x + y * wrap];
1017
    return pred_dc;
1018
}
1019

    
1020
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1021
{
1022
    int x, y, wrap, a, c, pred_dc, scale, i;
1023
    int16_t *dc_val, *ac_val, *ac_val1;
1024

    
1025
    /* find prediction */
1026
    if (n < 4) {
1027
        x = 2 * s->mb_x + 1 + (n & 1);
1028
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1029
        wrap = s->mb_width * 2 + 2;
1030
        dc_val = s->dc_val[0];
1031
        ac_val = s->ac_val[0][0];
1032
        scale = s->y_dc_scale;
1033
    } else {
1034
        x = s->mb_x + 1;
1035
        y = s->mb_y + 1;
1036
        wrap = s->mb_width + 2;
1037
        dc_val = s->dc_val[n - 4 + 1];
1038
        ac_val = s->ac_val[n - 4 + 1][0];
1039
        scale = s->c_dc_scale;
1040
    }
1041
    
1042
    ac_val += ((y) * wrap + (x)) * 16;
1043
    ac_val1 = ac_val;
1044
    
1045
    /* B C
1046
     * A X 
1047
     */
1048
    a = dc_val[(x - 1) + (y) * wrap];
1049
    c = dc_val[(x) + (y - 1) * wrap];
1050
    
1051
    /* No prediction outside GOB boundary */
1052
    if (s->first_slice_line && ((n < 2) || (n > 3)))
1053
        c = 1024;
1054
    pred_dc = 1024;
1055
    if (s->ac_pred) {
1056
        if (s->h263_aic_dir) {
1057
            /* left prediction */
1058
            if (a != 1024) {
1059
                ac_val -= 16;
1060
                for(i=1;i<8;i++) {
1061
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1062
                }
1063
                pred_dc = a;
1064
            }
1065
        } else {
1066
            /* top prediction */
1067
            if (c != 1024) {
1068
                ac_val -= 16 * wrap;
1069
                for(i=1;i<8;i++) {
1070
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1071
                }
1072
                pred_dc = c;
1073
            }
1074
        }
1075
    } else {
1076
        /* just DC prediction */
1077
        if (a != 1024 && c != 1024)
1078
            pred_dc = (a + c) >> 1;
1079
        else if (a != 1024)
1080
            pred_dc = a;
1081
        else
1082
            pred_dc = c;
1083
    }
1084
    
1085
    /* we assume pred is positive */
1086
    block[0]=block[0]*scale + pred_dc;
1087
    
1088
    if (block[0] < 0)
1089
        block[0] = 0;
1090
    else if (!(block[0] & 1))
1091
        block[0]++;
1092
    
1093
    /* Update AC/DC tables */
1094
    dc_val[(x) + (y) * wrap] = block[0];
1095
    
1096
    /* left copy */
1097
    for(i=1;i<8;i++)
1098
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1099
    /* top copy */
1100
    for(i=1;i<8;i++)
1101
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1102
}
1103

    
1104
int16_t *h263_pred_motion(MpegEncContext * s, int block, 
1105
                        int *px, int *py)
1106
{
1107
    int xy, wrap;
1108
    int16_t *A, *B, *C, *mot_val;
1109
    static const int off[4]= {2, 1, 1, -1};
1110

    
1111
    wrap = s->block_wrap[0];
1112
    xy = s->block_index[block];
1113

    
1114
    mot_val = s->motion_val[xy];
1115

    
1116
    A = s->motion_val[xy - 1];
1117
    /* special case for first (slice) line */
1118
    if (s->first_slice_line && block<3) {
1119
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1120
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1121
        if(block==0){ //most common case
1122
            if(s->mb_x  == s->resync_mb_x){ //rare
1123
                *px= *py = 0;
1124
            }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1125
                C = s->motion_val[xy + off[block] - wrap];
1126
                if(s->mb_x==0){
1127
                    *px = C[0];
1128
                    *py = C[1];
1129
                }else{
1130
                    *px = mid_pred(A[0], 0, C[0]);
1131
                    *py = mid_pred(A[1], 0, C[1]);
1132
                }
1133
            }else{
1134
                *px = A[0];
1135
                *py = A[1];
1136
            }
1137
        }else if(block==1){
1138
            if(s->mb_x + 1 == s->resync_mb_x){ //rare
1139
                C = s->motion_val[xy + off[block] - wrap];
1140
                *px = mid_pred(A[0], 0, C[0]);
1141
                *py = mid_pred(A[1], 0, C[1]);
1142
            }else{
1143
                *px = A[0];
1144
                *py = A[1];
1145
            }
1146
        }else{ /* block==2*/
1147
            B = s->motion_val[xy - wrap];
1148
            C = s->motion_val[xy + off[block] - wrap];
1149
            if(s->mb_x == s->resync_mb_x) //rare
1150
                A[0]=A[1]=0;
1151
    
1152
            *px = mid_pred(A[0], B[0], C[0]);
1153
            *py = mid_pred(A[1], B[1], C[1]);
1154
        }
1155
    } else {
1156
        B = s->motion_val[xy - wrap];
1157
        C = s->motion_val[xy + off[block] - wrap];
1158
        *px = mid_pred(A[0], B[0], C[0]);
1159
        *py = mid_pred(A[1], B[1], C[1]);
1160
    }
1161
    return mot_val;
1162
}
1163

    
1164
#ifdef CONFIG_ENCODERS
1165
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1166
{
1167
    int range, l, bit_size, sign, code, bits;
1168

    
1169
    if (val == 0) {
1170
        /* zero vector */
1171
        code = 0;
1172
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1173
    } else {
1174
        bit_size = f_code - 1;
1175
        range = 1 << bit_size;
1176
        /* modulo encoding */
1177
        l = range * 32;
1178
#if 1
1179
        val+= l;
1180
        val&= 2*l-1;
1181
        val-= l;
1182
        sign = val>>31;
1183
        val= (val^sign)-sign;
1184
        sign&=1;
1185
#else
1186
        if (val < -l) {
1187
            val += 2*l;
1188
        } else if (val >= l) {
1189
            val -= 2*l;
1190
        }
1191

    
1192
        assert(val>=-l && val<l);
1193

    
1194
        if (val >= 0) {
1195
            sign = 0;
1196
        } else {
1197
            val = -val;
1198
            sign = 1;
1199
        }
1200
#endif
1201
        val--;
1202
        code = (val >> bit_size) + 1;
1203
        bits = val & (range - 1);
1204

    
1205
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1206
        if (bit_size > 0) {
1207
            put_bits(&s->pb, bit_size, bits);
1208
        }
1209
    }
1210

    
1211
}
1212

    
1213
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1214
static void h263p_encode_umotion(MpegEncContext * s, int val)
1215
{
1216
    short sval = 0; 
1217
    short i = 0;
1218
    short n_bits = 0;
1219
    short temp_val;
1220
    int code = 0;
1221
    int tcode;
1222
    
1223
    if ( val == 0)
1224
        put_bits(&s->pb, 1, 1);
1225
    else if (val == 1)
1226
        put_bits(&s->pb, 3, 0);
1227
    else if (val == -1)
1228
        put_bits(&s->pb, 3, 2);
1229
    else {
1230
        
1231
        sval = ((val < 0) ? (short)(-val):(short)val);
1232
        temp_val = sval;
1233
        
1234
        while (temp_val != 0) {
1235
            temp_val = temp_val >> 1;
1236
            n_bits++;
1237
        }
1238
        
1239
        i = n_bits - 1;
1240
        while (i > 0) {
1241
            tcode = (sval & (1 << (i-1))) >> (i-1);
1242
            tcode = (tcode << 1) | 1;
1243
            code = (code << 2) | tcode;
1244
            i--;
1245
        }
1246
        code = ((code << 1) | (val < 0)) << 1;
1247
        put_bits(&s->pb, (2*n_bits)+1, code);
1248
        //printf("\nVal = %d\tCode = %d", sval, code);
1249
    }
1250
}
1251

    
1252
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1253
{
1254
    int f_code;
1255
    int mv;
1256
    
1257
    if(mv_penalty==NULL)
1258
        mv_penalty= av_mallocz( sizeof(uint16_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1259
    
1260
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1261
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1262
            int len;
1263

    
1264
            if(mv==0) len= mvtab[0][1];
1265
            else{
1266
                int val, bit_size, range, code;
1267

    
1268
                bit_size = s->f_code - 1;
1269
                range = 1 << bit_size;
1270

    
1271
                val=mv;
1272
                if (val < 0) 
1273
                    val = -val;
1274
                val--;
1275
                code = (val >> bit_size) + 1;
1276
                if(code<33){
1277
                    len= mvtab[code][1] + 1 + bit_size;
1278
                }else{
1279
                    len= mvtab[32][1] + 2 + bit_size;
1280
                }
1281
            }
1282

    
1283
            mv_penalty[f_code][mv+MAX_MV]= len;
1284
        }
1285
    }
1286

    
1287
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1288
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1289
            fcode_tab[mv+MAX_MV]= f_code;
1290
        }
1291
    }
1292

    
1293
    for(mv=0; mv<MAX_MV*2+1; mv++){
1294
        umv_fcode_tab[mv]= 1;
1295
    }
1296
}
1297
#endif
1298

    
1299
#ifdef CONFIG_ENCODERS
1300

    
1301
static void init_uni_dc_tab(void)
1302
{
1303
    int level, uni_code, uni_len;
1304

    
1305
    for(level=-256; level<256; level++){
1306
        int size, v, l;
1307
        /* find number of bits */
1308
        size = 0;
1309
        v = abs(level);
1310
        while (v) {
1311
            v >>= 1;
1312
            size++;
1313
        }
1314

    
1315
        if (level < 0)
1316
            l= (-level) ^ ((1 << size) - 1);
1317
        else
1318
            l= level;
1319

    
1320
        /* luminance */
1321
        uni_code= DCtab_lum[size][0];
1322
        uni_len = DCtab_lum[size][1];
1323

    
1324
        if (size > 0) {
1325
            uni_code<<=size; uni_code|=l;
1326
            uni_len+=size;
1327
            if (size > 8){
1328
                uni_code<<=1; uni_code|=1;
1329
                uni_len++;
1330
            }
1331
        }
1332
        uni_DCtab_lum_bits[level+256]= uni_code;
1333
        uni_DCtab_lum_len [level+256]= uni_len;
1334

    
1335
        /* chrominance */
1336
        uni_code= DCtab_chrom[size][0];
1337
        uni_len = DCtab_chrom[size][1];
1338
        
1339
        if (size > 0) {
1340
            uni_code<<=size; uni_code|=l;
1341
            uni_len+=size;
1342
            if (size > 8){
1343
                uni_code<<=1; uni_code|=1;
1344
                uni_len++;
1345
            }
1346
        }
1347
        uni_DCtab_chrom_bits[level+256]= uni_code;
1348
        uni_DCtab_chrom_len [level+256]= uni_len;
1349

    
1350
    }
1351
}
1352

    
1353
#endif //CONFIG_ENCODERS
1354

    
1355
#ifdef CONFIG_ENCODERS
1356
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1357
    int slevel, run, last;
1358
    
1359
    assert(MAX_LEVEL >= 64);
1360
    assert(MAX_RUN   >= 63);
1361

    
1362
    for(slevel=-64; slevel<64; slevel++){
1363
        if(slevel==0) continue;
1364
        for(run=0; run<64; run++){
1365
            for(last=0; last<=1; last++){
1366
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1367
                int level= slevel < 0 ? -slevel : slevel;
1368
                int sign= slevel < 0 ? 1 : 0;
1369
                int bits, len, code;
1370
                int level1, run1;
1371
                
1372
                len_tab[index]= 100;
1373
                     
1374
                /* ESC0 */
1375
                code= get_rl_index(rl, last, run, level);
1376
                bits= rl->table_vlc[code][0];
1377
                len=  rl->table_vlc[code][1];
1378
                bits=bits*2+sign; len++;
1379
                
1380
                if(code!=rl->n && len < len_tab[index]){
1381
                    bits_tab[index]= bits;
1382
                    len_tab [index]= len;
1383
                }
1384
#if 1
1385
                /* ESC1 */
1386
                bits= rl->table_vlc[rl->n][0];
1387
                len=  rl->table_vlc[rl->n][1];
1388
                bits=bits*2;    len++; //esc1
1389
                level1= level - rl->max_level[last][run];
1390
                if(level1>0){
1391
                    code= get_rl_index(rl, last, run, level1);
1392
                    bits<<= rl->table_vlc[code][1];
1393
                    len  += rl->table_vlc[code][1];
1394
                    bits += rl->table_vlc[code][0];
1395
                    bits=bits*2+sign; len++;
1396
                
1397
                    if(code!=rl->n && len < len_tab[index]){
1398
                        bits_tab[index]= bits;
1399
                        len_tab [index]= len;
1400
                    }
1401
                }
1402
#endif 
1403
#if 1
1404
                /* ESC2 */
1405
                bits= rl->table_vlc[rl->n][0];
1406
                len=  rl->table_vlc[rl->n][1];
1407
                bits=bits*4+2;    len+=2; //esc2
1408
                run1 = run - rl->max_run[last][level] - 1;
1409
                if(run1>=0){
1410
                    code= get_rl_index(rl, last, run1, level);
1411
                    bits<<= rl->table_vlc[code][1];
1412
                    len  += rl->table_vlc[code][1];
1413
                    bits += rl->table_vlc[code][0];
1414
                    bits=bits*2+sign; len++;
1415
                
1416
                    if(code!=rl->n && len < len_tab[index]){
1417
                        bits_tab[index]= bits;
1418
                        len_tab [index]= len;
1419
                    }
1420
                }
1421
#endif           
1422
                /* ESC3 */        
1423
                bits= rl->table_vlc[rl->n][0];
1424
                len = rl->table_vlc[rl->n][1];
1425
                bits=bits*4+3;    len+=2; //esc3
1426
                bits=bits*2+last; len++;
1427
                bits=bits*64+run; len+=6;
1428
                bits=bits*2+1;    len++;  //marker
1429
                bits=bits*4096+(slevel&0xfff); len+=12;
1430
                bits=bits*2+1;    len++;  //marker
1431
                
1432
                if(len < len_tab[index]){
1433
                    bits_tab[index]= bits;
1434
                    len_tab [index]= len;
1435
                }
1436
            }
1437
        }
1438
    }
1439
}
1440

    
1441
void h263_encode_init(MpegEncContext *s)
1442
{
1443
    static int done = 0;
1444

    
1445
    if (!done) {
1446
        done = 1;
1447

    
1448
        init_uni_dc_tab();
1449

    
1450
        init_rl(&rl_inter);
1451
        init_rl(&rl_intra);
1452
        init_rl(&rl_intra_aic);
1453
        
1454
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1455
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1456

    
1457
        init_mv_penalty_and_fcode(s);
1458
    }
1459
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1460
    
1461
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1462
    switch(s->codec_id){
1463
    case CODEC_ID_MPEG4:
1464
        s->fcode_tab= fcode_tab;
1465
        s->min_qcoeff= -2048;
1466
        s->max_qcoeff=  2047;
1467
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1468
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1469
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1470
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1471
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
1472
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1473
        s->ac_esc_length= 7+2+1+6+1+12+1;
1474
        break;
1475
    case CODEC_ID_H263P:
1476
        s->fcode_tab= umv_fcode_tab;
1477
        s->min_qcoeff= -127;
1478
        s->max_qcoeff=  127;
1479
        break;
1480
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1481
    default: //nothing needed default table allready set in mpegvideo.c
1482
        s->min_qcoeff= -127;
1483
        s->max_qcoeff=  127;
1484
        s->y_dc_scale_table=
1485
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1486
    }
1487

    
1488
    if(s->mpeg_quant){
1489
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1490
        s->inter_quant_bias= 0;
1491
    }else{
1492
        s->intra_quant_bias=0;
1493
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1494
    }
1495
}
1496

    
1497
/**
1498
 * encodes a 8x8 block.
1499
 * @param block the 8x8 block
1500
 * @param n block index (0-3 are luma, 4-5 are chroma)
1501
 */
1502
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1503
{
1504
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1505
    RLTable *rl;
1506

    
1507
    rl = &rl_inter;
1508
    if (s->mb_intra && !s->h263_aic) {
1509
        /* DC coef */
1510
        level = block[0];
1511
        /* 255 cannot be represented, so we clamp */
1512
        if (level > 254) {
1513
            level = 254;
1514
            block[0] = 254;
1515
        }
1516
        /* 0 cannot be represented also */
1517
        else if (level < 1) {
1518
            level = 1;
1519
            block[0] = 1;
1520
        }
1521
        if (level == 128) //FIXME check rv10
1522
            put_bits(&s->pb, 8, 0xff);
1523
        else
1524
            put_bits(&s->pb, 8, level & 0xff);
1525
        i = 1;
1526
    } else {
1527
        i = 0;
1528
        if (s->h263_aic && s->mb_intra)
1529
            rl = &rl_intra_aic;
1530
    }
1531
   
1532
    /* AC coefs */
1533
    last_index = s->block_last_index[n];
1534
    last_non_zero = i - 1;
1535
    for (; i <= last_index; i++) {
1536
        j = s->intra_scantable.permutated[i];
1537
        level = block[j];
1538
        if (level) {
1539
            run = i - last_non_zero - 1;
1540
            last = (i == last_index);
1541
            sign = 0;
1542
            slevel = level;
1543
            if (level < 0) {
1544
                sign = 1;
1545
                level = -level;
1546
            }
1547
            code = get_rl_index(rl, last, run, level);
1548
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1549
            if (code == rl->n) {
1550
                put_bits(&s->pb, 1, last);
1551
                put_bits(&s->pb, 6, run);
1552
                
1553
                assert(slevel != 0);
1554

    
1555
                if(slevel < 128 && slevel > -128) 
1556
                    put_bits(&s->pb, 8, slevel & 0xff);
1557
                else{
1558
                    put_bits(&s->pb, 8, 128);
1559
                    put_bits(&s->pb, 5, slevel & 0x1f);
1560
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
1561
                }
1562
            } else {
1563
                put_bits(&s->pb, 1, sign);
1564
            }
1565
                last_non_zero = i;
1566
            }
1567
    }
1568
}
1569
#endif
1570

    
1571
#ifdef CONFIG_ENCODERS
1572

    
1573
/***************************************************/
1574
/**
1575
 * add mpeg4 stuffing bits (01...1)
1576
 */
1577
void ff_mpeg4_stuffing(PutBitContext * pbc)
1578
{
1579
    int length;
1580
    put_bits(pbc, 1, 0);
1581
    length= (-get_bit_count(pbc))&7;
1582
    if(length) put_bits(pbc, length, (1<<length)-1);
1583
}
1584

    
1585
/* must be called before writing the header */
1586
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1587
    int time_div, time_mod;
1588

    
1589
    if(s->pict_type==I_TYPE){ //we will encode a vol header
1590
        int dummy;
1591
        av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1592
        
1593
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1594
    }
1595
    
1596
    if(s->current_picture.pts)
1597
        s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1598
    else
1599
        s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
1600
    time_div= s->time/s->time_increment_resolution;
1601
    time_mod= s->time%s->time_increment_resolution;
1602

    
1603
    if(s->pict_type==B_TYPE){
1604
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1605
    }else{
1606
        s->last_time_base= s->time_base;
1607
        s->time_base= time_div;
1608
        s->pp_time= s->time - s->last_non_b_time;
1609
        s->last_non_b_time= s->time;
1610
    }
1611
}
1612

    
1613
static void mpeg4_encode_gop_header(MpegEncContext * s){
1614
    int hours, minutes, seconds;
1615
    
1616
    put_bits(&s->pb, 16, 0);
1617
    put_bits(&s->pb, 16, GOP_STARTCODE);
1618
    
1619
    seconds= s->time/s->time_increment_resolution;
1620
    minutes= seconds/60; seconds %= 60;
1621
    hours= minutes/60; minutes %= 60;
1622
    hours%=24;
1623

    
1624
    put_bits(&s->pb, 5, hours);
1625
    put_bits(&s->pb, 6, minutes);
1626
    put_bits(&s->pb, 1, 1);
1627
    put_bits(&s->pb, 6, seconds);
1628
    
1629
    put_bits(&s->pb, 1, 0); //closed gov == NO
1630
    put_bits(&s->pb, 1, 0); //broken link == NO
1631

    
1632
    ff_mpeg4_stuffing(&s->pb);
1633
}
1634

    
1635
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1636
    int profile_and_level_indication;
1637
    int vo_ver_id;
1638
    
1639
    if(s->max_b_frames || s->quarter_sample){
1640
        profile_and_level_indication= 0xF1; // adv simple level 1
1641
        vo_ver_id= 5;
1642
    }else{
1643
        profile_and_level_indication= 0x01; // simple level 1
1644
        vo_ver_id= 1;
1645
    }
1646
    //FIXME levels
1647

    
1648
    put_bits(&s->pb, 16, 0);
1649
    put_bits(&s->pb, 16, VOS_STARTCODE);
1650
    
1651
    put_bits(&s->pb, 8, profile_and_level_indication);
1652
    
1653
    put_bits(&s->pb, 16, 0);
1654
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1655
    
1656
    put_bits(&s->pb, 1, 1);
1657
        put_bits(&s->pb, 4, vo_ver_id);
1658
        put_bits(&s->pb, 3, 1); //priority
1659
 
1660
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
1661
    
1662
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1663

    
1664
    ff_mpeg4_stuffing(&s->pb);
1665
}
1666

    
1667
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
1668
{
1669
    int vo_ver_id;
1670

    
1671
    if(s->max_b_frames || s->quarter_sample){
1672
        vo_ver_id= 5;
1673
        s->vo_type= ADV_SIMPLE_VO_TYPE;
1674
    }else{
1675
        vo_ver_id= 1;
1676
        s->vo_type= SIMPLE_VO_TYPE;
1677
    }
1678

    
1679
    put_bits(&s->pb, 16, 0);
1680
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
1681
    put_bits(&s->pb, 16, 0);
1682
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
1683

    
1684
    put_bits(&s->pb, 1, 0);                /* random access vol */
1685
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1686
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1687
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1688
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1689
    
1690
    float_aspect_to_info(s, s->avctx->aspect_ratio);
1691

    
1692
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1693
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1694
    {
1695
        put_bits(&s->pb, 8, s->aspected_width);
1696
        put_bits(&s->pb, 8, s->aspected_height);
1697
    }
1698

    
1699
    if(s->low_delay){
1700
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1701
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1702
        put_bits(&s->pb, 1, s->low_delay);
1703
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1704
    }else{
1705
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1706
    }
1707

    
1708
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1709
    put_bits(&s->pb, 1, 1);                /* marker bit */
1710
    
1711
    put_bits(&s->pb, 16, s->time_increment_resolution);
1712
    if (s->time_increment_bits < 1)
1713
        s->time_increment_bits = 1;
1714
    put_bits(&s->pb, 1, 1);                /* marker bit */
1715
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1716
    put_bits(&s->pb, 1, 1);                /* marker bit */
1717
    put_bits(&s->pb, 13, s->width);        /* vol width */
1718
    put_bits(&s->pb, 1, 1);                /* marker bit */
1719
    put_bits(&s->pb, 13, s->height);        /* vol height */
1720
    put_bits(&s->pb, 1, 1);                /* marker bit */
1721
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1722
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1723
    if (vo_ver_id == 1) {
1724
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1725
    }else{
1726
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1727
    }
1728
    
1729
    s->quant_precision=5;
1730
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
1731
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
1732
    if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1733

    
1734
    if (vo_ver_id != 1)
1735
        put_bits(&s->pb, 1, s->quarter_sample);
1736
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1737
    s->resync_marker= s->rtp_mode;
1738
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1739
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1740
    if(s->data_partitioning){
1741
        put_bits(&s->pb, 1, 0);                /* no rvlc */
1742
    }
1743

    
1744
    if (vo_ver_id != 1){
1745
        put_bits(&s->pb, 1, 0);                /* newpred */
1746
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1747
    }
1748
    put_bits(&s->pb, 1, 0);                /* scalability */
1749
    
1750
    ff_mpeg4_stuffing(&s->pb);
1751

    
1752
    /* user data */
1753
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
1754
        put_bits(&s->pb, 16, 0);
1755
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1756
        put_string(&s->pb, LIBAVCODEC_IDENT);
1757
        ff_mpeg4_stuffing(&s->pb);
1758
    }
1759
}
1760

    
1761
/* write mpeg4 VOP header */
1762
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1763
{
1764
    int time_incr;
1765
    int time_div, time_mod;
1766
    
1767
    if(s->pict_type==I_TYPE){
1768
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
1769
            mpeg4_encode_visual_object_header(s);
1770
            mpeg4_encode_vol_header(s, 0, 0);
1771
        }
1772
        mpeg4_encode_gop_header(s);
1773
    }
1774
    
1775
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1776

    
1777
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1778
    
1779
    put_bits(&s->pb, 16, 0);                /* vop header */
1780
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
1781
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1782

    
1783
    time_div= s->time/s->time_increment_resolution;
1784
    time_mod= s->time%s->time_increment_resolution;
1785
    time_incr= time_div - s->last_time_base;
1786
    while(time_incr--)
1787
        put_bits(&s->pb, 1, 1);
1788
        
1789
    put_bits(&s->pb, 1, 0);
1790

    
1791
    put_bits(&s->pb, 1, 1);        /* marker */
1792
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1793
    put_bits(&s->pb, 1, 1);        /* marker */
1794
    put_bits(&s->pb, 1, 1);        /* vop coded */
1795
    if (    s->pict_type == P_TYPE 
1796
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1797
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1798
    }
1799
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1800
    if(!s->progressive_sequence){
1801
         put_bits(&s->pb, 1, s->top_field_first);
1802
         put_bits(&s->pb, 1, s->alternate_scan);
1803
    }
1804
    //FIXME sprite stuff
1805

    
1806
    put_bits(&s->pb, 5, s->qscale);
1807

    
1808
    if (s->pict_type != I_TYPE)
1809
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1810
    if (s->pict_type == B_TYPE)
1811
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1812
    //    printf("****frame %d\n", picture_number);
1813

    
1814
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
1815
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1816
     s->h_edge_pos= s->width;
1817
     s->v_edge_pos= s->height;
1818
}
1819

    
1820
#endif //CONFIG_ENCODERS
1821

    
1822
/**
1823
 * change qscale by given dquant and update qscale dependant variables.
1824
 */
1825
static void change_qscale(MpegEncContext * s, int dquant)
1826
{
1827
    s->qscale += dquant;
1828

    
1829
    if (s->qscale < 1)
1830
        s->qscale = 1;
1831
    else if (s->qscale > 31)
1832
        s->qscale = 31;
1833

    
1834
    s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1835
    s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1836
}
1837

    
1838
/**
1839
 * predicts the dc.
1840
 * @param n block index (0-3 are luma, 4-5 are chroma)
1841
 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
1842
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
1843
 * @return the quantized predicted dc
1844
 */
1845
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
1846
{
1847
    int a, b, c, wrap, pred, scale;
1848
    uint16_t *dc_val;
1849
    int dummy;
1850

    
1851
    /* find prediction */
1852
    if (n < 4) {
1853
        scale = s->y_dc_scale;
1854
    } else {
1855
        scale = s->c_dc_scale;
1856
    }
1857
    wrap= s->block_wrap[n];
1858
    dc_val = s->dc_val[0] + s->block_index[n];
1859

    
1860
    /* B C
1861
     * A X 
1862
     */
1863
    a = dc_val[ - 1];
1864
    b = dc_val[ - 1 - wrap];
1865
    c = dc_val[ - wrap];
1866

    
1867
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
1868
    if(s->first_slice_line && n!=3){
1869
        if(n!=2) b=c= 1024;
1870
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
1871
    }
1872
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
1873
        if(n==0 || n==4 || n==5)
1874
            b=1024;
1875
    }
1876

    
1877
    if (abs(a - b) < abs(b - c)) {
1878
        pred = c;
1879
        *dir_ptr = 1; /* top */
1880
    } else {
1881
        pred = a;
1882
        *dir_ptr = 0; /* left */
1883
    }
1884
    /* we assume pred is positive */
1885
#ifdef ARCH_X86
1886
        asm volatile (
1887
                "xorl %%edx, %%edx        \n\t"
1888
                "mul %%ecx                \n\t"
1889
                : "=d" (pred), "=a"(dummy)
1890
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1891
        );
1892
#else
1893
    pred = (pred + (scale >> 1)) / scale;
1894
#endif
1895

    
1896
    /* prepare address for prediction update */
1897
    *dc_val_ptr = &dc_val[0];
1898

    
1899
    return pred;
1900
}
1901

    
1902
/**
1903
 * predicts the ac.
1904
 * @param n block index (0-3 are luma, 4-5 are chroma)
1905
 * @param dir the ac prediction direction
1906
 */
1907
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
1908
                   int dir)
1909
{
1910
    int i;
1911
    int16_t *ac_val, *ac_val1;
1912
    int8_t * const qscale_table= s->current_picture.qscale_table;
1913

    
1914
    /* find prediction */
1915
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1916
    ac_val1 = ac_val;
1917
    if (s->ac_pred) {
1918
        if (dir == 0) {
1919
            const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1920
            /* left prediction */
1921
            ac_val -= 16;
1922
            
1923
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1924
                /* same qscale */
1925
                for(i=1;i<8;i++) {
1926
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1927
                }
1928
            }else{
1929
                /* different qscale, we must rescale */
1930
                for(i=1;i<8;i++) {
1931
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1932
                }
1933
            }
1934
        } else {
1935
            const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1936
            /* top prediction */
1937
            ac_val -= 16 * s->block_wrap[n];
1938

    
1939
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1940
                /* same qscale */
1941
                for(i=1;i<8;i++) {
1942
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
1943
                }
1944
            }else{
1945
                /* different qscale, we must rescale */
1946
                for(i=1;i<8;i++) {
1947
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1948
                }
1949
            }
1950
        }
1951
    }
1952
    /* left copy */
1953
    for(i=1;i<8;i++)
1954
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1955

    
1956
    /* top copy */
1957
    for(i=1;i<8;i++)
1958
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1959

    
1960
}
1961

    
1962
#ifdef CONFIG_ENCODERS
1963

    
1964
static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
1965
                              int dir)
1966
{
1967
    int i;
1968
    int16_t *ac_val;
1969
    int8_t * const qscale_table= s->current_picture.qscale_table;
1970

    
1971
    /* find prediction */
1972
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1973
 
1974
    if (dir == 0) {
1975
        const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1976
        /* left prediction */
1977
        ac_val -= 16;
1978
        if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1979
            /* same qscale */
1980
            for(i=1;i<8;i++) {
1981
                block[s->dsp.idct_permutation[i<<3]] -= ac_val[i];
1982
            }
1983
        }else{
1984
            /* different qscale, we must rescale */
1985
            for(i=1;i<8;i++) {
1986
                block[s->dsp.idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1987
            }
1988
        }
1989
    } else {
1990
        const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1991
        /* top prediction */
1992
        ac_val -= 16 * s->block_wrap[n];
1993
        if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1994
            /* same qscale */
1995
            for(i=1;i<8;i++) {
1996
                block[s->dsp.idct_permutation[i]] -= ac_val[i + 8];
1997
            }
1998
        }else{
1999
            /* different qscale, we must rescale */
2000
            for(i=1;i<8;i++) {
2001
                block[s->dsp.idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2002
            }
2003
        }
2004
    }
2005
}
2006

    
2007
/**
2008
 * encodes the dc value.
2009
 * @param n block index (0-3 are luma, 4-5 are chroma)
2010
 */
2011
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2012
{
2013
#if 1
2014
//    if(level<-255 || level>255) printf("dc overflow\n");
2015
    level+=256;
2016
    if (n < 4) {
2017
        /* luminance */
2018
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2019
    } else {
2020
        /* chrominance */
2021
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2022
    }
2023
#else
2024
    int size, v;
2025
    /* find number of bits */
2026
    size = 0;
2027
    v = abs(level);
2028
    while (v) {
2029
        v >>= 1;
2030
        size++;
2031
    }
2032

    
2033
    if (n < 4) {
2034
        /* luminance */
2035
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2036
    } else {
2037
        /* chrominance */
2038
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2039
    }
2040

    
2041
    /* encode remaining bits */
2042
    if (size > 0) {
2043
        if (level < 0)
2044
            level = (-level) ^ ((1 << size) - 1);
2045
        put_bits(&s->pb, size, level);
2046
        if (size > 8)
2047
            put_bits(&s->pb, 1, 1);
2048
    }
2049
#endif
2050
}
2051

    
2052
/**
2053
 * encodes a 8x8 block
2054
 * @param n block index (0-3 are luma, 4-5 are chroma)
2055
 */
2056
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2057
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2058
{
2059
    int i, last_non_zero;
2060
#if 0 //variables for the outcommented version
2061
    int code, sign, last;
2062
#endif
2063
    const RLTable *rl;
2064
    uint32_t *bits_tab;
2065
    uint8_t *len_tab;
2066
    const int last_index = s->block_last_index[n];
2067

    
2068
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2069
        /* mpeg4 based DC predictor */
2070
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2071
        if(last_index<1) return;
2072
        i = 1;
2073
        rl = &rl_intra;
2074
        bits_tab= uni_mpeg4_intra_rl_bits;
2075
        len_tab = uni_mpeg4_intra_rl_len;
2076
    } else {
2077
        if(last_index<0) return;
2078
        i = 0;
2079
        rl = &rl_inter;
2080
        bits_tab= uni_mpeg4_inter_rl_bits;
2081
        len_tab = uni_mpeg4_inter_rl_len;
2082
    }
2083

    
2084
    /* AC coefs */
2085
    last_non_zero = i - 1;
2086
#if 1
2087
    for (; i < last_index; i++) {
2088
        int level = block[ scan_table[i] ];
2089
        if (level) {
2090
            int run = i - last_non_zero - 1;
2091
            level+=64;
2092
            if((level&(~127)) == 0){
2093
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2094
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2095
            }else{ //ESC3
2096
                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);
2097
            }
2098
            last_non_zero = i;
2099
        }
2100
    }
2101
    /*if(i<=last_index)*/{
2102
        int level = block[ scan_table[i] ];
2103
        int run = i - last_non_zero - 1;
2104
        level+=64;
2105
        if((level&(~127)) == 0){
2106
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2107
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2108
        }else{ //ESC3
2109
            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);
2110
        }
2111
    }
2112
#else
2113
    for (; i <= last_index; i++) {
2114
        const int slevel = block[ scan_table[i] ];
2115
        if (slevel) {
2116
            int level;
2117
            int run = i - last_non_zero - 1;
2118
            last = (i == last_index);
2119
            sign = 0;
2120
            level = slevel;
2121
            if (level < 0) {
2122
                sign = 1;
2123
                level = -level;
2124
            }
2125
            code = get_rl_index(rl, last, run, level);
2126
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2127
            if (code == rl->n) {
2128
                int level1, run1;
2129
                level1 = level - rl->max_level[last][run];
2130
                if (level1 < 1) 
2131
                    goto esc2;
2132
                code = get_rl_index(rl, last, run, level1);
2133
                if (code == rl->n) {
2134
                esc2:
2135
                    put_bits(ac_pb, 1, 1);
2136
                    if (level > MAX_LEVEL)
2137
                        goto esc3;
2138
                    run1 = run - rl->max_run[last][level] - 1;
2139
                    if (run1 < 0)
2140
                        goto esc3;
2141
                    code = get_rl_index(rl, last, run1, level);
2142
                    if (code == rl->n) {
2143
                    esc3:
2144
                        /* third escape */
2145
                        put_bits(ac_pb, 1, 1);
2146
                        put_bits(ac_pb, 1, last);
2147
                        put_bits(ac_pb, 6, run);
2148
                        put_bits(ac_pb, 1, 1);
2149
                        put_bits(ac_pb, 12, slevel & 0xfff);
2150
                        put_bits(ac_pb, 1, 1);
2151
                    } else {
2152
                        /* second escape */
2153
                        put_bits(ac_pb, 1, 0);
2154
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2155
                        put_bits(ac_pb, 1, sign);
2156
                    }
2157
                } else {
2158
                    /* first escape */
2159
                    put_bits(ac_pb, 1, 0);
2160
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2161
                    put_bits(ac_pb, 1, sign);
2162
                }
2163
            } else {
2164
                put_bits(ac_pb, 1, sign);
2165
            }
2166
            last_non_zero = i;
2167
        }
2168
    }
2169
#endif
2170
}
2171

    
2172
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2173
                               uint8_t *scan_table)
2174
{
2175
    int i, last_non_zero;
2176
    const RLTable *rl;
2177
    uint8_t *len_tab;
2178
    const int last_index = s->block_last_index[n];
2179
    int len=0;
2180

    
2181
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2182
        /* mpeg4 based DC predictor */
2183
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2184
        if(last_index<1) return len;
2185
        i = 1;
2186
        rl = &rl_intra;
2187
        len_tab = uni_mpeg4_intra_rl_len;
2188
    } else {
2189
        if(last_index<0) return 0;
2190
        i = 0;
2191
        rl = &rl_inter;
2192
        len_tab = uni_mpeg4_inter_rl_len;
2193
    }
2194

    
2195
    /* AC coefs */
2196
    last_non_zero = i - 1;
2197
    for (; i < last_index; i++) {
2198
        int level = block[ scan_table[i] ];
2199
        if (level) {
2200
            int run = i - last_non_zero - 1;
2201
            level+=64;
2202
            if((level&(~127)) == 0){
2203
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2204
                len += len_tab[index];
2205
            }else{ //ESC3
2206
                len += 7+2+1+6+1+12+1;
2207
            }
2208
            last_non_zero = i;
2209
        }
2210
    }
2211
    /*if(i<=last_index)*/{
2212
        int level = block[ scan_table[i] ];
2213
        int run = i - last_non_zero - 1;
2214
        level+=64;
2215
        if((level&(~127)) == 0){
2216
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2217
            len += len_tab[index];
2218
        }else{ //ESC3
2219
            len += 7+2+1+6+1+12+1;
2220
        }
2221
    }
2222
    
2223
    return len;
2224
}
2225

    
2226
#endif
2227

    
2228

    
2229
/***********************************************/
2230
/* decoding */
2231

    
2232
static VLC intra_MCBPC_vlc;
2233
static VLC inter_MCBPC_vlc;
2234
static VLC cbpy_vlc;
2235
static VLC mv_vlc;
2236
static VLC dc_lum, dc_chrom;
2237
static VLC sprite_trajectory;
2238
static VLC mb_type_b_vlc;
2239

    
2240
void init_vlc_rl(RLTable *rl)
2241
{
2242
    int i, q;
2243
    
2244
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2245
             &rl->table_vlc[0][1], 4, 2,
2246
             &rl->table_vlc[0][0], 4, 2);
2247

    
2248
    
2249
    for(q=0; q<32; q++){
2250
        int qmul= q*2;
2251
        int qadd= (q-1)|1;
2252
        
2253
        if(q==0){
2254
            qmul=1;
2255
            qadd=0;
2256
        }
2257
        
2258
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2259
        for(i=0; i<rl->vlc.table_size; i++){
2260
            int code= rl->vlc.table[i][0];
2261
            int len = rl->vlc.table[i][1];
2262
            int level, run;
2263
        
2264
            if(len==0){ // illegal code
2265
                run= 66;
2266
                level= MAX_LEVEL;
2267
            }else if(len<0){ //more bits needed
2268
                run= 0;
2269
                level= code;
2270
            }else{
2271
                if(code==rl->n){ //esc
2272
                    run= 66;
2273
                    level= 0;
2274
                }else{
2275
                    run=   rl->table_run  [code] + 1;
2276
                    level= rl->table_level[code] * qmul + qadd;
2277
                    if(code >= rl->last) run+=192;
2278
                }
2279
            }
2280
            rl->rl_vlc[q][i].len= len;
2281
            rl->rl_vlc[q][i].level= level;
2282
            rl->rl_vlc[q][i].run= run;
2283
        }
2284
    }
2285
}
2286

    
2287
/* init vlcs */
2288

    
2289
/* XXX: find a better solution to handle static init */
2290
void h263_decode_init_vlc(MpegEncContext *s)
2291
{
2292
    static int done = 0;
2293

    
2294
    if (!done) {
2295
        done = 1;
2296

    
2297
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8, 
2298
                 intra_MCBPC_bits, 1, 1,
2299
                 intra_MCBPC_code, 1, 1);
2300
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25, 
2301
                 inter_MCBPC_bits, 1, 1,
2302
                 inter_MCBPC_code, 1, 1);
2303
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2304
                 &cbpy_tab[0][1], 2, 1,
2305
                 &cbpy_tab[0][0], 2, 1);
2306
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2307
                 &mvtab[0][1], 2, 1,
2308
                 &mvtab[0][0], 2, 1);
2309
        init_rl(&rl_inter);
2310
        init_rl(&rl_intra);
2311
        init_rl(&rvlc_rl_inter);
2312
        init_rl(&rvlc_rl_intra);
2313
        init_rl(&rl_intra_aic);
2314
        init_vlc_rl(&rl_inter);
2315
        init_vlc_rl(&rl_intra);
2316
        init_vlc_rl(&rvlc_rl_inter);
2317
        init_vlc_rl(&rvlc_rl_intra);
2318
        init_vlc_rl(&rl_intra_aic);
2319
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2320
                 &DCtab_lum[0][1], 2, 1,
2321
                 &DCtab_lum[0][0], 2, 1);
2322
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2323
                 &DCtab_chrom[0][1], 2, 1,
2324
                 &DCtab_chrom[0][0], 2, 1);
2325
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2326
                 &sprite_trajectory_tab[0][1], 4, 2,
2327
                 &sprite_trajectory_tab[0][0], 4, 2);
2328
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2329
                 &mb_type_b_tab[0][1], 2, 1,
2330
                 &mb_type_b_tab[0][0], 2, 1);
2331
    }
2332
}
2333

    
2334
/**
2335
 * Get the GOB height based on picture height.
2336
 */
2337
int ff_h263_get_gob_height(MpegEncContext *s){
2338
    if (s->height <= 400)
2339
        return 1;
2340
    else if (s->height <= 800)
2341
        return  2;
2342
    else
2343
        return 4;
2344
}
2345

    
2346
/**
2347
 * decodes the group of blocks header.
2348
 * @return <0 if an error occured
2349
 */
2350
static int h263_decode_gob_header(MpegEncContext *s)
2351
{
2352
    unsigned int val, gfid;
2353
    int left;
2354
    
2355
    /* Check for GOB Start Code */
2356
    val = show_bits(&s->gb, 16);
2357
    if(val)
2358
        return -1;
2359

    
2360
        /* We have a GBSC probably with GSTUFF */
2361
    skip_bits(&s->gb, 16); /* Drop the zeros */
2362
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2363
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2364
    for(;left>13; left--){
2365
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2366
    }
2367
    if(left<=13) 
2368
        return -1;
2369

    
2370
#ifdef DEBUG
2371
    fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2372
#endif
2373
    s->gob_number = get_bits(&s->gb, 5); /* GN */
2374
    gfid = get_bits(&s->gb, 2); /* GFID */
2375
    s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2376
    if(s->qscale==0) 
2377
        return -1;
2378
    s->mb_x= 0;
2379
    s->mb_y= s->gob_index* s->gob_number;
2380
#ifdef DEBUG
2381
    fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2382
#endif
2383
    return 0;
2384
}
2385

    
2386
static inline void memsetw(short *tab, int val, int n)
2387
{
2388
    int i;
2389
    for(i=0;i<n;i++)
2390
        tab[i] = val;
2391
}
2392

    
2393
#ifdef CONFIG_ENCODERS
2394

    
2395
void ff_mpeg4_init_partitions(MpegEncContext *s)
2396
{
2397
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2398
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
2399
}
2400

    
2401
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2402
{
2403
    const int pb2_len   = get_bit_count(&s->pb2   );
2404
    const int tex_pb_len= get_bit_count(&s->tex_pb);
2405
    const int bits= get_bit_count(&s->pb);
2406

    
2407
    if(s->pict_type==I_TYPE){
2408
        put_bits(&s->pb, 19, DC_MARKER);
2409
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2410
        s->i_tex_bits+= tex_pb_len;
2411
    }else{
2412
        put_bits(&s->pb, 17, MOTION_MARKER);
2413
        s->misc_bits+=17 + pb2_len;
2414
        s->mv_bits+= bits - s->last_bits;
2415
        s->p_tex_bits+= tex_pb_len;
2416
    }
2417

    
2418
    flush_put_bits(&s->pb2);
2419
    flush_put_bits(&s->tex_pb);
2420

    
2421
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2422
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2423
    s->last_bits= get_bit_count(&s->pb);
2424
}
2425

    
2426
#endif //CONFIG_ENCODERS
2427

    
2428
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2429
    switch(s->pict_type){
2430
        case I_TYPE:
2431
            return 16;
2432
        case P_TYPE:
2433
        case S_TYPE:
2434
            return s->f_code+15;
2435
        case B_TYPE:
2436
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2437
        default:
2438
            return -1;
2439
    }
2440
}
2441

    
2442
#ifdef CONFIG_ENCODERS
2443

    
2444
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2445
{
2446
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2447

    
2448
    ff_mpeg4_stuffing(&s->pb);
2449
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2450
    put_bits(&s->pb, 1, 1);
2451
    
2452
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2453
    put_bits(&s->pb, s->quant_precision, s->qscale);
2454
    put_bits(&s->pb, 1, 0); /* no HEC */
2455
}
2456

    
2457
#endif //CONFIG_ENCODERS
2458

    
2459
/**
2460
 * check if the next stuff is a resync marker or the end.
2461
 * @return 0 if not
2462
 */
2463
static inline int mpeg4_is_resync(MpegEncContext *s){
2464
    const int bits_count= get_bits_count(&s->gb);
2465
    
2466
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
2467
        return 0;
2468
    }
2469

    
2470
    if(bits_count + 8 >= s->gb.size_in_bits){
2471
        int v= show_bits(&s->gb, 8);
2472
        v|= 0x7F >> (7-(bits_count&7));
2473
                
2474
        if(v==0x7F)
2475
            return 1;
2476
    }else{
2477
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2478
            int len;
2479
            GetBitContext gb= s->gb;
2480
        
2481
            skip_bits(&s->gb, 1);
2482
            align_get_bits(&s->gb);
2483
        
2484
            for(len=0; len<32; len++){
2485
                if(get_bits1(&s->gb)) break;
2486
            }
2487

    
2488
            s->gb= gb;
2489

    
2490
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2491
                return 1;
2492
        }
2493
    }
2494
    return 0;
2495
}
2496

    
2497
/**
2498
 * decodes the next video packet.
2499
 * @return <0 if something went wrong
2500
 */
2501
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2502
{
2503
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2504
    int header_extension=0, mb_num, len;
2505
    
2506
    /* is there enough space left for a video packet + header */
2507
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
2508

    
2509
    for(len=0; len<32; len++){
2510
        if(get_bits1(&s->gb)) break;
2511
    }
2512

    
2513
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2514
        printf("marker does not match f_code\n");
2515
        return -1;
2516
    }
2517
    
2518
    if(s->shape != RECT_SHAPE){
2519
        header_extension= get_bits1(&s->gb);
2520
        //FIXME more stuff here
2521
    }
2522

    
2523
    mb_num= get_bits(&s->gb, mb_num_bits);
2524
    if(mb_num>=s->mb_num){
2525
        fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2526
        return -1;
2527
    }
2528
    s->mb_x= mb_num % s->mb_width;
2529
    s->mb_y= mb_num / s->mb_width;
2530

    
2531
    if(s->shape != BIN_ONLY_SHAPE){
2532
        int qscale= get_bits(&s->gb, s->quant_precision); 
2533
        if(qscale)
2534
            s->qscale= qscale;
2535
    }
2536

    
2537
    if(s->shape == RECT_SHAPE){
2538
        header_extension= get_bits1(&s->gb);
2539
    }
2540
    if(header_extension){
2541
        int time_increment;
2542
        int time_incr=0;
2543

    
2544
        while (get_bits1(&s->gb) != 0) 
2545
            time_incr++;
2546

    
2547
        check_marker(&s->gb, "before time_increment in video packed header");
2548
        time_increment= get_bits(&s->gb, s->time_increment_bits);
2549
        check_marker(&s->gb, "before vop_coding_type in video packed header");
2550
        
2551
        skip_bits(&s->gb, 2); /* vop coding type */
2552
        //FIXME not rect stuff here
2553

    
2554
        if(s->shape != BIN_ONLY_SHAPE){
2555
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2556
//FIXME dont just ignore everything
2557
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2558
                mpeg4_decode_sprite_trajectory(s);
2559
                fprintf(stderr, "untested\n");
2560
            }
2561

    
2562
            //FIXME reduced res stuff here
2563
            
2564
            if (s->pict_type != I_TYPE) {
2565
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
2566
                if(f_code==0){
2567
                    printf("Error, video packet header damaged (f_code=0)\n");
2568
                }
2569
            }
2570
            if (s->pict_type == B_TYPE) {
2571
                int b_code = get_bits(&s->gb, 3);
2572
                if(b_code==0){
2573
                    printf("Error, video packet header damaged (b_code=0)\n");
2574
                }
2575
            }       
2576
        }
2577
    }
2578
    //FIXME new-pred stuff
2579
    
2580
//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));
2581

    
2582
    return 0;
2583
}
2584

    
2585
void ff_mpeg4_clean_buffers(MpegEncContext *s)
2586
{
2587
    int c_wrap, c_xy, l_wrap, l_xy;
2588

    
2589
    l_wrap= s->block_wrap[0];
2590
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2591
    c_wrap= s->block_wrap[4];
2592
    c_xy= s->mb_y*c_wrap + s->mb_x;
2593

    
2594
#if 0
2595
    /* clean DC */
2596
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2597
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2598
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2599
#endif
2600

    
2601
    /* clean AC */
2602
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
2603
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2604
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2605

    
2606
    /* clean MV */
2607
    // we cant clear the MVs as they might be needed by a b frame
2608
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
2609
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2610
    s->last_mv[0][0][0]=
2611
    s->last_mv[0][0][1]=
2612
    s->last_mv[1][0][0]=
2613
    s->last_mv[1][0][1]= 0;
2614
}
2615

    
2616
/**
2617
 * decodes the group of blocks / video packet header.
2618
 * @return <0 if no resync found
2619
 */
2620
int ff_h263_resync(MpegEncContext *s){
2621
    int left, ret;
2622
    
2623
    if(s->codec_id==CODEC_ID_MPEG4)
2624
        skip_bits1(&s->gb);
2625
    
2626
    align_get_bits(&s->gb);
2627

    
2628
    if(show_bits(&s->gb, 16)==0){
2629
        if(s->codec_id==CODEC_ID_MPEG4)
2630
            ret= mpeg4_decode_video_packet_header(s);
2631
        else
2632
            ret= h263_decode_gob_header(s);
2633
        if(ret>=0)
2634
            return 0;
2635
    }
2636
    //ok, its not where its supposed to be ...
2637
    s->gb= s->last_resync_gb;
2638
    align_get_bits(&s->gb);
2639
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2640
    
2641
    for(;left>16+1+5+5; left-=8){ 
2642
        if(show_bits(&s->gb, 16)==0){
2643
            GetBitContext bak= s->gb;
2644

    
2645
            if(s->codec_id==CODEC_ID_MPEG4)
2646
                ret= mpeg4_decode_video_packet_header(s);
2647
            else
2648
                ret= h263_decode_gob_header(s);
2649
            if(ret>=0)
2650
                return 0;
2651

    
2652
            s->gb= bak;
2653
        }
2654
        skip_bits(&s->gb, 8);
2655
    }
2656
    
2657
    return -1;
2658
}
2659

    
2660
/**
2661
 * gets the average motion vector for a GMC MB.
2662
 * @param n either 0 for the x component or 1 for y
2663
 * @returns the average MV for a GMC MB
2664
 */
2665
static inline int get_amv(MpegEncContext *s, int n){
2666
    int x, y, mb_v, sum, dx, dy, shift;
2667
    int len = 1 << (s->f_code + 4);
2668
    const int a= s->sprite_warping_accuracy;
2669

    
2670
    if(s->real_sprite_warping_points==1){
2671
        if(s->divx_version==500 && s->divx_build==413)
2672
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2673
        else
2674
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2675
    }else{
2676
        dx= s->sprite_delta[n][0];
2677
        dy= s->sprite_delta[n][1];
2678
        shift= s->sprite_shift[0];
2679
        if(n) dy -= 1<<(shift + a + 1);
2680
        else  dx -= 1<<(shift + a + 1);
2681
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2682

    
2683
        sum=0;
2684
        for(y=0; y<16; y++){
2685
            int v;
2686
        
2687
            v= mb_v + dy*y;
2688
            //XXX FIXME optimize
2689
            for(x=0; x<16; x++){
2690
                sum+= v>>shift;
2691
                v+= dx;
2692
            }
2693
        }
2694
        sum= RSHIFT(sum, a+8-s->quarter_sample);
2695
    }
2696

    
2697
    if      (sum < -len) sum= -len;
2698
    else if (sum >= len) sum= len-1;
2699

    
2700
    return sum;
2701
}
2702

    
2703
/**
2704
 * decodes first partition.
2705
 * @return number of MBs decoded or <0 if an error occured
2706
 */
2707
static int mpeg4_decode_partition_a(MpegEncContext *s){
2708
    int mb_num;
2709
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2710
    
2711
    /* decode first partition */
2712
    mb_num=0;
2713
    s->first_slice_line=1;
2714
    for(; s->mb_y<s->mb_height; s->mb_y++){
2715
        ff_init_block_index(s);
2716
        for(; s->mb_x<s->mb_width; s->mb_x++){
2717
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2718
            int cbpc;
2719
            int dir=0;
2720
            
2721
            mb_num++;
2722
            ff_update_block_index(s);
2723
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2724
                s->first_slice_line=0;
2725
            
2726
            if(s->mb_x==0) PRINT_MB_TYPE("\n");
2727

    
2728
            if(s->pict_type==I_TYPE){
2729
                int i;
2730

    
2731
                if(show_bits(&s->gb, 19)==DC_MARKER){
2732
                    return mb_num-1;
2733
                }
2734

    
2735
                PRINT_MB_TYPE("I");
2736
                cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2737
                if (cbpc < 0){
2738

    
2739
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2740
                    return -1;
2741
                }
2742
                s->cbp_table[xy]= cbpc & 3;
2743
                s->mb_type[xy]= MB_TYPE_INTRA;
2744
                s->mb_intra = 1;
2745

    
2746
                if(cbpc & 4) {
2747
                    change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2748
                }
2749
                s->current_picture.qscale_table[xy]= s->qscale;
2750

    
2751
                s->mbintra_table[xy]= 1;
2752
                for(i=0; i<6; i++){
2753
                    int dc_pred_dir;
2754
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2755
                    if(dc < 0){
2756
                        fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2757
                        return -1;
2758
                    }
2759
                    dir<<=1;
2760
                    if(dc_pred_dir) dir|=1;
2761
                }
2762
                s->pred_dir_table[xy]= dir;
2763
            }else{ /* P/S_TYPE */
2764
                int mx, my, pred_x, pred_y, bits;
2765
                int16_t * const mot_val= s->motion_val[s->block_index[0]];
2766
                const int stride= s->block_wrap[0]*2;
2767

    
2768
                bits= show_bits(&s->gb, 17);
2769
                if(bits==MOTION_MARKER){
2770
                    return mb_num-1;
2771
                }
2772
                skip_bits1(&s->gb);
2773
                if(bits&0x10000){
2774
                    /* skip mb */
2775
                    s->mb_type[xy]= MB_TYPE_SKIPED;
2776
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2777
                        PRINT_MB_TYPE("G");
2778
                        mx= get_amv(s, 0);
2779
                        my= get_amv(s, 1);
2780
                    }else{
2781
                        PRINT_MB_TYPE("S");
2782
                        mx=my=0;
2783
                    }
2784
                    mot_val[0       ]= mot_val[2       ]=
2785
                    mot_val[0+stride]= mot_val[2+stride]= mx;
2786
                    mot_val[1       ]= mot_val[3       ]=
2787
                    mot_val[1+stride]= mot_val[3+stride]= my;
2788

    
2789
                    if(s->mbintra_table[xy])
2790
                        ff_clean_intra_table_entries(s);
2791
                    continue;
2792
                }
2793
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2794
                if (cbpc < 0){
2795
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2796
                    return -1;
2797
                }
2798
                if (cbpc > 20)
2799
                    cbpc+=3;
2800
                else if (cbpc == 20)
2801
                    fprintf(stderr, "Stuffing !");
2802
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2803
    
2804
                s->mb_intra = ((cbpc & 4) != 0);
2805
        
2806
                if(s->mb_intra){
2807
                    PRINT_MB_TYPE("I");
2808
                    s->mbintra_table[xy]= 1;
2809
                    s->mb_type[xy]= MB_TYPE_INTRA;
2810
                    mot_val[0       ]= mot_val[2       ]= 
2811
                    mot_val[0+stride]= mot_val[2+stride]= 0;
2812
                    mot_val[1       ]= mot_val[3       ]=
2813
                    mot_val[1+stride]= mot_val[3+stride]= 0;
2814
                }else{
2815
                    if(s->mbintra_table[xy])
2816
                        ff_clean_intra_table_entries(s);
2817

    
2818
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2819
                        s->mcsel= get_bits1(&s->gb);
2820
                    else s->mcsel= 0;
2821
        
2822
                    if ((cbpc & 16) == 0) {
2823
                        PRINT_MB_TYPE("P");
2824
                        /* 16x16 motion prediction */
2825
                        s->mb_type[xy]= MB_TYPE_INTER;
2826

    
2827
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
2828
                        if(!s->mcsel){
2829
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2830
                            if (mx >= 0xffff)
2831
                                return -1;
2832

    
2833
                            my = h263_decode_motion(s, pred_y, s->f_code);
2834
                            if (my >= 0xffff)
2835
                                return -1;
2836
                        } else {
2837
                            mx = get_amv(s, 0);
2838
                            my = get_amv(s, 1);
2839
                        }
2840

    
2841
                        mot_val[0       ]= mot_val[2       ] =
2842
                        mot_val[0+stride]= mot_val[2+stride]= mx;
2843
                        mot_val[1       ]= mot_val[3       ]=
2844
                        mot_val[1+stride]= mot_val[3+stride]= my;
2845
                    } else {
2846
                        int i;
2847
                        PRINT_MB_TYPE("4");
2848
                        s->mb_type[xy]= MB_TYPE_INTER4V;
2849
                        for(i=0;i<4;i++) {
2850
                            int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2851
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2852
                            if (mx >= 0xffff)
2853
                                return -1;
2854
                
2855
                            my = h263_decode_motion(s, pred_y, s->f_code);
2856
                            if (my >= 0xffff)
2857
                                return -1;
2858
                            mot_val[0] = mx;
2859
                            mot_val[1] = my;
2860
                        }
2861
                    }
2862
                }
2863
            }
2864
        }
2865
        s->mb_x= 0;
2866
    }
2867

    
2868
    return mb_num;
2869
}
2870

    
2871
/**
2872
 * decode second partition.
2873
 * @return <0 if an error occured
2874
 */
2875
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
2876
    int mb_num=0;
2877
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2878

    
2879
    s->mb_x= s->resync_mb_x;
2880
    s->first_slice_line=1;
2881
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
2882
        ff_init_block_index(s);
2883
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
2884
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2885

    
2886
            mb_num++;
2887
            ff_update_block_index(s);
2888
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2889
                s->first_slice_line=0;
2890
            
2891
            if(s->pict_type==I_TYPE){
2892
                int ac_pred= get_bits1(&s->gb);
2893
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2894
                if(cbpy<0){
2895
                    fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2896
                    return -1;
2897
                }
2898
                
2899
                s->cbp_table[xy]|= cbpy<<2;
2900
                s->pred_dir_table[xy]|= ac_pred<<7;
2901
            }else{ /* P || S_TYPE */
2902
                if(s->mb_type[xy]&MB_TYPE_INTRA){          
2903
                    int dir=0,i;
2904
                    int ac_pred = get_bits1(&s->gb);
2905
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2906

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

    
2917
                    for(i=0; i<6; i++){
2918
                        int dc_pred_dir;
2919
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2920
                        if(dc < 0){
2921
                            fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2922
                            return -1;
2923
                        }
2924
                        dir<<=1;
2925
                        if(dc_pred_dir) dir|=1;
2926
                    }
2927
                    s->cbp_table[xy]&= 3; //remove dquant
2928
                    s->cbp_table[xy]|= cbpy<<2;
2929
                    s->pred_dir_table[xy]= dir | (ac_pred<<7);
2930
                }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
2931
                    s->current_picture.qscale_table[xy]= s->qscale;
2932
                    s->cbp_table[xy]= 0;
2933
                }else{
2934
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2935

    
2936
                    if(cbpy<0){
2937
                        fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2938
                        return -1;
2939
                    }
2940
                    
2941
                    if(s->cbp_table[xy] & 8) {
2942
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2943
                    }
2944
                    s->current_picture.qscale_table[xy]= s->qscale;
2945

    
2946
                    s->cbp_table[xy]&= 3; //remove dquant
2947
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
2948
                }
2949
            }
2950
        }
2951
        if(mb_num >= mb_count) return 0;
2952
        s->mb_x= 0;
2953
    }
2954
    return 0;
2955
}
2956

    
2957
/**
2958
 * decodes the first & second partition
2959
 * @return <0 if error (and sets error type in the error_status_table)
2960
 */
2961
int ff_mpeg4_decode_partitions(MpegEncContext *s)
2962
{
2963
    int mb_num;
2964
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
2965
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
2966
    
2967
    mb_num= mpeg4_decode_partition_a(s);    
2968
    if(mb_num<0){
2969
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
2970
        return -1;
2971
    }
2972
    
2973
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
2974
        fprintf(stderr, "slice below monitor ...\n");
2975
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
2976
        return -1;
2977
    }
2978

    
2979
    s->mb_num_left= mb_num;
2980
        
2981
    if(s->pict_type==I_TYPE){
2982
        if(get_bits(&s->gb, 19)!=DC_MARKER){
2983
            fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
2984
            return -1;
2985
        }
2986
    }else{
2987
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
2988
            fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
2989
            return -1;
2990
        }
2991
    }
2992
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
2993
    
2994
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
2995
        if(s->pict_type==P_TYPE)
2996
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
2997
        return -1;
2998
    }else{
2999
        if(s->pict_type==P_TYPE)
3000
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3001
    }
3002

    
3003
    return 0;        
3004
}
3005

    
3006
/**
3007
 * decode partition C of one MB.
3008
 * @return <0 if an error occured
3009
 */
3010
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3011
{
3012
    int cbp, mb_type;
3013
    const int xy= s->mb_x + s->mb_y*s->mb_width;
3014

    
3015
    mb_type= s->mb_type[xy];
3016
    cbp = s->cbp_table[xy];
3017

    
3018
    if(s->current_picture.qscale_table[xy] != s->qscale){
3019
        s->qscale= s->current_picture.qscale_table[xy];
3020
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3021
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3022
    }
3023
    
3024
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3025
        int i;
3026
        for(i=0; i<4; i++){
3027
            s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
3028
            s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
3029
        }
3030
        s->mb_intra = mb_type&MB_TYPE_INTRA;
3031

    
3032
        if (mb_type&MB_TYPE_SKIPED) {
3033
            /* skip mb */
3034
            for(i=0;i<6;i++)
3035
                s->block_last_index[i] = -1;
3036
            s->mv_dir = MV_DIR_FORWARD;
3037
            s->mv_type = MV_TYPE_16X16;
3038
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3039
                s->mcsel=1;
3040
                s->mb_skiped = 0;
3041
            }else{
3042
                s->mcsel=0;
3043
                s->mb_skiped = 1;
3044
            }
3045
        }else if(s->mb_intra){
3046
            s->ac_pred = s->pred_dir_table[xy]>>7;
3047
        }else if(!s->mb_intra){
3048
//            s->mcsel= 0; //FIXME do we need to init that
3049
            
3050
            s->mv_dir = MV_DIR_FORWARD;
3051
            if (mb_type&MB_TYPE_INTER4V) {
3052
                s->mv_type = MV_TYPE_8X8;
3053
            } else {
3054
                s->mv_type = MV_TYPE_16X16;
3055
            }
3056
        }
3057
    } else { /* I-Frame */
3058
        s->mb_intra = 1;
3059
        s->ac_pred = s->pred_dir_table[xy]>>7;
3060
    }
3061

    
3062
    if (!(mb_type&MB_TYPE_SKIPED)) {
3063
        int i;
3064
        /* decode each block */
3065
        for (i = 0; i < 6; i++) {
3066
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3067
                fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3068
                return -1;
3069
            }
3070
            cbp+=cbp;
3071
        }
3072
    }
3073

    
3074
    /* per-MB end of slice check */
3075

    
3076
    if(--s->mb_num_left <= 0){
3077
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3078
        if(mpeg4_is_resync(s))
3079
            return SLICE_END;
3080
        else
3081
            return SLICE_NOEND;     
3082
    }else{
3083
        if(s->cbp_table[xy+1] && mpeg4_is_resync(s))
3084
            return SLICE_END;
3085
        else
3086
            return SLICE_OK;
3087
    }
3088
}
3089

    
3090
int ff_h263_decode_mb(MpegEncContext *s,
3091
                      DCTELEM block[6][64])
3092
{
3093
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3094
    int16_t *mot_val;
3095
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
3096

    
3097
    if(s->mb_x==0) PRINT_MB_TYPE("\n");
3098

    
3099
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3100
        if (get_bits1(&s->gb)) {
3101
            /* skip mb */
3102
            s->mb_intra = 0;
3103
            for(i=0;i<6;i++)
3104
                s->block_last_index[i] = -1;
3105
            s->mv_dir = MV_DIR_FORWARD;
3106
            s->mv_type = MV_TYPE_16X16;
3107
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3108
                PRINT_MB_TYPE("G");
3109
                s->mcsel=1;
3110
                s->mv[0][0][0]= get_amv(s, 0);
3111
                s->mv[0][0][1]= get_amv(s, 1);
3112

    
3113
                s->mb_skiped = 0;
3114
            }else{
3115
                PRINT_MB_TYPE("S");
3116
                s->mcsel=0;
3117
                s->mv[0][0][0] = 0;
3118
                s->mv[0][0][1] = 0;
3119
                s->mb_skiped = 1;
3120
            }
3121
            goto end;
3122
        }
3123
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3124
        //fprintf(stderr, "\tCBPC: %d", cbpc);
3125
        if (cbpc < 0)
3126
            return -1;
3127
        if (cbpc > 20)
3128
            cbpc+=3;
3129
        else if (cbpc == 20)
3130
            fprintf(stderr, "Stuffing !");
3131
        
3132
        dquant = cbpc & 8;
3133
        s->mb_intra = ((cbpc & 4) != 0);
3134
        if (s->mb_intra) goto intra;
3135
        
3136
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3137
            s->mcsel= get_bits1(&s->gb);
3138
        else s->mcsel= 0;
3139
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3140
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
3141
        if (dquant) {
3142
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3143
        }
3144
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
3145
            s->interlaced_dct= get_bits1(&s->gb);
3146
        
3147
        s->mv_dir = MV_DIR_FORWARD;
3148
        if ((cbpc & 16) == 0) {
3149
            if(s->mcsel){
3150
                PRINT_MB_TYPE("G");
3151
                /* 16x16 global motion prediction */
3152
                s->mv_type = MV_TYPE_16X16;
3153
                mx= get_amv(s, 0);
3154
                my= get_amv(s, 1);
3155
                s->mv[0][0][0] = mx;
3156
                s->mv[0][0][1] = my;
3157
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
3158
                PRINT_MB_TYPE("f");
3159
                /* 16x8 field motion prediction */
3160
                s->mv_type= MV_TYPE_FIELD;
3161

    
3162
                s->field_select[0][0]= get_bits1(&s->gb);
3163
                s->field_select[0][1]= get_bits1(&s->gb);
3164

    
3165
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3166
                
3167
                for(i=0; i<2; i++){
3168
                    mx = h263_decode_motion(s, pred_x, s->f_code);
3169
                    if (mx >= 0xffff)
3170
                        return -1;
3171
            
3172
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
3173
                    if (my >= 0xffff)
3174
                        return -1;
3175

    
3176
                    s->mv[0][i][0] = mx;
3177
                    s->mv[0][i][1] = my;
3178
                }
3179
            }else{
3180
                PRINT_MB_TYPE("P");
3181
                /* 16x16 motion prediction */
3182
                s->mv_type = MV_TYPE_16X16;
3183
                h263_pred_motion(s, 0, &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
            
3189
                if (mx >= 0xffff)
3190
                    return -1;
3191
            
3192
                if (s->umvplus)
3193
                   my = h263p_decode_umotion(s, pred_y);
3194
                else
3195
                   my = h263_decode_motion(s, pred_y, s->f_code);
3196
            
3197
                if (my >= 0xffff)
3198
                    return -1;
3199
                s->mv[0][0][0] = mx;
3200
                s->mv[0][0][1] = my;
3201

    
3202
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3203
                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3204
            }
3205
        } else {
3206
            PRINT_MB_TYPE("4");
3207
            s->mv_type = MV_TYPE_8X8;
3208
            for(i=0;i<4;i++) {
3209
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3210
                if (s->umvplus)
3211
                  mx = h263p_decode_umotion(s, pred_x);
3212
                else
3213
                  mx = h263_decode_motion(s, pred_x, s->f_code);
3214
                if (mx >= 0xffff)
3215
                    return -1;
3216
                
3217
                if (s->umvplus)
3218
                  my = h263p_decode_umotion(s, pred_y);
3219
                else    
3220
                  my = h263_decode_motion(s, pred_y, s->f_code);
3221
                if (my >= 0xffff)
3222
                    return -1;
3223
                s->mv[0][i][0] = mx;
3224
                s->mv[0][i][1] = my;
3225
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3226
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3227
                mot_val[0] = mx;
3228
                mot_val[1] = my;
3229
            }
3230
        }
3231
    } else if(s->pict_type==B_TYPE) {
3232
        int modb1; // first bit of modb
3233
        int modb2; // second bit of modb
3234
        int mb_type;
3235

    
3236
        s->mb_intra = 0; //B-frames never contain intra blocks
3237
        s->mcsel=0;      //     ...               true gmc blocks
3238

    
3239
        if(s->mb_x==0){
3240
            for(i=0; i<2; i++){
3241
                s->last_mv[i][0][0]= 
3242
                s->last_mv[i][0][1]= 
3243
                s->last_mv[i][1][0]= 
3244
                s->last_mv[i][1][1]= 0;
3245
            }
3246
        }
3247

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

    
3251
        if(s->mb_skiped){
3252
                /* skip mb */
3253
            for(i=0;i<6;i++)
3254
                s->block_last_index[i] = -1;
3255

    
3256
            s->mv_dir = MV_DIR_FORWARD;
3257
            s->mv_type = MV_TYPE_16X16;
3258
            s->mv[0][0][0] = 0;
3259
            s->mv[0][0][1] = 0;
3260
            s->mv[1][0][0] = 0;
3261
            s->mv[1][0][1] = 0;
3262
            PRINT_MB_TYPE("s");
3263
            goto end;
3264
        }
3265

    
3266
        modb1= get_bits1(&s->gb); 
3267
        if(modb1){
3268
            mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
3269
            cbp=0;
3270
        }else{
3271
            int field_mv;
3272
        
3273
            modb2= get_bits1(&s->gb);
3274
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3275
            if(modb2) cbp= 0;
3276
            else      cbp= get_bits(&s->gb, 6);
3277

    
3278
            if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
3279
                if(get_bits1(&s->gb)){
3280
                    change_qscale(s, get_bits1(&s->gb)*4 - 2);
3281
                }
3282
            }
3283
            field_mv=0;
3284

    
3285
            if(!s->progressive_sequence){
3286
                if(cbp)
3287
                    s->interlaced_dct= get_bits1(&s->gb);
3288

    
3289
                if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
3290
                    field_mv=1;
3291

    
3292
                    if(mb_type!=MB_TYPE_B_BACKW){
3293
                        s->field_select[0][0]= get_bits1(&s->gb);
3294
                        s->field_select[0][1]= get_bits1(&s->gb);
3295
                    }
3296
                    if(mb_type!=MB_TYPE_B_FORW){
3297
                        s->field_select[1][0]= get_bits1(&s->gb);
3298
                        s->field_select[1][1]= get_bits1(&s->gb);
3299
                    }
3300
                }
3301
            }
3302

    
3303
            s->mv_dir = 0;
3304
            if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
3305
                s->mv_type= MV_TYPE_16X16;
3306
                if(mb_type!=MB_TYPE_B_BACKW){
3307
                    s->mv_dir = MV_DIR_FORWARD;
3308

    
3309
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3310
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3311
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3312
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3313
                }
3314
    
3315
                if(mb_type!=MB_TYPE_B_FORW){
3316
                    s->mv_dir |= MV_DIR_BACKWARD;
3317

    
3318
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3319
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3320
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3321
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
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
            }else if(mb_type!=MB_TYPE_B_DIRECT){
3326
                s->mv_type= MV_TYPE_FIELD;
3327

    
3328
                if(mb_type!=MB_TYPE_B_BACKW){
3329
                    s->mv_dir = MV_DIR_FORWARD;
3330
                
3331
                    for(i=0; i<2; i++){
3332
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3333
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3334
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3335
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3336
                    }
3337
                }
3338
    
3339
                if(mb_type!=MB_TYPE_B_FORW){
3340
                    s->mv_dir |= MV_DIR_BACKWARD;
3341

    
3342
                    for(i=0; i<2; i++){
3343
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
3344
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3345
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
3346
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3347
                    }
3348
                }
3349
                if(mb_type!=MB_TYPE_B_DIRECT)
3350
                    PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "f" : (mb_type==MB_TYPE_B_BACKW ? "b" : "t"));
3351
            }
3352
        }
3353
          
3354
        if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
3355
            if(mb_type==4)
3356
                mx=my=0;
3357
            else{
3358
                mx = h263_decode_motion(s, 0, 1);
3359
                my = h263_decode_motion(s, 0, 1);
3360
            }
3361
 
3362
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3363
            ff_mpeg4_set_direct_mv(s, mx, my);
3364
        }
3365
        
3366
        if(mb_type<0 || mb_type>4){
3367
            printf("illegal MB_type\n");
3368
            return -1;
3369
        }
3370
    } else { /* I-Frame */
3371
        cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
3372
        if (cbpc < 0)
3373
            return -1;
3374
        dquant = cbpc & 4;
3375
        s->mb_intra = 1;
3376
intra:
3377
        s->ac_pred = 0;
3378
        if (s->h263_pred || s->h263_aic) {
3379
            s->ac_pred = get_bits1(&s->gb);
3380
            if (s->ac_pred && s->h263_aic)
3381
                s->h263_aic_dir = get_bits1(&s->gb);
3382
        }
3383
        PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
3384
        
3385
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3386
        if(cbpy<0) return -1;
3387
        cbp = (cbpc & 3) | (cbpy << 2);
3388
        if (dquant) {
3389
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3390
        }
3391
        
3392
        if(!s->progressive_sequence)
3393
            s->interlaced_dct= get_bits1(&s->gb);
3394

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

    
3412
    /* decode each block */
3413
    if (s->h263_pred) {
3414
        for (i = 0; i < 6; i++) {
3415
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
3416
                return -1;
3417
            cbp+=cbp;
3418
        }
3419
    } else {
3420
        for (i = 0; i < 6; i++) {
3421
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3422
                return -1;
3423
            cbp+=cbp;
3424
        }
3425
    }
3426
end:
3427

    
3428
        /* per-MB end of slice check */
3429
    if(s->codec_id==CODEC_ID_MPEG4){
3430
        if(mpeg4_is_resync(s)){
3431
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x+1])
3432
                return SLICE_OK;
3433
            return SLICE_END;
3434
        }
3435
    }else{
3436
        int v= show_bits(&s->gb, 16);
3437
    
3438
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3439
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3440
        }
3441

    
3442
        if(v==0)
3443
            return SLICE_END;
3444
    }
3445

    
3446
    return SLICE_OK;     
3447
}
3448

    
3449
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3450
{
3451
    int code, val, sign, shift, l;
3452
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3453
    if (code < 0)
3454
        return 0xffff;
3455

    
3456
    if (code == 0)
3457
        return pred;
3458

    
3459
    sign = get_bits1(&s->gb);
3460
    shift = f_code - 1;
3461
    val = (code - 1) << shift;
3462
    if (shift > 0)
3463
        val |= get_bits(&s->gb, shift);
3464
    val++;
3465
    if (sign)
3466
        val = -val;
3467
    val += pred;
3468

    
3469
    /* modulo decoding */
3470
    if (!s->h263_long_vectors) {
3471
        l = 1 << (f_code + 4);
3472
        if (val < -l) {
3473
            val += l<<1;
3474
        } else if (val >= l) {
3475
            val -= l<<1;
3476
        }
3477
    } else {
3478
        /* horrible h263 long vector mode */
3479
        if (pred < -31 && val < -63)
3480
            val += 64;
3481
        if (pred > 32 && val > 63)
3482
            val -= 64;
3483
        
3484
    }
3485
    return val;
3486
}
3487

    
3488
/* Decodes RVLC of H.263+ UMV */
3489
static int h263p_decode_umotion(MpegEncContext * s, int pred)
3490
{
3491
   int code = 0, sign;
3492
   
3493
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
3494
      return pred;
3495
   
3496
   code = 2 + get_bits1(&s->gb);
3497
   
3498
   while (get_bits1(&s->gb))
3499
   {
3500
      code <<= 1;
3501
      code += get_bits1(&s->gb);
3502
   }
3503
   sign = code & 1;
3504
   code >>= 1;
3505
   
3506
   code = (sign) ? (pred - code) : (pred + code);
3507
#ifdef DEBUG
3508
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3509
#endif
3510
   return code;   
3511

    
3512
}
3513

    
3514
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3515
                             int n, int coded)
3516
{
3517
    int code, level, i, j, last, run;
3518
    RLTable *rl = &rl_inter;
3519
    const uint8_t *scan_table;
3520

    
3521
    scan_table = s->intra_scantable.permutated;
3522
    if (s->h263_aic && s->mb_intra) {
3523
        rl = &rl_intra_aic;
3524
        i = 0;
3525
        if (s->ac_pred) {
3526
            if (s->h263_aic_dir) 
3527
                scan_table = s->intra_v_scantable.permutated; /* left */
3528
            else
3529
                scan_table = s->intra_h_scantable.permutated; /* top */
3530
        }
3531
    } else if (s->mb_intra) {
3532
        /* DC coef */
3533
        if(s->h263_rv10){
3534
          if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
3535
            int component, diff;
3536
            component = (n <= 3 ? 0 : n - 4 + 1);
3537
            level = s->last_dc[component];
3538
            if (s->rv10_first_dc_coded[component]) {
3539
                diff = rv_decode_dc(s, n);
3540
                if (diff == 0xffff)
3541
                    return -1;
3542
                level += diff;
3543
                level = level & 0xff; /* handle wrap round */
3544
                s->last_dc[component] = level;
3545
            } else {
3546
                s->rv10_first_dc_coded[component] = 1;
3547
            }
3548
          } else {
3549
                level = get_bits(&s->gb, 8);
3550
          }
3551
        }else{
3552
            level = get_bits(&s->gb, 8);
3553
            if((level&0x7F) == 0){
3554
                fprintf(stderr, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
3555
                return -1;
3556
            }
3557
            if (level == 255)
3558
                level = 128;
3559
        }
3560
        block[0] = level;
3561
        i = 1;
3562
    } else {
3563
        i = 0;
3564
    }
3565
    if (!coded) {
3566
        if (s->mb_intra && s->h263_aic)
3567
            goto not_coded;
3568
        s->block_last_index[n] = i - 1;
3569
        return 0;
3570
    }
3571

    
3572
    for(;;) {
3573
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3574
        if (code < 0){
3575
            fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3576
            return -1;
3577
        }
3578
        if (code == rl->n) {
3579
            /* escape */
3580
            last = get_bits1(&s->gb);
3581
            run = get_bits(&s->gb, 6);
3582
            level = (int8_t)get_bits(&s->gb, 8);
3583
            if(level == -128){
3584
                if (s->h263_rv10) {
3585
                    /* XXX: should patch encoder too */
3586
                    level = get_bits(&s->gb, 12);
3587
                    level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
3588
                }else{
3589
                    level = get_bits(&s->gb, 5);
3590
                    level += get_bits(&s->gb, 6)<<5;
3591
                    level= (level + ((-1)<<10)) ^ ((-1)<<10); //sign extension
3592
                }
3593
            }
3594
        } else {
3595
            run = rl->table_run[code];
3596
            level = rl->table_level[code];
3597
            last = code >= rl->last;
3598
            if (get_bits1(&s->gb))
3599
                level = -level;
3600
        }
3601
        i += run;
3602
        if (i >= 64){
3603
            fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
3604
            return -1;
3605
        }
3606
        j = scan_table[i];
3607
        block[j] = level;
3608
        if (last)
3609
            break;
3610
        i++;
3611
    }
3612
not_coded:    
3613
    if (s->mb_intra && s->h263_aic) {
3614
        h263_pred_acdc(s, block, n);
3615
        i = 63;
3616
    }
3617
    s->block_last_index[n] = i;
3618
    return 0;
3619
}
3620

    
3621
/**
3622
 * decodes the dc value.
3623
 * @param n block index (0-3 are luma, 4-5 are chroma)
3624
 * @param dir_ptr the prediction direction will be stored here
3625
 * @return the quantized dc
3626
 */
3627
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3628
{
3629
    int level, pred, code;
3630
    uint16_t *dc_val;
3631

    
3632
    if (n < 4) 
3633
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3634
    else 
3635
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3636
    if (code < 0 || code > 9 /* && s->nbit<9 */){
3637
        fprintf(stderr, "illegal dc vlc\n");
3638
        return -1;
3639
    }
3640
    if (code == 0) {
3641
        level = 0;
3642
    } else {
3643
        level = get_bits(&s->gb, code);
3644
        if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
3645
            level = - (level ^ ((1 << code) - 1));
3646
        if (code > 8){
3647
            if(get_bits1(&s->gb)==0){ /* marker */
3648
                if(s->error_resilience>=2){
3649
                    fprintf(stderr, "dc marker bit missing\n");
3650
                    return -1;
3651
                }
3652
            }
3653
        }
3654
    }
3655
    pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3656
    level += pred;
3657
    if (level < 0){
3658
        if(s->error_resilience>=3){
3659
            fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3660
            return -1;
3661
        }
3662
        level = 0;
3663
    }
3664
    if (n < 4) {
3665
        *dc_val = level * s->y_dc_scale;
3666
    } else {
3667
        *dc_val = level * s->c_dc_scale;
3668
    }
3669
    if(s->error_resilience>=3){
3670
        if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3671
            fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3672
            return -1;
3673
        }
3674
    }
3675
    return level;
3676
}
3677

    
3678
/**
3679
 * decodes a block.
3680
 * @return <0 if an error occured
3681
 */
3682
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3683
                              int n, int coded, int intra, int rvlc)
3684
{
3685
    int level, i, last, run;
3686
    int dc_pred_dir;
3687
    RLTable * rl;
3688
    RL_VLC_ELEM * rl_vlc;
3689
    const uint8_t * scan_table;
3690
    int qmul, qadd;
3691

    
3692
    //Note intra & rvlc should be optimized away if this is inlined
3693
    
3694
    if(intra) {
3695
        /* DC coef */
3696
        if(s->partitioned_frame){
3697
            level = s->dc_val[0][ s->block_index[n] ];
3698
            if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
3699
            else    level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
3700
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
3701
        }else{
3702
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3703
            if (level < 0)
3704
                return -1;
3705
        }
3706
        block[0] = level;
3707
        i = 0;
3708
        if (!coded) 
3709
            goto not_coded;
3710
        
3711
        if(rvlc){        
3712
            rl = &rvlc_rl_intra;
3713
            rl_vlc = rvlc_rl_intra.rl_vlc[0];
3714
        }else{
3715
            rl = &rl_intra;
3716
            rl_vlc = rl_intra.rl_vlc[0];
3717
        }
3718
        if (s->ac_pred) {
3719
            if (dc_pred_dir == 0) 
3720
                scan_table = s->intra_v_scantable.permutated; /* left */
3721
            else
3722
                scan_table = s->intra_h_scantable.permutated; /* top */
3723
        } else {
3724
            scan_table = s->intra_scantable.permutated;
3725
        }
3726
        qmul=1;
3727
        qadd=0;
3728
    } else {
3729
        i = -1;
3730
        if (!coded) {
3731
            s->block_last_index[n] = i;
3732
            return 0;
3733
        }
3734
        if(rvlc) rl = &rvlc_rl_inter;
3735
        else     rl = &rl_inter;
3736
   
3737
        scan_table = s->intra_scantable.permutated;
3738

    
3739
        if(s->mpeg_quant){
3740
            qmul=1;
3741
            qadd=0;
3742
            if(rvlc){        
3743
                rl_vlc = rvlc_rl_inter.rl_vlc[0];        
3744
            }else{
3745
                rl_vlc = rl_inter.rl_vlc[0];        
3746
            }
3747
        }else{
3748
            qmul = s->qscale << 1;
3749
            qadd = (s->qscale - 1) | 1;
3750
            if(rvlc){        
3751
                rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];        
3752
            }else{
3753
                rl_vlc = rl_inter.rl_vlc[s->qscale];        
3754
            }
3755
        }
3756
    }
3757
  {
3758
    OPEN_READER(re, &s->gb);
3759
    for(;;) {
3760
        UPDATE_CACHE(re, &s->gb);
3761
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3762
        if (level==0) {
3763
          /* escape */                
3764
          if(rvlc){
3765
                if(SHOW_UBITS(re, &s->gb, 1)==0){
3766
                    fprintf(stderr, "1. marker bit missing in rvlc esc\n");
3767
                    return -1;
3768
                }; SKIP_CACHE(re, &s->gb, 1);
3769
 
3770
                last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3771
                run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3772
                SKIP_COUNTER(re, &s->gb, 1+1+6);
3773
                UPDATE_CACHE(re, &s->gb);
3774
              
3775
                if(SHOW_UBITS(re, &s->gb, 1)==0){
3776
                    fprintf(stderr, "2. marker bit missing in rvlc esc\n");
3777
                    return -1;
3778
                }; SKIP_CACHE(re, &s->gb, 1);
3779
 
3780
                level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
3781
 
3782
                if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
3783
                    fprintf(stderr, "reverse esc missing\n");
3784
                    return -1;
3785
                }; SKIP_CACHE(re, &s->gb, 5);
3786

    
3787
                level=  level * qmul + qadd;
3788
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
3789
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
3790

    
3791
                i+= run + 1;
3792
                if(last) i+=192;    
3793
          }else{
3794
            int cache;
3795
            cache= GET_CACHE(re, &s->gb);
3796
            if (cache&0x80000000) {
3797
                if (cache&0x40000000) {
3798
                    /* third escape */
3799
                    SKIP_CACHE(re, &s->gb, 2);
3800
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3801
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3802
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
3803
                    UPDATE_CACHE(re, &s->gb);
3804

    
3805
                    if(SHOW_UBITS(re, &s->gb, 1)==0){
3806
                        fprintf(stderr, "1. marker bit missing in 3. esc\n");
3807
                        return -1;
3808
                    }; SKIP_CACHE(re, &s->gb, 1);
3809
                    
3810
                    level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3811
 
3812
                    if(SHOW_UBITS(re, &s->gb, 1)==0){
3813
                        fprintf(stderr, "2. marker bit missing in 3. esc\n");
3814
                        return -1;
3815
                    }; LAST_SKIP_CACHE(re, &s->gb, 1);
3816
                    
3817
                    SKIP_COUNTER(re, &s->gb, 1+12+1);
3818
                    
3819
                    if(level*s->qscale>1024 || level*s->qscale<-1024){
3820
                        fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3821
                        return -1;
3822
                    }
3823
#if 1 
3824
                    {
3825
                        const int abs_level= ABS(level);
3826
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
3827
                            const int run1= run - rl->max_run[last][abs_level] - 1;
3828
                            if(abs_level <= rl->max_level[last][run]){
3829
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3830
                                return -1;
3831
                            }
3832
                            if(s->error_resilience > FF_ER_COMPLIANT){
3833
                                if(abs_level <= rl->max_level[last][run]*2){
3834
                                    fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3835
                                    return -1;
3836
                                }
3837
                                if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3838
                                    fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3839
                                    return -1;
3840
                                }
3841
                            }
3842
                        }
3843
                    }
3844
#endif
3845
                    if (level>0) level= level * qmul + qadd;
3846
                    else         level= level * qmul - qadd;
3847

    
3848
                    i+= run + 1;
3849
                    if(last) i+=192;
3850
                } else {
3851
                    /* second escape */
3852
#if MIN_CACHE_BITS < 20
3853
                    LAST_SKIP_BITS(re, &s->gb, 2);
3854
                    UPDATE_CACHE(re, &s->gb);
3855
#else
3856
                    SKIP_BITS(re, &s->gb, 2);
3857
#endif
3858
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3859
                    i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3860
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3861
                    LAST_SKIP_BITS(re, &s->gb, 1);
3862
                }
3863
            } else {
3864
                /* first escape */
3865
#if MIN_CACHE_BITS < 19
3866
                LAST_SKIP_BITS(re, &s->gb, 1);
3867
                UPDATE_CACHE(re, &s->gb);
3868
#else
3869
                SKIP_BITS(re, &s->gb, 1);
3870
#endif
3871
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3872
                i+= run;
3873
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3874
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3875
                LAST_SKIP_BITS(re, &s->gb, 1);
3876
            }
3877
          }
3878
        } else {
3879
            i+= run;
3880
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3881
            LAST_SKIP_BITS(re, &s->gb, 1);
3882
        }
3883
        if (i > 62){
3884
            i-= 192;
3885
            if(i&(~63)){
3886
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3887
                return -1;
3888
            }
3889

    
3890
            block[scan_table[i]] = level;
3891
            break;
3892
        }
3893

    
3894
        block[scan_table[i]] = level;
3895
    }
3896
    CLOSE_READER(re, &s->gb);
3897
  }
3898
 not_coded:
3899
    if (s->mb_intra) {
3900
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
3901
        if (s->ac_pred) {
3902
            i = 63; /* XXX: not optimal */
3903
        }
3904
    }
3905
    s->block_last_index[n] = i;
3906
    return 0;
3907
}
3908

    
3909
/* most is hardcoded. should extend to handle all h263 streams */
3910
int h263_decode_picture_header(MpegEncContext *s)
3911
{
3912
    int format, width, height;
3913

    
3914
    /* picture start code */
3915
    if (get_bits(&s->gb, 22) != 0x20) {
3916
        fprintf(stderr, "Bad picture start code\n");
3917
        return -1;
3918
    }
3919
    /* temporal reference */
3920
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3921

    
3922
    /* PTYPE starts here */    
3923
    if (get_bits1(&s->gb) != 1) {
3924
        /* marker */
3925
        fprintf(stderr, "Bad marker\n");
3926
        return -1;
3927
    }
3928
    if (get_bits1(&s->gb) != 0) {
3929
        fprintf(stderr, "Bad H263 id\n");
3930
        return -1;        /* h263 id */
3931
    }
3932
    skip_bits1(&s->gb);        /* split screen off */
3933
    skip_bits1(&s->gb);        /* camera  off */
3934
    skip_bits1(&s->gb);        /* freeze picture release off */
3935

    
3936
    /* Reset GOB number */
3937
    s->gob_number = 0;
3938
        
3939
    format = get_bits(&s->gb, 3);
3940
    /*
3941
        0    forbidden
3942
        1    sub-QCIF
3943
        10   QCIF
3944
        7        extended PTYPE (PLUSPTYPE)
3945
    */
3946

    
3947
    if (format != 7 && format != 6) {
3948
        s->h263_plus = 0;
3949
        /* H.263v1 */
3950
        width = h263_format[format][0];
3951
        height = h263_format[format][1];
3952
        if (!width)
3953
            return -1;
3954
        
3955
        s->width = width;
3956
        s->height = height;
3957
        s->pict_type = I_TYPE + get_bits1(&s->gb);
3958

    
3959
        s->unrestricted_mv = get_bits1(&s->gb); 
3960
        s->h263_long_vectors = s->unrestricted_mv;
3961

    
3962
        if (get_bits1(&s->gb) != 0) {
3963
            fprintf(stderr, "H263 SAC not supported\n");
3964
            return -1;        /* SAC: off */
3965
        }
3966
        if (get_bits1(&s->gb) != 0) {
3967
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3968
        }   
3969
        
3970
        if (get_bits1(&s->gb) != 0) {
3971
            fprintf(stderr, "H263 PB frame not supported\n");
3972
            return -1;        /* not PB frame */
3973
        }
3974
        s->qscale = get_bits(&s->gb, 5);
3975
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
3976
    } else {
3977
        int ufep;
3978
        
3979
        /* H.263v2 */
3980
        s->h263_plus = 1;
3981
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3982

    
3983
        /* ufep other than 0 and 1 are reserved */        
3984
        if (ufep == 1) {
3985
            /* OPPTYPE */       
3986
            format = get_bits(&s->gb, 3);
3987
            dprintf("ufep=1, format: %d\n", format);
3988
            skip_bits(&s->gb,1); /* Custom PCF */
3989
            s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3990
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3991
            if (get_bits1(&s->gb) != 0) {
3992
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3993
            }
3994
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3995
                s->h263_aic = 1;
3996
            }
3997
            
3998
            skip_bits(&s->gb, 7);
3999
            /* these are the 7 bits: (in order of appearence  */
4000
            /* Deblocking Filter */
4001
            /* Slice Structured */
4002
            /* Reference Picture Selection */
4003
            /* Independent Segment Decoding */
4004
            /* Alternative Inter VLC */
4005
            /* Modified Quantization */
4006
            /* Prevent start code emulation */
4007

    
4008
            skip_bits(&s->gb, 3); /* Reserved */
4009
        } else if (ufep != 0) {
4010
            fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
4011
            return -1;
4012
        }
4013
            
4014
        /* MPPTYPE */
4015
        s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
4016
        dprintf("pict_type: %d\n", s->pict_type);
4017
        if (s->pict_type != I_TYPE &&
4018
            s->pict_type != P_TYPE)
4019
            return -1;
4020
        skip_bits(&s->gb, 2);
4021
        s->no_rounding = get_bits1(&s->gb);
4022
        dprintf("RTYPE: %d\n", s->no_rounding);
4023
        skip_bits(&s->gb, 4);
4024
        
4025
        /* Get the picture dimensions */
4026
        if (ufep) {
4027
            if (format == 6) {
4028
                /* Custom Picture Format (CPFMT) */
4029
                s->aspect_ratio_info = get_bits(&s->gb, 4);
4030
                dprintf("aspect: %d\n", s->aspect_ratio_info);
4031
                /* aspect ratios:
4032
                0 - forbidden
4033
                1 - 1:1
4034
                2 - 12:11 (CIF 4:3)
4035
                3 - 10:11 (525-type 4:3)
4036
                4 - 16:11 (CIF 16:9)
4037
                5 - 40:33 (525-type 16:9)
4038
                6-14 - reserved
4039
                */
4040
                width = (get_bits(&s->gb, 9) + 1) * 4;
4041
                skip_bits1(&s->gb);
4042
                height = get_bits(&s->gb, 9) * 4;
4043
                dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
4044
                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
4045
                    /* aspected dimensions */
4046
                    s->aspected_width = get_bits(&s->gb, 8);
4047
                    s->aspected_height = get_bits(&s->gb, 8);
4048
                }else{
4049
                    s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4050
                    s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4051
                }
4052
            } else {
4053
                width = h263_format[format][0];
4054
                height = h263_format[format][1];
4055
            }
4056
            if ((width == 0) || (height == 0))
4057
                return -1;
4058
            s->width = width;
4059
            s->height = height;
4060
            if (s->umvplus) {
4061
                if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
4062
                    skip_bits1(&s->gb); 
4063
            }
4064
        }
4065
            
4066
        s->qscale = get_bits(&s->gb, 5);
4067
    }
4068
    /* PEI */
4069
    while (get_bits1(&s->gb) != 0) {
4070
        skip_bits(&s->gb, 8);
4071
    }
4072
    s->f_code = 1;
4073
    
4074
    if(s->h263_aic){
4075
         s->y_dc_scale_table= 
4076
         s->c_dc_scale_table= h263_aic_dc_scale_table;
4077
    }else{
4078
        s->y_dc_scale_table=
4079
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4080
    }
4081

    
4082
    return 0;
4083
}
4084

    
4085
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
4086
{
4087
    int i;
4088
    int a= 2<<s->sprite_warping_accuracy;
4089
    int rho= 3-s->sprite_warping_accuracy;
4090
    int r=16/a;
4091
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
4092
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
4093
    int sprite_ref[4][2];
4094
    int virtual_ref[2][2];
4095
    int w2, h2, w3, h3;
4096
    int alpha=0, beta=0;
4097
    int w= s->width;
4098
    int h= s->height;
4099
    int min_ab;
4100

    
4101
    for(i=0; i<s->num_sprite_warping_points; i++){
4102
        int length;
4103
        int x=0, y=0;
4104

    
4105
        length= get_vlc(&s->gb, &sprite_trajectory);
4106
        if(length){
4107
            x= get_bits(&s->gb, length);
4108

    
4109
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
4110
                x = - (x ^ ((1 << length) - 1));
4111
        }
4112
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4113
        
4114
        length= get_vlc(&s->gb, &sprite_trajectory);
4115
        if(length){
4116
            y=get_bits(&s->gb, length);
4117

    
4118
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
4119
                y = - (y ^ ((1 << length) - 1));
4120
        }
4121
        skip_bits1(&s->gb); /* marker bit */
4122
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4123
        d[i][0]= x;
4124
        d[i][1]= y;
4125
    }
4126

    
4127
    while((1<<alpha)<w) alpha++;
4128
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
4129
    w2= 1<<alpha;
4130
    h2= 1<<beta;
4131

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

    
4300
static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
4301
    int hours, minutes, seconds;
4302

    
4303
    hours= get_bits(gb, 5);
4304
    minutes= get_bits(gb, 6);
4305
    skip_bits1(gb);
4306
    seconds= get_bits(gb, 6);
4307

    
4308
    s->time_base= seconds + 60*(minutes + 60*hours);
4309

    
4310
    skip_bits1(gb);
4311
    skip_bits1(gb);
4312
    
4313
    return 0;
4314
}
4315

    
4316
static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4317
    int width, height, vo_ver_id;
4318

    
4319
    /* vol header */
4320
    skip_bits(gb, 1); /* random access */
4321
    s->vo_type= get_bits(gb, 8);
4322
    if (get_bits1(gb) != 0) { /* is_ol_id */
4323
        vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4324
        skip_bits(gb, 3); /* vo_priority */
4325
    } else {
4326
        vo_ver_id = 1;
4327
    }
4328
//printf("vo type:%d\n",s->vo_type);
4329
    s->aspect_ratio_info= get_bits(gb, 4);
4330
    if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){            
4331
        s->aspected_width = get_bits(gb, 8); // par_width
4332
        s->aspected_height = get_bits(gb, 8); // par_height
4333
    }else{
4334
        s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4335
        s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4336
    }
4337

    
4338
    if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4339
        int chroma_format= get_bits(gb, 2);
4340
        if(chroma_format!=1){
4341
            printf("illegal chroma format\n");
4342
        }
4343
        s->low_delay= get_bits1(gb);
4344
        if(get_bits1(gb)){ /* vbv parameters */
4345
            get_bits(gb, 15);        /* first_half_bitrate */
4346
            skip_bits1(gb);        /* marker */
4347
            get_bits(gb, 15);        /* latter_half_bitrate */
4348
            skip_bits1(gb);        /* marker */
4349
            get_bits(gb, 15);        /* first_half_vbv_buffer_size */
4350
            skip_bits1(gb);        /* marker */
4351
            get_bits(gb, 3);        /* latter_half_vbv_buffer_size */
4352
            get_bits(gb, 11);        /* first_half_vbv_occupancy */
4353
            skip_bits1(gb);        /* marker */
4354
            get_bits(gb, 15);        /* latter_half_vbv_occupancy */
4355
            skip_bits1(gb);        /* marker */               
4356
        }
4357
    }else{
4358
        // set low delay flag only once so the smart? low delay detection wont be overriden
4359
        if(s->picture_number==0)
4360
            s->low_delay=0;
4361
    }
4362

    
4363
    s->shape = get_bits(gb, 2); /* vol shape */
4364
    if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4365
    if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4366
        printf("Gray shape not supported\n");
4367
        skip_bits(gb, 4);  //video_object_layer_shape_extension
4368
    }
4369

    
4370
    skip_bits1(gb);   /* marker */
4371
    
4372
    s->time_increment_resolution = get_bits(gb, 16);
4373
    
4374
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4375
    if (s->time_increment_bits < 1)
4376
        s->time_increment_bits = 1;
4377
    skip_bits1(gb);   /* marker */
4378

    
4379
    if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
4380
        skip_bits(gb, s->time_increment_bits);
4381
    }
4382

    
4383
    if (s->shape != BIN_ONLY_SHAPE) {
4384
        if (s->shape == RECT_SHAPE) {
4385
            skip_bits1(gb);   /* marker */
4386
            width = get_bits(gb, 13);
4387
            skip_bits1(gb);   /* marker */
4388
            height = get_bits(gb, 13);
4389
            skip_bits1(gb);   /* marker */
4390
            if(width && height){ /* they should be non zero but who knows ... */
4391
                s->width = width;
4392
                s->height = height;
4393
//                printf("width/height: %d %d\n", width, height);
4394
            }
4395
        }
4396
        
4397
        s->progressive_sequence= get_bits1(gb)^1;
4398
        if(!get_bits1(gb)) printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
4399
        if (vo_ver_id == 1) {
4400
            s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4401
        } else {
4402
            s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4403
        }
4404
        if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4405
        if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4406
            if(s->vol_sprite_usage==STATIC_SPRITE){
4407
                s->sprite_width = get_bits(gb, 13);
4408
                skip_bits1(gb); /* marker */
4409
                s->sprite_height= get_bits(gb, 13);
4410
                skip_bits1(gb); /* marker */
4411
                s->sprite_left  = get_bits(gb, 13);
4412
                skip_bits1(gb); /* marker */
4413
                s->sprite_top   = get_bits(gb, 13);
4414
                skip_bits1(gb); /* marker */
4415
            }
4416
            s->num_sprite_warping_points= get_bits(gb, 6);
4417
            s->sprite_warping_accuracy = get_bits(gb, 2);
4418
            s->sprite_brightness_change= get_bits1(gb);
4419
            if(s->vol_sprite_usage==STATIC_SPRITE)
4420
                s->low_latency_sprite= get_bits1(gb);            
4421
        }
4422
        // FIXME sadct disable bit if verid!=1 && shape not rect
4423
        
4424
        if (get_bits1(gb) == 1) {   /* not_8_bit */
4425
            s->quant_precision = get_bits(gb, 4); /* quant_precision */
4426
            if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4427
            if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4428
        } else {
4429
            s->quant_precision = 5;
4430
        }
4431
        
4432
        // FIXME a bunch of grayscale shape things
4433

    
4434
        if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4435
            int i, v;
4436
            
4437
            /* load default matrixes */
4438
            for(i=0; i<64; i++){
4439
                int j= s->dsp.idct_permutation[i];
4440
                v= ff_mpeg4_default_intra_matrix[i];
4441
                s->intra_matrix[j]= v;
4442
                s->chroma_intra_matrix[j]= v;
4443
                
4444
                v= ff_mpeg4_default_non_intra_matrix[i];
4445
                s->inter_matrix[j]= v;
4446
                s->chroma_inter_matrix[j]= v;
4447
            }
4448

    
4449
            /* load custom intra matrix */
4450
            if(get_bits1(gb)){
4451
                int last=0;
4452
                for(i=0; i<64; i++){
4453
                    int j;
4454
                    v= get_bits(gb, 8);
4455
                    if(v==0) break;
4456
                    
4457
                    last= v;
4458
                    j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4459
                    s->intra_matrix[j]= v;
4460
                    s->chroma_intra_matrix[j]= v;
4461
                }
4462

    
4463
                /* replicate last value */
4464
                for(; i<64; i++){
4465
                    int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4466
                    s->intra_matrix[j]= v;
4467
                    s->chroma_intra_matrix[j]= v;
4468
                }
4469
            }
4470

    
4471
            /* load custom non intra matrix */
4472
            if(get_bits1(gb)){
4473
                int last=0;
4474
                for(i=0; i<64; i++){
4475
                    int j;
4476
                    v= get_bits(gb, 8);
4477
                    if(v==0) break;
4478

    
4479
                    last= v;
4480
                    j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4481
                    s->inter_matrix[j]= v;
4482
                    s->chroma_inter_matrix[j]= v;
4483
                }
4484

    
4485
                /* replicate last value */
4486
                for(; i<64; i++){
4487
                    int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4488
                    s->inter_matrix[j]= last;
4489
                    s->chroma_inter_matrix[j]= last;
4490
                }
4491
            }
4492

    
4493
            // FIXME a bunch of grayscale shape things
4494
        }
4495

    
4496
        if(vo_ver_id != 1)
4497
             s->quarter_sample= get_bits1(gb);
4498
        else s->quarter_sample=0;
4499

    
4500
        if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4501

    
4502
        s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4503

    
4504
        s->data_partitioning= get_bits1(gb);
4505
        if(s->data_partitioning){
4506
            s->rvlc= get_bits1(gb);
4507
        }
4508
        
4509
        if(vo_ver_id != 1) {
4510
            s->new_pred= get_bits1(gb);
4511
            if(s->new_pred){
4512
                printf("new pred not supported\n");
4513
                skip_bits(gb, 2); /* requested upstream message type */
4514
                skip_bits1(gb); /* newpred segment type */
4515
            }
4516
            s->reduced_res_vop= get_bits1(gb);
4517
            if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4518
        }
4519
        else{
4520
            s->new_pred=0;
4521
            s->reduced_res_vop= 0;
4522
        }
4523

    
4524
        s->scalability= get_bits1(gb);
4525

    
4526
        if (s->scalability) {
4527
            GetBitContext bak= *gb;
4528
            int ref_layer_id;
4529
            int ref_layer_sampling_dir;
4530
            int h_sampling_factor_n;
4531
            int h_sampling_factor_m;
4532
            int v_sampling_factor_n;
4533
            int v_sampling_factor_m;
4534
            
4535
            s->hierachy_type= get_bits1(gb);
4536
            ref_layer_id= get_bits(gb, 4);
4537
            ref_layer_sampling_dir= get_bits1(gb);
4538
            h_sampling_factor_n= get_bits(gb, 5);
4539
            h_sampling_factor_m= get_bits(gb, 5);
4540
            v_sampling_factor_n= get_bits(gb, 5);
4541
            v_sampling_factor_m= get_bits(gb, 5);
4542
            s->enhancement_type= get_bits1(gb);
4543
            
4544
            if(   h_sampling_factor_n==0 || h_sampling_factor_m==0 
4545
               || v_sampling_factor_n==0 || v_sampling_factor_m==0){
4546
               
4547
//                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4548
                s->scalability=0;
4549
               
4550
                *gb= bak;
4551
            }else
4552
                printf("scalability not supported\n");
4553
            
4554
            // bin shape stuff FIXME
4555
        }
4556
    }
4557
    return 0;
4558
}
4559

    
4560
/**
4561
 * decodes the user data stuff in the header.
4562
 * allso inits divx/xvid/lavc_version/build
4563
 */
4564
static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
4565
    char buf[256];
4566
    int i;
4567
    int e;
4568
    int ver, build, ver2, ver3;
4569

    
4570
    buf[0]= show_bits(gb, 8);
4571
    for(i=1; i<256; i++){
4572
        buf[i]= show_bits(gb, 16)&0xFF;
4573
        if(buf[i]==0) break;
4574
        skip_bits(gb, 8);
4575
    }
4576
    buf[255]=0;
4577
    
4578
    /* divx detection */
4579
    e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
4580
    if(e!=2)
4581
        e=sscanf(buf, "DivX%db%d", &ver, &build);
4582
    if(e==2){
4583
        s->divx_version= ver;
4584
        s->divx_build= build;
4585
        if(s->picture_number==0){
4586
            printf("This file was encoded with DivX%d Build%d\n", ver, build);
4587
        }
4588
    }
4589
    
4590
    /* ffmpeg detection */
4591
    e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
4592
    if(e!=4)
4593
        e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); 
4594
    if(e!=4){
4595
        if(strcmp(buf, "ffmpeg")==0){
4596
            s->ffmpeg_version= 0x000406;
4597
            s->lavc_build= 4600;
4598
        }
4599
    }
4600
    if(e==4){
4601
        s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
4602
        s->lavc_build= build;
4603
        if(s->picture_number==0)
4604
            printf("This file was encoded with libavcodec build %d\n", build);
4605
    }
4606
    
4607
    /* xvid detection */
4608
    e=sscanf(buf, "XviD%d", &build);
4609
    if(e==1){
4610
        s->xvid_build= build;
4611
        if(s->picture_number==0)
4612
            printf("This file was encoded with XviD build %d\n", build);
4613
    }
4614

    
4615
//printf("User Data: %s\n", buf);
4616
    return 0;
4617
}
4618

    
4619
static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
4620
    int time_incr, time_increment;
4621

    
4622
    s->pict_type = get_bits(gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
4623
    if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
4624
        printf("low_delay flag set, but shouldnt, clearing it\n");
4625
        s->low_delay=0;
4626
    }
4627
 
4628
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
4629
    if(s->partitioned_frame)
4630
        s->decode_mb= mpeg4_decode_partitioned_mb;
4631
    else
4632
        s->decode_mb= ff_h263_decode_mb;
4633

    
4634
    if(s->time_increment_resolution==0){
4635
        s->time_increment_resolution=1;
4636
//        fprintf(stderr, "time_increment_resolution is illegal\n");
4637
    }
4638
    time_incr=0;
4639
    while (get_bits1(gb) != 0) 
4640
        time_incr++;
4641

    
4642
    check_marker(gb, "before time_increment");
4643
    
4644
    if(s->picture_number==0 && (show_bits(gb, s->time_increment_bits+1)&1)==0){
4645
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4646
        
4647

    
4648
        for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
4649
            if(show_bits(gb, s->time_increment_bits+1)&1) break;
4650
        }
4651
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
4652
    }
4653
    
4654
    time_increment= get_bits(gb, s->time_increment_bits);
4655
//printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4656
    if(s->pict_type!=B_TYPE){
4657
        s->last_time_base= s->time_base;
4658
        s->time_base+= time_incr;
4659
        s->time= s->time_base*s->time_increment_resolution + time_increment;
4660
        if(s->workaround_bugs&FF_BUG_UMP4){
4661
            if(s->time < s->last_non_b_time){
4662
//                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4663
                s->time_base++;
4664
                s->time+= s->time_increment_resolution;
4665
            }
4666
        }
4667
        s->pp_time= s->time - s->last_non_b_time;
4668
        s->last_non_b_time= s->time;
4669
    }else{
4670
        s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4671
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4672
        if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4673
//            printf("messed up order, seeking?, skiping current b frame\n");
4674
            return FRAME_SKIPED;
4675
        }
4676
        
4677
        if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4678
        if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4679
//printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4680
        s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame) 
4681
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4682
        s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame) 
4683
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4684
    }
4685
    
4686
    s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4687
    if(s->avctx->debug&FF_DEBUG_PTS)
4688
        printf("MPEG4 PTS: %f\n", s->current_picture.pts/(1000.0*1000.0));
4689
    
4690
    check_marker(gb, "before vop_coded");
4691
    
4692
    /* vop coded */
4693
    if (get_bits1(gb) != 1){