Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 7604246d

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

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

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

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

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

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

    
83
extern uint32_t inverse[256];
84

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

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

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

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

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

    
114

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

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

    
134
#ifdef CONFIG_ENCODERS
135

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

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

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

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

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

    
161
    align_put_bits(&s->pb);
162

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
404
#endif //CONFIG_ENCODERS
405

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

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

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

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

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

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

    
545
            if(interleaved_stats){
546
                bits= get_bit_count(&s->pb);
547
                s->misc_bits+= bits - s->last_bits;
548
                s->last_bits=bits;
549
            }
550

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1210
}
1211

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

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

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

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

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

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

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

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

    
1298
#ifdef CONFIG_ENCODERS
1299

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

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

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

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

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

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

    
1349
    }
1350
}
1351

    
1352
#endif //CONFIG_ENCODERS
1353

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

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

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

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

    
1447
        init_uni_dc_tab();
1448

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

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

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

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

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

    
1561
#ifdef CONFIG_ENCODERS
1562

    
1563
/***************************************************/
1564
/**
1565
 * add mpeg4 stuffing bits (01...1)
1566
 */
1567
void ff_mpeg4_stuffing(PutBitContext * pbc)
1568
{
1569
    int length;
1570
    put_bits(pbc, 1, 0);
1571
    length= (-get_bit_count(pbc))&7;
1572
    if(length) put_bits(pbc, length, (1<<length)-1);
1573
}
1574

    
1575
/* must be called before writing the header */
1576
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1577
    int time_div, time_mod;
1578

    
1579
    if(s->pict_type==I_TYPE){ //we will encode a vol header
1580
        s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1581
        if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1582

    
1583
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1584
    }
1585
    
1586
    if(s->current_picture.pts)
1587
        s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1588
    else
1589
        s->time= picture_number*(int64_t)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1590
    time_div= s->time/s->time_increment_resolution;
1591
    time_mod= s->time%s->time_increment_resolution;
1592

    
1593
    if(s->pict_type==B_TYPE){
1594
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1595
    }else{
1596
        s->last_time_base= s->time_base;
1597
        s->time_base= time_div;
1598
        s->pp_time= s->time - s->last_non_b_time;
1599
        s->last_non_b_time= s->time;
1600
    }
1601
}
1602

    
1603
static void mpeg4_encode_gop_header(MpegEncContext * s){
1604
    int hours, minutes, seconds;
1605
    
1606
    put_bits(&s->pb, 16, 0);
1607
    put_bits(&s->pb, 16, GOP_STARTCODE);
1608
    
1609
    seconds= s->time/s->time_increment_resolution;
1610
    minutes= seconds/60; seconds %= 60;
1611
    hours= minutes/60; minutes %= 60;
1612
    hours%=24;
1613

    
1614
    put_bits(&s->pb, 5, hours);
1615
    put_bits(&s->pb, 6, minutes);
1616
    put_bits(&s->pb, 1, 1);
1617
    put_bits(&s->pb, 6, seconds);
1618
    
1619
    put_bits(&s->pb, 1, 0); //closed gov == NO
1620
    put_bits(&s->pb, 1, 0); //broken link == NO
1621

    
1622
    ff_mpeg4_stuffing(&s->pb);
1623
}
1624

    
1625
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1626
    int profile_and_level_indication;
1627
    int vo_ver_id;
1628
    
1629
    if(s->max_b_frames || s->quarter_sample){
1630
        profile_and_level_indication= 0xF1; // adv simple level 1
1631
        vo_ver_id= 5;
1632
    }else{
1633
        profile_and_level_indication= 0x01; // simple level 1
1634
        vo_ver_id= 1;
1635
    }
1636
    //FIXME levels
1637

    
1638
    put_bits(&s->pb, 16, 0);
1639
    put_bits(&s->pb, 16, VOS_STARTCODE);
1640
    
1641
    put_bits(&s->pb, 8, profile_and_level_indication);
1642
    
1643
    put_bits(&s->pb, 16, 0);
1644
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1645
    
1646
    put_bits(&s->pb, 1, 1);
1647
        put_bits(&s->pb, 4, vo_ver_id);
1648
        put_bits(&s->pb, 3, 1); //priority
1649
 
1650
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
1651
    
1652
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1653

    
1654
    ff_mpeg4_stuffing(&s->pb);
1655
}
1656

    
1657
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
1658
{
1659
    int vo_ver_id;
1660
    char buf[255];
1661

    
1662
    if(s->max_b_frames || s->quarter_sample){
1663
        vo_ver_id= 5;
1664
        s->vo_type= ADV_SIMPLE_VO_TYPE;
1665
    }else{
1666
        vo_ver_id= 1;
1667
        s->vo_type= SIMPLE_VO_TYPE;
1668
    }
1669

    
1670
    put_bits(&s->pb, 16, 0);
1671
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
1672
    put_bits(&s->pb, 16, 0);
1673
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
1674

    
1675
    put_bits(&s->pb, 1, 0);                /* random access vol */
1676
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1677
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1678
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1679
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1680
    
1681
    float_aspect_to_info(s, s->avctx->aspect_ratio);
1682

    
1683
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1684
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1685
    {
1686
        put_bits(&s->pb, 8, s->aspected_width);
1687
        put_bits(&s->pb, 8, s->aspected_height);
1688
    }
1689

    
1690
    if(s->low_delay){
1691
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1692
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1693
        put_bits(&s->pb, 1, s->low_delay);
1694
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1695
    }else{
1696
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1697
    }
1698

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

    
1725
    if (vo_ver_id != 1)
1726
        put_bits(&s->pb, 1, s->quarter_sample);
1727
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1728
    s->resync_marker= s->rtp_mode;
1729
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1730
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1731
    if(s->data_partitioning){
1732
        put_bits(&s->pb, 1, 0);                /* no rvlc */
1733
    }
1734

    
1735
    if (vo_ver_id != 1){
1736
        put_bits(&s->pb, 1, 0);                /* newpred */
1737
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1738
    }
1739
    put_bits(&s->pb, 1, 0);                /* scalability */
1740
    
1741
    ff_mpeg4_stuffing(&s->pb);
1742

    
1743
    /* user data */
1744
    if(!ff_bit_exact){
1745
        put_bits(&s->pb, 16, 0);
1746
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1747
        sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1748
        put_string(&s->pb, buf);
1749
        ff_mpeg4_stuffing(&s->pb);
1750
    }
1751
}
1752

    
1753
/* write mpeg4 VOP header */
1754
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1755
{
1756
    int time_incr;
1757
    int time_div, time_mod;
1758
    
1759
    if(s->pict_type==I_TYPE){
1760
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
1761
            mpeg4_encode_visual_object_header(s);
1762
            mpeg4_encode_vol_header(s, 0, 0);
1763
        }
1764
        mpeg4_encode_gop_header(s);
1765
    }
1766
    
1767
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1768

    
1769
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1770
    
1771
    put_bits(&s->pb, 16, 0);                /* vop header */
1772
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
1773
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1774

    
1775
    time_div= s->time/s->time_increment_resolution;
1776
    time_mod= s->time%s->time_increment_resolution;
1777
    time_incr= time_div - s->last_time_base;
1778
    while(time_incr--)
1779
        put_bits(&s->pb, 1, 1);
1780
        
1781
    put_bits(&s->pb, 1, 0);
1782

    
1783
    put_bits(&s->pb, 1, 1);        /* marker */
1784
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1785
    put_bits(&s->pb, 1, 1);        /* marker */
1786
    put_bits(&s->pb, 1, 1);        /* vop coded */
1787
    if (    s->pict_type == P_TYPE 
1788
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1789
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1790
    }
1791
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1792
    if(!s->progressive_sequence){
1793
         put_bits(&s->pb, 1, s->top_field_first);
1794
         put_bits(&s->pb, 1, s->alternate_scan);
1795
    }
1796
    //FIXME sprite stuff
1797

    
1798
    put_bits(&s->pb, 5, s->qscale);
1799

    
1800
    if (s->pict_type != I_TYPE)
1801
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1802
    if (s->pict_type == B_TYPE)
1803
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1804
    //    printf("****frame %d\n", picture_number);
1805

    
1806
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
1807
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1808
     s->h_edge_pos= s->width;
1809
     s->v_edge_pos= s->height;
1810
}
1811

    
1812
#endif //CONFIG_ENCODERS
1813

    
1814
/**
1815
 * change qscale by given dquant and update qscale dependant variables.
1816
 */
1817
static void change_qscale(MpegEncContext * s, int dquant)
1818
{
1819
    s->qscale += dquant;
1820

    
1821
    if (s->qscale < 1)
1822
        s->qscale = 1;
1823
    else if (s->qscale > 31)
1824
        s->qscale = 31;
1825

    
1826
    s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1827
    s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1828
}
1829

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

    
1843
    /* find prediction */
1844
    if (n < 4) {
1845
        scale = s->y_dc_scale;
1846
    } else {
1847
        scale = s->c_dc_scale;
1848
    }
1849
    wrap= s->block_wrap[n];
1850
    dc_val = s->dc_val[0] + s->block_index[n];
1851

    
1852
    /* B C
1853
     * A X 
1854
     */
1855
    a = dc_val[ - 1];
1856
    b = dc_val[ - 1 - wrap];
1857
    c = dc_val[ - wrap];
1858

    
1859
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
1860
    if(s->first_slice_line && n!=3){
1861
        if(n!=2) b=c= 1024;
1862
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
1863
    }
1864
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
1865
        if(n==0 || n==4 || n==5)
1866
            b=1024;
1867
    }
1868

    
1869
    if (abs(a - b) < abs(b - c)) {
1870
        pred = c;
1871
        *dir_ptr = 1; /* top */
1872
    } else {
1873
        pred = a;
1874
        *dir_ptr = 0; /* left */
1875
    }
1876
    /* we assume pred is positive */
1877
#ifdef ARCH_X86
1878
        asm volatile (
1879
                "xorl %%edx, %%edx        \n\t"
1880
                "mul %%ecx                \n\t"
1881
                : "=d" (pred), "=a"(dummy)
1882
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1883
        );
1884
#else
1885
    pred = (pred + (scale >> 1)) / scale;
1886
#endif
1887

    
1888
    /* prepare address for prediction update */
1889
    *dc_val_ptr = &dc_val[0];
1890

    
1891
    return pred;
1892
}
1893

    
1894
/**
1895
 * predicts the ac.
1896
 * @param n block index (0-3 are luma, 4-5 are chroma)
1897
 * @param dir the ac prediction direction
1898
 */
1899
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
1900
                   int dir)
1901
{
1902
    int i;
1903
    int16_t *ac_val, *ac_val1;
1904
    int8_t * const qscale_table= s->current_picture.qscale_table;
1905

    
1906
    /* find prediction */
1907
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1908
    ac_val1 = ac_val;
1909
    if (s->ac_pred) {
1910
        if (dir == 0) {
1911
            const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1912
            /* left prediction */
1913
            ac_val -= 16;
1914
            
1915
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1916
                /* same qscale */
1917
                for(i=1;i<8;i++) {
1918
                    block[s->idct_permutation[i<<3]] += ac_val[i];
1919
                }
1920
            }else{
1921
                /* different qscale, we must rescale */
1922
                for(i=1;i<8;i++) {
1923
                    block[s->idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1924
                }
1925
            }
1926
        } else {
1927
            const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1928
            /* top prediction */
1929
            ac_val -= 16 * s->block_wrap[n];
1930

    
1931
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1932
                /* same qscale */
1933
                for(i=1;i<8;i++) {
1934
                    block[s->idct_permutation[i]] += ac_val[i + 8];
1935
                }
1936
            }else{
1937
                /* different qscale, we must rescale */
1938
                for(i=1;i<8;i++) {
1939
                    block[s->idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1940
                }
1941
            }
1942
        }
1943
    }
1944
    /* left copy */
1945
    for(i=1;i<8;i++)
1946
        ac_val1[i    ] = block[s->idct_permutation[i<<3]];
1947

    
1948
    /* top copy */
1949
    for(i=1;i<8;i++)
1950
        ac_val1[8 + i] = block[s->idct_permutation[i   ]];
1951

    
1952
}
1953

    
1954
#ifdef CONFIG_ENCODERS
1955

    
1956
static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
1957
                              int dir)
1958
{
1959
    int i;
1960
    int16_t *ac_val;
1961
    int8_t * const qscale_table= s->current_picture.qscale_table;
1962

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

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

    
2025
    if (n < 4) {
2026
        /* luminance */
2027
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2028
    } else {
2029
        /* chrominance */
2030
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2031
    }
2032

    
2033
    /* encode remaining bits */
2034
    if (size > 0) {
2035
        if (level < 0)
2036
            level = (-level) ^ ((1 << size) - 1);
2037
        put_bits(&s->pb, size, level);
2038
        if (size > 8)
2039
            put_bits(&s->pb, 1, 1);
2040
    }
2041
#endif
2042
}
2043

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

    
2060
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2061
        /* mpeg4 based DC predictor */
2062
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2063
        if(last_index<1) return;
2064
        i = 1;
2065
        rl = &rl_intra;
2066
        bits_tab= uni_mpeg4_intra_rl_bits;
2067
        len_tab = uni_mpeg4_intra_rl_len;
2068
    } else {
2069
        if(last_index<0) return;
2070
        i = 0;
2071
        rl = &rl_inter;
2072
        bits_tab= uni_mpeg4_inter_rl_bits;
2073
        len_tab = uni_mpeg4_inter_rl_len;
2074
    }
2075

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

    
2164
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2165
                               uint8_t *scan_table)
2166
{
2167
    int i, last_non_zero;
2168
    const RLTable *rl;
2169
    uint8_t *len_tab;
2170
    const int last_index = s->block_last_index[n];
2171
    int len=0;
2172

    
2173
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2174
        /* mpeg4 based DC predictor */
2175
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2176
        if(last_index<1) return len;
2177
        i = 1;
2178
        rl = &rl_intra;
2179
        len_tab = uni_mpeg4_intra_rl_len;
2180
    } else {
2181
        if(last_index<0) return 0;
2182
        i = 0;
2183
        rl = &rl_inter;
2184
        len_tab = uni_mpeg4_inter_rl_len;
2185
    }
2186

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

    
2218
#endif
2219

    
2220

    
2221
/***********************************************/
2222
/* decoding */
2223

    
2224
static VLC intra_MCBPC_vlc;
2225
static VLC inter_MCBPC_vlc;
2226
static VLC cbpy_vlc;
2227
static VLC mv_vlc;
2228
static VLC dc_lum, dc_chrom;
2229
static VLC sprite_trajectory;
2230
static VLC mb_type_b_vlc;
2231

    
2232
void init_vlc_rl(RLTable *rl)
2233
{
2234
    int i, q;
2235
    
2236
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2237
             &rl->table_vlc[0][1], 4, 2,
2238
             &rl->table_vlc[0][0], 4, 2);
2239

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

    
2279
/* init vlcs */
2280

    
2281
/* XXX: find a better solution to handle static init */
2282
void h263_decode_init_vlc(MpegEncContext *s)
2283
{
2284
    static int done = 0;
2285

    
2286
    if (!done) {
2287
        done = 1;
2288

    
2289
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8, 
2290
                 intra_MCBPC_bits, 1, 1,
2291
                 intra_MCBPC_code, 1, 1);
2292
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25, 
2293
                 inter_MCBPC_bits, 1, 1,
2294
                 inter_MCBPC_code, 1, 1);
2295
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2296
                 &cbpy_tab[0][1], 2, 1,
2297
                 &cbpy_tab[0][0], 2, 1);
2298
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2299
                 &mvtab[0][1], 2, 1,
2300
                 &mvtab[0][0], 2, 1);
2301
        init_rl(&rl_inter);
2302
        init_rl(&rl_intra);
2303
        init_rl(&rl_intra_aic);
2304
        init_vlc_rl(&rl_inter);
2305
        init_vlc_rl(&rl_intra);
2306
        init_vlc_rl(&rl_intra_aic);
2307
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2308
                 &DCtab_lum[0][1], 2, 1,
2309
                 &DCtab_lum[0][0], 2, 1);
2310
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2311
                 &DCtab_chrom[0][1], 2, 1,
2312
                 &DCtab_chrom[0][0], 2, 1);
2313
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2314
                 &sprite_trajectory_tab[0][1], 4, 2,
2315
                 &sprite_trajectory_tab[0][0], 4, 2);
2316
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2317
                 &mb_type_b_tab[0][1], 2, 1,
2318
                 &mb_type_b_tab[0][0], 2, 1);
2319
    }
2320
}
2321

    
2322
/**
2323
 * Get the GOB height based on picture height.
2324
 */
2325
int ff_h263_get_gob_height(MpegEncContext *s){
2326
    if (s->height <= 400)
2327
        return 1;
2328
    else if (s->height <= 800)
2329
        return  2;
2330
    else
2331
        return 4;
2332
}
2333

    
2334
/**
2335
 * decodes the group of blocks header.
2336
 * @return <0 if an error occured
2337
 */
2338
static int h263_decode_gob_header(MpegEncContext *s)
2339
{
2340
    unsigned int val, gfid;
2341
    int left;
2342
    
2343
    /* Check for GOB Start Code */
2344
    val = show_bits(&s->gb, 16);
2345
    if(val)
2346
        return -1;
2347

    
2348
        /* We have a GBSC probably with GSTUFF */
2349
    skip_bits(&s->gb, 16); /* Drop the zeros */
2350
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2351
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2352
    for(;left>13; left--){
2353
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2354
    }
2355
    if(left<=13) 
2356
        return -1;
2357

    
2358
#ifdef DEBUG
2359
    fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2360
#endif
2361
    s->gob_number = get_bits(&s->gb, 5); /* GN */
2362
    gfid = get_bits(&s->gb, 2); /* GFID */
2363
    s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2364
    if(s->qscale==0) 
2365
        return -1;
2366
    s->mb_x= 0;
2367
    s->mb_y= s->gob_index* s->gob_number;
2368
#ifdef DEBUG
2369
    fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2370
#endif
2371
    return 0;
2372
}
2373

    
2374
static inline void memsetw(short *tab, int val, int n)
2375
{
2376
    int i;
2377
    for(i=0;i<n;i++)
2378
        tab[i] = val;
2379
}
2380

    
2381
#ifdef CONFIG_ENCODERS
2382

    
2383
void ff_mpeg4_init_partitions(MpegEncContext *s)
2384
{
2385
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2386
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
2387
}
2388

    
2389
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2390
{
2391
    const int pb2_len   = get_bit_count(&s->pb2   );
2392
    const int tex_pb_len= get_bit_count(&s->tex_pb);
2393
    const int bits= get_bit_count(&s->pb);
2394

    
2395
    if(s->pict_type==I_TYPE){
2396
        put_bits(&s->pb, 19, DC_MARKER);
2397
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2398
        s->i_tex_bits+= tex_pb_len;
2399
    }else{
2400
        put_bits(&s->pb, 17, MOTION_MARKER);
2401
        s->misc_bits+=17 + pb2_len;
2402
        s->mv_bits+= bits - s->last_bits;
2403
        s->p_tex_bits+= tex_pb_len;
2404
    }
2405

    
2406
    flush_put_bits(&s->pb2);
2407
    flush_put_bits(&s->tex_pb);
2408

    
2409
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2410
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2411
    s->last_bits= get_bit_count(&s->pb);
2412
}
2413

    
2414
#endif //CONFIG_ENCODERS
2415

    
2416
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2417
    switch(s->pict_type){
2418
        case I_TYPE:
2419
            return 16;
2420
        case P_TYPE:
2421
        case S_TYPE:
2422
            return s->f_code+15;
2423
        case B_TYPE:
2424
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2425
        default:
2426
            return -1;
2427
    }
2428
}
2429

    
2430
#ifdef CONFIG_ENCODERS
2431

    
2432
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2433
{
2434
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2435

    
2436
    ff_mpeg4_stuffing(&s->pb);
2437
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2438
    put_bits(&s->pb, 1, 1);
2439
    
2440
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2441
    put_bits(&s->pb, s->quant_precision, s->qscale);
2442
    put_bits(&s->pb, 1, 0); /* no HEC */
2443
}
2444

    
2445
#endif //CONFIG_ENCODERS
2446

    
2447
/**
2448
 * check if the next stuff is a resync marker or the end.
2449
 * @return 0 if not
2450
 */
2451
static inline int mpeg4_is_resync(MpegEncContext *s){
2452
    const int bits_count= get_bits_count(&s->gb);
2453
    
2454
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
2455
        return 0;
2456
    }
2457

    
2458
    if(bits_count + 8 >= s->gb.size_in_bits){
2459
        int v= show_bits(&s->gb, 8);
2460
        v|= 0x7F >> (7-(bits_count&7));
2461
                
2462
        if(v==0x7F)
2463
            return 1;
2464
    }else{
2465
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2466
            int len;
2467
            GetBitContext gb= s->gb;
2468
        
2469
            skip_bits(&s->gb, 1);
2470
            align_get_bits(&s->gb);
2471
        
2472
            for(len=0; len<32; len++){
2473
                if(get_bits1(&s->gb)) break;
2474
            }
2475

    
2476
            s->gb= gb;
2477

    
2478
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2479
                return 1;
2480
        }
2481
    }
2482
    return 0;
2483
}
2484

    
2485
/**
2486
 * decodes the next video packet.
2487
 * @return <0 if something went wrong
2488
 */
2489
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2490
{
2491
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2492
    int header_extension=0, mb_num, len;
2493
    
2494
    /* is there enough space left for a video packet + header */
2495
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
2496

    
2497
    for(len=0; len<32; len++){
2498
        if(get_bits1(&s->gb)) break;
2499
    }
2500

    
2501
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2502
        printf("marker does not match f_code\n");
2503
        return -1;
2504
    }
2505
    
2506
    if(s->shape != RECT_SHAPE){
2507
        header_extension= get_bits1(&s->gb);
2508
        //FIXME more stuff here
2509
    }
2510

    
2511
    mb_num= get_bits(&s->gb, mb_num_bits);
2512
    if(mb_num>=s->mb_num){
2513
        fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2514
        return -1;
2515
    }
2516
    s->mb_x= mb_num % s->mb_width;
2517
    s->mb_y= mb_num / s->mb_width;
2518

    
2519
    if(s->shape != BIN_ONLY_SHAPE){
2520
        int qscale= get_bits(&s->gb, s->quant_precision); 
2521
        if(qscale)
2522
            s->qscale= qscale;
2523
    }
2524

    
2525
    if(s->shape == RECT_SHAPE){
2526
        header_extension= get_bits1(&s->gb);
2527
    }
2528
    if(header_extension){
2529
        int time_increment;
2530
        int time_incr=0;
2531

    
2532
        while (get_bits1(&s->gb) != 0) 
2533
            time_incr++;
2534

    
2535
        check_marker(&s->gb, "before time_increment in video packed header");
2536
        time_increment= get_bits(&s->gb, s->time_increment_bits);
2537
        check_marker(&s->gb, "before vop_coding_type in video packed header");
2538
        
2539
        skip_bits(&s->gb, 2); /* vop coding type */
2540
        //FIXME not rect stuff here
2541

    
2542
        if(s->shape != BIN_ONLY_SHAPE){
2543
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2544
//FIXME dont just ignore everything
2545
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2546
                mpeg4_decode_sprite_trajectory(s);
2547
                fprintf(stderr, "untested\n");
2548
            }
2549

    
2550
            //FIXME reduced res stuff here
2551
            
2552
            if (s->pict_type != I_TYPE) {
2553
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
2554
                if(f_code==0){
2555
                    printf("Error, video packet header damaged (f_code=0)\n");
2556
                }
2557
            }
2558
            if (s->pict_type == B_TYPE) {
2559
                int b_code = get_bits(&s->gb, 3);
2560
                if(b_code==0){
2561
                    printf("Error, video packet header damaged (b_code=0)\n");
2562
                }
2563
            }       
2564
        }
2565
    }
2566
    //FIXME new-pred stuff
2567
    
2568
//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));
2569

    
2570
    return 0;
2571
}
2572

    
2573
void ff_mpeg4_clean_buffers(MpegEncContext *s)
2574
{
2575
    int c_wrap, c_xy, l_wrap, l_xy;
2576

    
2577
    l_wrap= s->block_wrap[0];
2578
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2579
    c_wrap= s->block_wrap[4];
2580
    c_xy= s->mb_y*c_wrap + s->mb_x;
2581

    
2582
#if 0
2583
    /* clean DC */
2584
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2585
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2586
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2587
#endif
2588

    
2589
    /* clean AC */
2590
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
2591
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2592
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2593

    
2594
    /* clean MV */
2595
    // we cant clear the MVs as they might be needed by a b frame
2596
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
2597
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2598
    s->last_mv[0][0][0]=
2599
    s->last_mv[0][0][1]=
2600
    s->last_mv[1][0][0]=
2601
    s->last_mv[1][0][1]= 0;
2602
}
2603

    
2604
/**
2605
 * decodes the group of blocks / video packet header.
2606
 * @return <0 if no resync found
2607
 */
2608
int ff_h263_resync(MpegEncContext *s){
2609
    int left, ret;
2610
    
2611
    if(s->codec_id==CODEC_ID_MPEG4)
2612
        skip_bits1(&s->gb);
2613
    
2614
    align_get_bits(&s->gb);
2615

    
2616
    if(show_bits(&s->gb, 16)==0){
2617
        if(s->codec_id==CODEC_ID_MPEG4)
2618
            ret= mpeg4_decode_video_packet_header(s);
2619
        else
2620
            ret= h263_decode_gob_header(s);
2621
        if(ret>=0)
2622
            return 0;
2623
    }
2624
    //ok, its not where its supposed to be ...
2625
    s->gb= s->last_resync_gb;
2626
    align_get_bits(&s->gb);
2627
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2628
    
2629
    for(;left>16+1+5+5; left-=8){ 
2630
        if(show_bits(&s->gb, 16)==0){
2631
            GetBitContext bak= s->gb;
2632

    
2633
            if(s->codec_id==CODEC_ID_MPEG4)
2634
                ret= mpeg4_decode_video_packet_header(s);
2635
            else
2636
                ret= h263_decode_gob_header(s);
2637
            if(ret>=0)
2638
                return 0;
2639

    
2640
            s->gb= bak;
2641
        }
2642
        skip_bits(&s->gb, 8);
2643
    }
2644
    
2645
    return -1;
2646
}
2647

    
2648
/**
2649
 * gets the average motion vector for a GMC MB.
2650
 * @param n either 0 for the x component or 1 for y
2651
 * @returns the average MV for a GMC MB
2652
 */
2653
static inline int get_amv(MpegEncContext *s, int n){
2654
    int x, y, mb_v, sum, dx, dy, shift;
2655
    int len = 1 << (s->f_code + 4);
2656
    const int a= s->sprite_warping_accuracy;
2657

    
2658
    if(s->real_sprite_warping_points==1){
2659
        if(s->divx_version==500 && s->divx_build==413)
2660
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2661
        else
2662
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2663
    }else{
2664
        dx= s->sprite_delta[n][0];
2665
        dy= s->sprite_delta[n][1];
2666
        shift= s->sprite_shift[0];
2667
        if(n) dy -= 1<<(shift + a + 1);
2668
        else  dx -= 1<<(shift + a + 1);
2669
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2670

    
2671
        sum=0;
2672
        for(y=0; y<16; y++){
2673
            int v;
2674
        
2675
            v= mb_v + dy*y;
2676
            //XXX FIXME optimize
2677
            for(x=0; x<16; x++){
2678
                sum+= v>>shift;
2679
                v+= dx;
2680
            }
2681
        }
2682
        sum= RSHIFT(sum, a+8-s->quarter_sample);
2683
    }
2684

    
2685
    if      (sum < -len) sum= -len;
2686
    else if (sum >= len) sum= len-1;
2687

    
2688
    return sum;
2689
}
2690

    
2691
/**
2692
 * decodes first partition.
2693
 * @return number of MBs decoded or <0 if an error occured
2694
 */
2695
static int mpeg4_decode_partition_a(MpegEncContext *s){
2696
    int mb_num;
2697
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2698
    
2699
    /* decode first partition */
2700
    mb_num=0;
2701
    s->first_slice_line=1;
2702
    for(; s->mb_y<s->mb_height; s->mb_y++){
2703
        ff_init_block_index(s);
2704
        for(; s->mb_x<s->mb_width; s->mb_x++){
2705
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2706
            int cbpc;
2707
            int dir=0;
2708
            
2709
            mb_num++;
2710
            ff_update_block_index(s);
2711
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2712
                s->first_slice_line=0;
2713
            
2714
            if(s->mb_x==0) PRINT_MB_TYPE("\n");
2715

    
2716
            if(s->pict_type==I_TYPE){
2717
                int i;
2718

    
2719
                if(show_bits(&s->gb, 19)==DC_MARKER){
2720
                    return mb_num-1;
2721
                }
2722

    
2723
                PRINT_MB_TYPE("I");
2724
                cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2725
                if (cbpc < 0){
2726

    
2727
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2728
                    return -1;
2729
                }
2730
                s->cbp_table[xy]= cbpc & 3;
2731
                s->mb_type[xy]= MB_TYPE_INTRA;
2732
                s->mb_intra = 1;
2733

    
2734
                if(cbpc & 4) {
2735
                    change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2736
                }
2737
                s->current_picture.qscale_table[xy]= s->qscale;
2738

    
2739
                s->mbintra_table[xy]= 1;
2740
                for(i=0; i<6; i++){
2741
                    int dc_pred_dir;
2742
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2743
                    if(dc < 0){
2744
                        fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2745
                        return -1;
2746
                    }
2747
                    dir<<=1;
2748
                    if(dc_pred_dir) dir|=1;
2749
                }
2750
                s->pred_dir_table[xy]= dir;
2751
                
2752
                s->error_status_table[xy]= AC_ERROR;
2753
            }else{ /* P/S_TYPE */
2754
                int mx, my, pred_x, pred_y, bits;
2755
                int16_t * const mot_val= s->motion_val[s->block_index[0]];
2756
                const int stride= s->block_wrap[0]*2;
2757

    
2758
                bits= show_bits(&s->gb, 17);
2759
                if(bits==MOTION_MARKER){
2760
                    return mb_num-1;
2761
                }
2762
                skip_bits1(&s->gb);
2763
                if(bits&0x10000){
2764
                    /* skip mb */
2765
                    s->mb_type[xy]= MB_TYPE_SKIPED;
2766
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2767
                        PRINT_MB_TYPE("G");
2768
                        mx= get_amv(s, 0);
2769
                        my= get_amv(s, 1);
2770
                    }else{
2771
                        PRINT_MB_TYPE("S");
2772
                        mx=my=0;
2773
                    }
2774
                    mot_val[0       ]= mot_val[2       ]=
2775
                    mot_val[0+stride]= mot_val[2+stride]= mx;
2776
                    mot_val[1       ]= mot_val[3       ]=
2777
                    mot_val[1+stride]= mot_val[3+stride]= my;
2778

    
2779
                    if(s->mbintra_table[xy])
2780
                        ff_clean_intra_table_entries(s);
2781

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

    
2811
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2812
                        s->mcsel= get_bits1(&s->gb);
2813
                    else s->mcsel= 0;
2814
        
2815
                    if ((cbpc & 16) == 0) {
2816
                        PRINT_MB_TYPE("P");
2817
                        /* 16x16 motion prediction */
2818
                        s->mb_type[xy]= MB_TYPE_INTER;
2819

    
2820
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
2821
                        if(!s->mcsel){
2822
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2823
                            if (mx >= 0xffff)
2824
                                return -1;
2825

    
2826
                            my = h263_decode_motion(s, pred_y, s->f_code);
2827
                            if (my >= 0xffff)
2828
                                return -1;
2829
                        } else {
2830
                            mx = get_amv(s, 0);
2831
                            my = get_amv(s, 1);
2832
                        }
2833

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

    
2862
    return mb_num;
2863
}
2864

    
2865
/**
2866
 * decode second partition.
2867
 * @return <0 if an error occured
2868
 */
2869
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
2870
    int mb_num=0;
2871
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2872

    
2873
    s->mb_x= s->resync_mb_x;
2874
    s->first_slice_line=1;
2875
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
2876
        ff_init_block_index(s);
2877
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
2878
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2879

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

    
2901
                    if(cbpy<0){
2902
                        fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2903
                        return -1;
2904
                    }
2905
                    
2906
                    if(s->cbp_table[xy] & 8) {
2907
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2908
                    }
2909
                    s->current_picture.qscale_table[xy]= s->qscale;
2910

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

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

    
2941
                    s->cbp_table[xy]&= 3; //remove dquant
2942
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
2943
                }
2944
            }
2945
        }
2946
        if(mb_num >= mb_count) return 0;
2947
        s->mb_x= 0;
2948
    }
2949
    return 0;
2950
}
2951

    
2952
/**
2953
 * decodes the first & second partition
2954
 * @return <0 if error (and sets error type in the error_status_table)
2955
 */
2956
int ff_mpeg4_decode_partitions(MpegEncContext *s)
2957
{
2958
    int mb_num;
2959
    
2960
    mb_num= mpeg4_decode_partition_a(s);    
2961
    if(mb_num<0)
2962
        return -1;
2963
    
2964
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
2965
        fprintf(stderr, "slice below monitor ...\n");
2966
        return -1;
2967
    }
2968

    
2969
    s->mb_num_left= mb_num;
2970
        
2971
    if(s->pict_type==I_TYPE){
2972
        if(get_bits(&s->gb, 19)!=DC_MARKER){
2973
            fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
2974
            return -1;
2975
        }else
2976
            s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END|DC_END;
2977
    }else{
2978
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
2979
            fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
2980
            return -1;
2981
        }else
2982
            s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END;
2983
    }
2984
    
2985
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
2986
        return -1;
2987
    }
2988
    
2989
    s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= DC_END;
2990

    
2991
    return 0;        
2992
}
2993

    
2994
/**
2995
 * decode partition C of one MB.
2996
 * @return <0 if an error occured
2997
 */
2998
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
2999
{
3000
    int cbp, mb_type;
3001
    const int xy= s->mb_x + s->mb_y*s->mb_width;
3002

    
3003
    mb_type= s->mb_type[xy];
3004
    cbp = s->cbp_table[xy];
3005

    
3006
    if(s->current_picture.qscale_table[xy] != s->qscale){
3007
        s->qscale= s->current_picture.qscale_table[xy];
3008
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3009
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3010
    }
3011
    
3012
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3013
        int i;
3014
        for(i=0; i<4; i++){
3015
            s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
3016
            s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
3017
        }
3018
        s->mb_intra = mb_type&MB_TYPE_INTRA;
3019

    
3020
        if (mb_type&MB_TYPE_SKIPED) {
3021
            /* skip mb */
3022
            for(i=0;i<6;i++)
3023
                s->block_last_index[i] = -1;
3024
            s->mv_dir = MV_DIR_FORWARD;
3025
            s->mv_type = MV_TYPE_16X16;
3026
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3027
                s->mcsel=1;
3028
                s->mb_skiped = 0;
3029
            }else{
3030
                s->mcsel=0;
3031
                s->mb_skiped = 1;
3032
            }
3033
        }else if(s->mb_intra){
3034
            s->ac_pred = s->pred_dir_table[xy]>>7;
3035

    
3036
            /* decode each block */
3037
            for (i = 0; i < 6; i++) {
3038
                if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
3039
                    fprintf(stderr, "texture corrupted at %d %d\n", s->mb_x, s->mb_y);
3040
                    return -1;
3041
                }
3042
                cbp+=cbp;
3043
            }
3044
        }else if(!s->mb_intra){
3045
//            s->mcsel= 0; //FIXME do we need to init that
3046
            
3047
            s->mv_dir = MV_DIR_FORWARD;
3048
            if (mb_type&MB_TYPE_INTER4V) {
3049
                s->mv_type = MV_TYPE_8X8;
3050
            } else {
3051
                s->mv_type = MV_TYPE_16X16;
3052
            }
3053
            /* decode each block */
3054
            for (i = 0; i < 6; i++) {
3055
                if(mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0){
3056
                    fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
3057
                    return -1;
3058
                }
3059
                cbp+=cbp;
3060
            }
3061
        }
3062
    } else { /* I-Frame */
3063
        int i;
3064
        s->mb_intra = 1;
3065
        s->ac_pred = s->pred_dir_table[xy]>>7;
3066
        
3067
        /* decode each block */
3068
        for (i = 0; i < 6; i++) {
3069
            if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
3070
                fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
3071
                return -1;
3072
            }
3073
            cbp+=cbp;
3074
        }
3075
    }
3076

    
3077
    s->error_status_table[xy]&= ~AC_ERROR;
3078

    
3079
    /* per-MB end of slice check */
3080

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

    
3095
int ff_h263_decode_mb(MpegEncContext *s,
3096
                      DCTELEM block[6][64])
3097
{
3098
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3099
    int16_t *mot_val;
3100
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
3101

    
3102
    s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
3103

    
3104
    if(s->mb_x==0) PRINT_MB_TYPE("\n");
3105

    
3106
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3107
        if (get_bits1(&s->gb)) {
3108
            /* skip mb */
3109
            s->mb_intra = 0;
3110
            for(i=0;i<6;i++)
3111
                s->block_last_index[i] = -1;
3112
            s->mv_dir = MV_DIR_FORWARD;
3113
            s->mv_type = MV_TYPE_16X16;
3114
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3115
                PRINT_MB_TYPE("G");
3116
                s->mcsel=1;
3117
                s->mv[0][0][0]= get_amv(s, 0);
3118
                s->mv[0][0][1]= get_amv(s, 1);
3119

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

    
3169
                s->field_select[0][0]= get_bits1(&s->gb);
3170
                s->field_select[0][1]= get_bits1(&s->gb);
3171

    
3172
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3173
                
3174
                for(i=0; i<2; i++){
3175
                    mx = h263_decode_motion(s, pred_x, s->f_code);
3176
                    if (mx >= 0xffff)
3177
                        return -1;
3178
            
3179
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
3180
                    if (my >= 0xffff)
3181
                        return -1;
3182

    
3183
                    s->mv[0][i][0] = mx;
3184
                    s->mv[0][i][1] = my;
3185
                }
3186
            }else{
3187
                PRINT_MB_TYPE("P");
3188
                /* 16x16 motion prediction */
3189
                s->mv_type = MV_TYPE_16X16;
3190
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3191
                if (s->umvplus_dec)
3192
                   mx = h263p_decode_umotion(s, pred_x);
3193
                else
3194
                   mx = h263_decode_motion(s, pred_x, s->f_code);
3195
            
3196
                if (mx >= 0xffff)
3197
                    return -1;
3198
            
3199
                if (s->umvplus_dec)
3200
                   my = h263p_decode_umotion(s, pred_y);
3201
                else
3202
                   my = h263_decode_motion(s, pred_y, s->f_code);
3203
            
3204
                if (my >= 0xffff)
3205
                    return -1;
3206
                s->mv[0][0][0] = mx;
3207
                s->mv[0][0][1] = my;
3208

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

    
3243
        s->mb_intra = 0; //B-frames never contain intra blocks
3244
        s->mcsel=0;      //     ...               true gmc blocks
3245

    
3246
        if(s->mb_x==0){
3247
            for(i=0; i<2; i++){
3248
                s->last_mv[i][0][0]= 
3249
                s->last_mv[i][0][1]= 
3250
                s->last_mv[i][1][0]= 
3251
                s->last_mv[i][1][1]= 0;
3252
            }
3253
        }
3254

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

    
3258
        if(s->mb_skiped){
3259
                /* skip mb */
3260
            for(i=0;i<6;i++)
3261
                s->block_last_index[i] = -1;
3262

    
3263
            s->mv_dir = MV_DIR_FORWARD;
3264
            s->mv_type = MV_TYPE_16X16;
3265
            s->mv[0][0][0] = 0;
3266
            s->mv[0][0][1] = 0;
3267
            s->mv[1][0][0] = 0;
3268
            s->mv[1][0][1] = 0;
3269
            PRINT_MB_TYPE("s");
3270
            goto end;
3271
        }
3272

    
3273
        modb1= get_bits1(&s->gb); 
3274
        if(modb1){
3275
            mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
3276
            cbp=0;
3277
        }else{
3278
            int field_mv;
3279
        
3280
            modb2= get_bits1(&s->gb);
3281
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3282
            if(modb2) cbp= 0;
3283
            else      cbp= get_bits(&s->gb, 6);
3284

    
3285
            if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
3286
                if(get_bits1(&s->gb)){
3287
                    change_qscale(s, get_bits1(&s->gb)*4 - 2);
3288
                }
3289
            }
3290
            field_mv=0;
3291

    
3292
            if(!s->progressive_sequence){
3293
                if(cbp)
3294
                    s->interlaced_dct= get_bits1(&s->gb);
3295

    
3296
                if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
3297
                    field_mv=1;
3298

    
3299
                    if(mb_type!=MB_TYPE_B_BACKW){
3300
                        s->field_select[0][0]= get_bits1(&s->gb);
3301
                        s->field_select[0][1]= get_bits1(&s->gb);
3302
                    }
3303
                    if(mb_type!=MB_TYPE_B_FORW){
3304
                        s->field_select[1][0]= get_bits1(&s->gb);
3305
                        s->field_select[1][1]= get_bits1(&s->gb);
3306
                    }
3307
                }
3308
            }
3309

    
3310
            s->mv_dir = 0;
3311
            if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
3312
                s->mv_type= MV_TYPE_16X16;
3313
                if(mb_type!=MB_TYPE_B_BACKW){
3314
                    s->mv_dir = MV_DIR_FORWARD;
3315

    
3316
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3317
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3318
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3319
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3320
                }
3321
    
3322
                if(mb_type!=MB_TYPE_B_FORW){
3323
                    s->mv_dir |= MV_DIR_BACKWARD;
3324

    
3325
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3326
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3327
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3328
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3329
                }
3330
                if(mb_type!=MB_TYPE_B_DIRECT)
3331
                    PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "F" : (mb_type==MB_TYPE_B_BACKW ? "B" : "T"));
3332
            }else if(mb_type!=MB_TYPE_B_DIRECT){
3333
                s->mv_type= MV_TYPE_FIELD;
3334

    
3335
                if(mb_type!=MB_TYPE_B_BACKW){
3336
                    s->mv_dir = MV_DIR_FORWARD;
3337
                
3338
                    for(i=0; i<2; i++){
3339
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3340
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3341
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3342
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3343
                    }
3344
                }
3345
    
3346
                if(mb_type!=MB_TYPE_B_FORW){
3347
                    s->mv_dir |= MV_DIR_BACKWARD;
3348

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

    
3402
        /* decode each block */
3403
        if (s->h263_pred) {
3404
            for (i = 0; i < 6; i++) {
3405
                if (mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0)
3406
                    return -1;
3407
                cbp+=cbp;
3408
            }
3409
        } else {
3410
            for (i = 0; i < 6; i++) {
3411
                if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3412
                    return -1;
3413
                cbp+=cbp;
3414
            }
3415
        }
3416
        goto end;
3417
    }
3418

    
3419
    /* decode each block */
3420
    if (s->h263_pred) {
3421
        for (i = 0; i < 6; i++) {
3422
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0)
3423
                return -1;
3424
            cbp+=cbp;
3425
        }
3426
    } else {
3427
        for (i = 0; i < 6; i++) {
3428
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3429
                return -1;
3430
            cbp+=cbp;
3431
        }
3432
    }
3433
end:
3434

    
3435
        /* per-MB end of slice check */
3436
    if(s->codec_id==CODEC_ID_MPEG4){
3437
        if(mpeg4_is_resync(s)){
3438
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x+1])
3439
                return SLICE_OK;
3440
            return SLICE_END;
3441
        }
3442
    }else{
3443
        int v= show_bits(&s->gb, 16);
3444
    
3445
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3446
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3447
        }
3448

    
3449
        if(v==0)
3450
            return SLICE_END;
3451
    }
3452

    
3453
    return SLICE_OK;     
3454
}
3455

    
3456
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3457
{
3458
    int code, val, sign, shift, l;
3459
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3460
    if (code < 0)
3461
        return 0xffff;
3462

    
3463
    if (code == 0)
3464
        return pred;
3465

    
3466
    sign = get_bits1(&s->gb);
3467
    shift = f_code - 1;
3468
    val = (code - 1) << shift;
3469
    if (shift > 0)
3470
        val |= get_bits(&s->gb, shift);
3471
    val++;
3472
    if (sign)
3473
        val = -val;
3474
    val += pred;
3475

    
3476
    /* modulo decoding */
3477
    if (!s->h263_long_vectors) {
3478
        l = 1 << (f_code + 4);
3479
        if (val < -l) {
3480
            val += l<<1;
3481
        } else if (val >= l) {
3482
            val -= l<<1;
3483
        }
3484
    } else {
3485
        /* horrible h263 long vector mode */
3486
        if (pred < -31 && val < -63)
3487
            val += 64;
3488
        if (pred > 32 && val > 63)
3489
            val -= 64;
3490
        
3491
    }
3492
    return val;
3493
}
3494

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

    
3519
}
3520

    
3521
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3522
                             int n, int coded)
3523
{
3524
    int code, level, i, j, last, run;
3525
    RLTable *rl = &rl_inter;
3526
    const uint8_t *scan_table;
3527

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

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

    
3614
/**
3615
 * decodes the dc value.
3616
 * @param n block index (0-3 are luma, 4-5 are chroma)
3617
 * @param dir_ptr the prediction direction will be stored here
3618
 * @return the quantized dc
3619
 */
3620
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3621
{
3622
    int level, pred, code;
3623
    uint16_t *dc_val;
3624

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

    
3671
/**
3672
 * decodes a block.
3673
 * @return <0 if an error occured
3674
 */
3675
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3676
                              int n, int coded, int intra)
3677
{
3678
    int level, i, last, run;
3679
    int dc_pred_dir;
3680
    RLTable * rl;
3681
    RL_VLC_ELEM * rl_vlc;
3682
    const uint8_t * scan_table;
3683
    int qmul, qadd;
3684

    
3685
    if(intra) {
3686
        /* DC coef */
3687
        if(s->partitioned_frame){
3688
            level = s->dc_val[0][ s->block_index[n] ];
3689
            if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
3690
            else    level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
3691
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
3692
        }else{
3693
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3694
            if (level < 0)
3695
                return -1;
3696
        }
3697
        block[0] = level;
3698
        i = 0;
3699
        if (!coded) 
3700
            goto not_coded;
3701
        rl = &rl_intra;
3702
        rl_vlc = rl_intra.rl_vlc[0];
3703
        if (s->ac_pred) {
3704
            if (dc_pred_dir == 0) 
3705
                scan_table = s->intra_v_scantable.permutated; /* left */
3706
            else
3707
                scan_table = s->intra_h_scantable.permutated; /* top */
3708
        } else {
3709
            scan_table = s->intra_scantable.permutated;
3710
        }
3711
        qmul=1;
3712
        qadd=0;
3713
    } else {
3714
        i = -1;
3715
        if (!coded) {
3716
            s->block_last_index[n] = i;
3717
            return 0;
3718
        }
3719
        rl = &rl_inter;
3720
   
3721
        scan_table = s->intra_scantable.permutated;
3722

    
3723
        if(s->mpeg_quant){
3724
            qmul=1;
3725
            qadd=0;
3726
            rl_vlc = rl_inter.rl_vlc[0];        
3727
        }else{
3728
            qmul = s->qscale << 1;
3729
            qadd = (s->qscale - 1) | 1;
3730
            rl_vlc = rl_inter.rl_vlc[s->qscale];
3731
        }
3732
    }
3733
  {
3734
    OPEN_READER(re, &s->gb);
3735
    for(;;) {
3736
        UPDATE_CACHE(re, &s->gb);
3737
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3738
        if (level==0) {
3739
            int cache;
3740
            cache= GET_CACHE(re, &s->gb);
3741
            /* escape */
3742
            if (cache&0x80000000) {
3743
                if (cache&0x40000000) {
3744
                    /* third escape */
3745
                    SKIP_CACHE(re, &s->gb, 2);
3746
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3747
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3748
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
3749
                    UPDATE_CACHE(re, &s->gb);
3750

    
3751
                    if(SHOW_UBITS(re, &s->gb, 1)==0){
3752
                        fprintf(stderr, "1. marker bit missing in 3. esc\n");
3753
                        return -1;
3754
                    }; SKIP_CACHE(re, &s->gb, 1);
3755
                    
3756
                    level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3757
 
3758
                    if(SHOW_UBITS(re, &s->gb, 1)==0){
3759
                        fprintf(stderr, "2. marker bit missing in 3. esc\n");
3760
                        return -1;
3761
                    }; LAST_SKIP_CACHE(re, &s->gb, 1);
3762
                    
3763
                    SKIP_COUNTER(re, &s->gb, 1+12+1);
3764
                    
3765
                    if(level*s->qscale>1024 || level*s->qscale<-1024){
3766
                        fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3767
                        return -1;
3768
                    }
3769
#if 1 
3770
                    {
3771
                        const int abs_level= ABS(level);
3772
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
3773
                            const int run1= run - rl->max_run[last][abs_level] - 1;
3774
                            if(abs_level <= rl->max_level[last][run]){
3775
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3776
                                return -1;
3777
                            }
3778
                            if(s->error_resilience > FF_ER_COMPLIANT){
3779
                                if(abs_level <= rl->max_level[last][run]*2){
3780
                                    fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3781
                                    return -1;
3782
                                }
3783
                                if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3784
                                    fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3785
                                    return -1;
3786
                                }
3787
                            }
3788
                        }
3789
                    }
3790
#endif
3791
                    if (level>0) level= level * qmul + qadd;
3792
                    else         level= level * qmul - qadd;
3793

    
3794
                    i+= run + 1;
3795
                    if(last) i+=192;
3796
                } else {
3797
                    /* second escape */
3798
#if MIN_CACHE_BITS < 20
3799
                    LAST_SKIP_BITS(re, &s->gb, 2);
3800
                    UPDATE_CACHE(re, &s->gb);
3801
#else
3802
                    SKIP_BITS(re, &s->gb, 2);
3803
#endif
3804
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3805
                    i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3806
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3807
                    LAST_SKIP_BITS(re, &s->gb, 1);
3808
                }
3809
            } else {
3810
                /* first escape */
3811
#if MIN_CACHE_BITS < 19
3812
                LAST_SKIP_BITS(re, &s->gb, 1);
3813
                UPDATE_CACHE(re, &s->gb);
3814
#else
3815
                SKIP_BITS(re, &s->gb, 1);
3816
#endif
3817
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3818
                i+= run;
3819
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3820
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3821
                LAST_SKIP_BITS(re, &s->gb, 1);
3822
            }
3823
        } else {
3824
            i+= run;
3825
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3826
            LAST_SKIP_BITS(re, &s->gb, 1);
3827
        }
3828
        if (i > 62){
3829
            i-= 192;
3830
            if(i&(~63)){
3831
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3832
                return -1;
3833
            }
3834

    
3835
            block[scan_table[i]] = level;
3836
            break;
3837
        }
3838

    
3839
        block[scan_table[i]] = level;
3840
    }
3841
    CLOSE_READER(re, &s->gb);
3842
  }
3843
 not_coded:
3844
    if (s->mb_intra) {
3845
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
3846
        if (s->ac_pred) {
3847
            i = 63; /* XXX: not optimal */
3848
        }
3849
    }
3850
    s->block_last_index[n] = i;
3851
    return 0;
3852
}
3853

    
3854
/* most is hardcoded. should extend to handle all h263 streams */
3855
int h263_decode_picture_header(MpegEncContext *s)
3856
{
3857
    int format, width, height;
3858

    
3859
    /* picture start code */
3860
    if (get_bits(&s->gb, 22) != 0x20) {
3861
        fprintf(stderr, "Bad picture start code\n");
3862
        return -1;
3863
    }
3864
    /* temporal reference */
3865
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3866

    
3867
    /* PTYPE starts here */    
3868
    if (get_bits1(&s->gb) != 1) {
3869
        /* marker */
3870
        fprintf(stderr, "Bad marker\n");
3871
        return -1;
3872
    }
3873
    if (get_bits1(&s->gb) != 0) {
3874
        fprintf(stderr, "Bad H263 id\n");
3875
        return -1;        /* h263 id */
3876
    }
3877
    skip_bits1(&s->gb);        /* split screen off */
3878
    skip_bits1(&s->gb);        /* camera  off */
3879
    skip_bits1(&s->gb);        /* freeze picture release off */
3880

    
3881
    /* Reset GOB number */
3882
    s->gob_number = 0;
3883
        
3884
    format = get_bits(&s->gb, 3);
3885
    /*
3886
        0    forbidden
3887
        1    sub-QCIF
3888
        10   QCIF
3889
        7        extended PTYPE (PLUSPTYPE)
3890
    */
3891

    
3892
    if (format != 7 && format != 6) {
3893
        s->h263_plus = 0;
3894
        /* H.263v1 */
3895
        width = h263_format[format][0];
3896
        height = h263_format[format][1];
3897
        if (!width)
3898
            return -1;
3899
        
3900
        s->width = width;
3901
        s->height = height;
3902
        s->pict_type = I_TYPE + get_bits1(&s->gb);
3903

    
3904
        s->unrestricted_mv = get_bits1(&s->gb); 
3905
        s->h263_long_vectors = s->unrestricted_mv;
3906

    
3907
        if (get_bits1(&s->gb) != 0) {
3908
            fprintf(stderr, "H263 SAC not supported\n");
3909
            return -1;        /* SAC: off */
3910
        }
3911
        if (get_bits1(&s->gb) != 0) {
3912
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3913
        }   
3914
        
3915
        if (get_bits1(&s->gb) != 0) {
3916
            fprintf(stderr, "H263 PB frame not supported\n");
3917
            return -1;        /* not PB frame */
3918
        }
3919
        s->qscale = get_bits(&s->gb, 5);
3920
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
3921
    } else {
3922
        int ufep;
3923
        
3924
        /* H.263v2 */
3925
        s->h263_plus = 1;
3926
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3927

    
3928
        /* ufep other than 0 and 1 are reserved */        
3929
        if (ufep == 1) {
3930
            /* OPPTYPE */       
3931
            format = get_bits(&s->gb, 3);
3932
            dprintf("ufep=1, format: %d\n", format);
3933
            skip_bits(&s->gb,1); /* Custom PCF */
3934
            s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3935
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3936
            if (get_bits1(&s->gb) != 0) {
3937
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3938
            }
3939
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3940
                s->h263_aic = 1;
3941
            }
3942
            
3943
            skip_bits(&s->gb, 7);
3944
            /* these are the 7 bits: (in order of appearence  */
3945
            /* Deblocking Filter */
3946
            /* Slice Structured */
3947
            /* Reference Picture Selection */
3948
            /* Independent Segment Decoding */
3949
            /* Alternative Inter VLC */
3950
            /* Modified Quantization */
3951
            /* Prevent start code emulation */
3952

    
3953
            skip_bits(&s->gb, 3); /* Reserved */
3954
        } else if (ufep != 0) {
3955
            fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3956
            return -1;
3957
        }
3958
            
3959
        /* MPPTYPE */
3960
        s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3961
        dprintf("pict_type: %d\n", s->pict_type);
3962
        if (s->pict_type != I_TYPE &&
3963
            s->pict_type != P_TYPE)
3964
            return -1;
3965
        skip_bits(&s->gb, 2);
3966
        s->no_rounding = get_bits1(&s->gb);
3967
        dprintf("RTYPE: %d\n", s->no_rounding);
3968
        skip_bits(&s->gb, 4);
3969
        
3970
        /* Get the picture dimensions */
3971
        if (ufep) {
3972
            if (format == 6) {
3973
                /* Custom Picture Format (CPFMT) */
3974
                s->aspect_ratio_info = get_bits(&s->gb, 4);
3975
                dprintf("aspect: %d\n", s->aspect_ratio_info);
3976
                /* aspect ratios:
3977
                0 - forbidden
3978
                1 - 1:1
3979
                2 - 12:11 (CIF 4:3)
3980
                3 - 10:11 (525-type 4:3)
3981
                4 - 16:11 (CIF 16:9)
3982
                5 - 40:33 (525-type 16:9)
3983
                6-14 - reserved
3984
                */
3985
                width = (get_bits(&s->gb, 9) + 1) * 4;
3986
                skip_bits1(&s->gb);
3987
                height = get_bits(&s->gb, 9) * 4;
3988
                dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
3989
                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
3990
                    /* aspected dimensions */
3991
                    s->aspected_width = get_bits(&s->gb, 8);
3992
                    s->aspected_height = get_bits(&s->gb, 8);
3993
                }else{
3994
                    s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
3995
                    s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
3996
                }
3997
            } else {
3998
                width = h263_format[format][0];
3999
                height = h263_format[format][1];
4000
            }
4001
            if ((width == 0) || (height == 0))
4002
                return -1;
4003
            s->width = width;
4004
            s->height = height;
4005
            if (s->umvplus_dec) {
4006
                skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
4007
            }
4008
        }
4009
            
4010
        s->qscale = get_bits(&s->gb, 5);
4011
    }
4012
    /* PEI */
4013
    while (get_bits1(&s->gb) != 0) {
4014
        skip_bits(&s->gb, 8);
4015
    }
4016
    s->f_code = 1;
4017
    
4018
    if(s->h263_aic){
4019
         s->y_dc_scale_table= 
4020
         s->c_dc_scale_table= h263_aic_dc_scale_table;
4021
    }else{
4022
        s->y_dc_scale_table=
4023
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4024
    }
4025

    
4026
    return 0;
4027
}
4028

    
4029
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
4030
{
4031
    int i;
4032
    int a= 2<<s->sprite_warping_accuracy;
4033
    int rho= 3-s->sprite_warping_accuracy;
4034
    int r=16/a;
4035
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
4036
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
4037
    int sprite_ref[4][2];
4038
    int virtual_ref[2][2];
4039
    int w2, h2, w3, h3;
4040
    int alpha=0, beta=0;
4041
    int w= s->width;
4042
    int h= s->height;
4043
    int min_ab;
4044

    
4045
    for(i=0; i<s->num_sprite_warping_points; i++){
4046
        int length;
4047
        int x=0, y=0;
4048

    
4049
        length= get_vlc(&s->gb, &sprite_trajectory);
4050
        if(length){
4051
            x= get_bits(&s->gb, length);
4052

    
4053
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
4054
                x = - (x ^ ((1 << length) - 1));
4055
        }
4056
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4057
        
4058
        length= get_vlc(&s->gb, &sprite_trajectory);
4059
        if(length){
4060
            y=get_bits(&s->gb, length);
4061

    
4062
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
4063
                y = - (y ^ ((1 << length) - 1));
4064
        }
4065
        skip_bits1(&s->gb); /* marker bit */
4066
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4067
        d[i][0]= x;
4068
        d[i][1]= y;
4069
    }
4070

    
4071
    while((1<<alpha)<w) alpha++;
4072
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
4073
    w2= 1<<alpha;
4074
    h2= 1<<beta;
4075

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

    
4244
static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
4245
    int hours, minutes, seconds;
4246

    
4247
    hours= get_bits(gb, 5);
4248
    minutes= get_bits(gb, 6);
4249
    skip_bits1(gb);
4250
    seconds= get_bits(gb, 6);
4251

    
4252
    s->time_base= seconds + 60*(minutes + 60*hours);
4253

    
4254
    skip_bits1(gb);
4255
    skip_bits1(gb);
4256
    
4257
    return 0;
4258
}
4259

    
4260
static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4261
    int width, height, vo_ver_id;
4262

    
4263
    /* vol header */
4264
    skip_bits(gb, 1); /* random access */
4265
    s->vo_type= get_bits(gb, 8);
4266
    if (get_bits1(gb) != 0) { /* is_ol_id */
4267
        vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4268
        skip_bits(gb, 3); /* vo_priority */
4269
    } else {
4270
        vo_ver_id = 1;
4271
    }
4272
//printf("vo type:%d\n",s->vo_type);
4273
    s->aspect_ratio_info= get_bits(gb, 4);
4274
    if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){            
4275
        s->aspected_width = get_bits(gb, 8); // par_width
4276
        s->aspected_height = get_bits(gb, 8); // par_height
4277
    }else{
4278
        s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4279
        s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4280
    }
4281

    
4282
    if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4283
        int chroma_format= get_bits(gb, 2);
4284
        if(chroma_format!=1){
4285
            printf("illegal chroma format\n");
4286
        }
4287
        s->low_delay= get_bits1(gb);
4288
        if(get_bits1(gb)){ /* vbv parameters */
4289
            get_bits(gb, 15);        /* first_half_bitrate */
4290
            skip_bits1(gb);        /* marker */
4291
            get_bits(gb, 15);        /* latter_half_bitrate */
4292
            skip_bits1(gb);        /* marker */
4293
            get_bits(gb, 15);        /* first_half_vbv_buffer_size */
4294
            skip_bits1(gb);        /* marker */
4295
            get_bits(gb, 3);        /* latter_half_vbv_buffer_size */
4296
            get_bits(gb, 11);        /* first_half_vbv_occupancy */
4297
            skip_bits1(gb);        /* marker */
4298
            get_bits(gb, 15);        /* latter_half_vbv_occupancy */
4299
            skip_bits1(gb);        /* marker */               
4300
        }
4301
    }else{
4302
        // set low delay flag only once so the smart? low delay detection wont be overriden
4303
        if(s->picture_number==0)
4304
            s->low_delay=0;
4305
    }
4306

    
4307
    s->shape = get_bits(gb, 2); /* vol shape */
4308
    if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4309
    if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4310
        printf("Gray shape not supported\n");
4311
        skip_bits(gb, 4);  //video_object_layer_shape_extension
4312
    }
4313

    
4314
    skip_bits1(gb);   /* marker */
4315
    
4316
    s->time_increment_resolution = get_bits(gb, 16);
4317
    
4318
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4319
    if (s->time_increment_bits < 1)
4320
        s->time_increment_bits = 1;
4321
    skip_bits1(gb);   /* marker */
4322

    
4323
    if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
4324
        skip_bits(gb, s->time_increment_bits);
4325
    }
4326

    
4327
    if (s->shape != BIN_ONLY_SHAPE) {
4328
        if (s->shape == RECT_SHAPE) {
4329
            skip_bits1(gb);   /* marker */
4330
            width = get_bits(gb, 13);
4331
            skip_bits1(gb);   /* marker */
4332
            height = get_bits(gb, 13);
4333
            skip_bits1(gb);   /* marker */
4334
            if(width && height){ /* they should be non zero but who knows ... */
4335
                s->width = width;
4336
                s->height = height;
4337
//                printf("width/height: %d %d\n", width, height);
4338
            }
4339
        }
4340
        
4341
        s->progressive_sequence= get_bits1(gb)^1;
4342
        if(!get_bits1(gb)) printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
4343
        if (vo_ver_id == 1) {
4344
            s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4345
        } else {
4346
            s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4347
        }
4348
        if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4349
        if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4350
            if(s->vol_sprite_usage==STATIC_SPRITE){
4351
                s->sprite_width = get_bits(gb, 13);
4352
                skip_bits1(gb); /* marker */
4353
                s->sprite_height= get_bits(gb, 13);
4354
                skip_bits1(gb); /* marker */
4355
                s->sprite_left  = get_bits(gb, 13);
4356
                skip_bits1(gb); /* marker */
4357
                s->sprite_top   = get_bits(gb, 13);
4358
                skip_bits1(gb); /* marker */
4359
            }
4360
            s->num_sprite_warping_points= get_bits(gb, 6);
4361
            s->sprite_warping_accuracy = get_bits(gb, 2);
4362
            s->sprite_brightness_change= get_bits1(gb);
4363
            if(s->vol_sprite_usage==STATIC_SPRITE)
4364
                s->low_latency_sprite= get_bits1(gb);            
4365
        }
4366
        // FIXME sadct disable bit if verid!=1 && shape not rect
4367
        
4368
        if (get_bits1(gb) == 1) {   /* not_8_bit */
4369
            s->quant_precision = get_bits(gb, 4); /* quant_precision */
4370
            if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4371
            if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4372
        } else {
4373
            s->quant_precision = 5;
4374
        }
4375
        
4376
        // FIXME a bunch of grayscale shape things
4377

    
4378
        if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4379
            int i, v;
4380
            
4381
            /* load default matrixes */
4382
            for(i=0; i<64; i++){
4383
                int j= s->idct_permutation[i];
4384
                v= ff_mpeg4_default_intra_matrix[i];
4385
                s->intra_matrix[j]= v;
4386
                s->chroma_intra_matrix[j]= v;
4387
                
4388
                v= ff_mpeg4_default_non_intra_matrix[i];
4389
                s->inter_matrix[j]= v;
4390
                s->chroma_inter_matrix[j]= v;
4391
            }
4392

    
4393
            /* load custom intra matrix */
4394
            if(get_bits1(gb)){
4395
                int last=0;
4396
                for(i=0; i<64; i++){
4397
                    int j;
4398
                    v= get_bits(gb, 8);
4399
                    if(v==0) break;
4400
                    
4401
                    last= v;
4402
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4403
                    s->intra_matrix[j]= v;
4404
                    s->chroma_intra_matrix[j]= v;
4405
                }
4406

    
4407
                /* replicate last value */
4408
                for(; i<64; i++){
4409
                    int j= s->idct_permutation[ ff_zigzag_direct[i] ];
4410
                    s->intra_matrix[j]= v;
4411
                    s->chroma_intra_matrix[j]= v;
4412
                }
4413
            }
4414

    
4415
            /* load custom non intra matrix */
4416
            if(get_bits1(gb)){
4417
                int last=0;
4418
                for(i=0; i<64; i++){
4419
                    int j;
4420
                    v= get_bits(gb, 8);
4421
                    if(v==0) break;
4422

    
4423
                    last= v;
4424
                    j= s->idct_permutation[ ff_zigzag_direct[i] ];
4425
                    s->inter_matrix[j]= v;
4426
                    s->chroma_inter_matrix[j]= v;
4427
                }
4428

    
4429
                /* replicate last value */
4430
                for(; i<64; i++){
4431
                    int j= s->idct_permutation[ ff_zigzag_direct[i] ];
4432
                    s->inter_matrix[j]= last;
4433
                    s->chroma_inter_matrix[j]= last;
4434
                }
4435
            }
4436

    
4437
            // FIXME a bunch of grayscale shape things
4438
        }
4439

    
4440
        if(vo_ver_id != 1)
4441
             s->quarter_sample= get_bits1(gb);
4442
        else s->quarter_sample=0;
4443

    
4444
        if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4445

    
4446
        s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4447

    
4448
        s->data_partitioning= get_bits1(gb);
4449
        if(s->data_partitioning){
4450
            s->rvlc= get_bits1(gb);
4451
            if(s->rvlc){
4452
                printf("reversible vlc not supported\n");
4453
            }
4454
        }
4455
        
4456
        if(vo_ver_id != 1) {
4457
            s->new_pred= get_bits1(gb);
4458
            if(s->new_pred){
4459
                printf("new pred not supported\n");
4460
                skip_bits(gb, 2); /* requested upstream message type */
4461
                skip_bits1(gb); /* newpred segment type */
4462
            }
4463
            s->reduced_res_vop= get_bits1(gb);
4464
            if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4465
        }
4466
        else{
4467
            s->new_pred=0;
4468
            s->reduced_res_vop= 0;
4469
        }
4470

    
4471
        s->scalability= get_bits1(gb);
4472

    
4473
        if (s->scalability) {
4474
            GetBitContext bak= *gb;
4475
            int ref_layer_id;
4476
            int ref_layer_sampling_dir;
4477
            int h_sampling_factor_n;
4478
            int h_sampling_factor_m;
4479
            int v_sampling_factor_n;
4480
            int v_sampling_factor_m;
4481
            
4482
            s->hierachy_type= get_bits1(gb);
4483
            ref_layer_id= get_bits(gb, 4);
4484
            ref_layer_sampling_dir= get_bits1(gb);
4485
            h_sampling_factor_n= get_bits(gb, 5);
4486
            h_sampling_factor_m= get_bits(gb, 5);
4487
            v_sampling_factor_n= get_bits(gb, 5);
4488
            v_sampling_factor_m= get_bits(gb, 5);
4489
            s->enhancement_type= get_bits1(gb);
4490
            
4491
            if(   h_sampling_factor_n==0 || h_sampling_factor_m==0 
4492
               || v_sampling_factor_n==0 || v_sampling_factor_m==0){
4493
               
4494
//                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4495
                s->scalability=0;
4496
               
4497
                *gb= bak;
4498
            }else
4499
                printf("scalability not supported\n");
4500
            
4501
            // bin shape stuff FIXME
4502
        }
4503
    }
4504
    return 0;
4505
}
4506

    
4507
/**
4508
 * decodes the user data stuff in the header.
4509
 * allso inits divx/xvid/lavc_version/build
4510
 */
4511
static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
4512
    char buf[256];
4513
    int i;
4514
    int e;
4515
    int ver, build, ver2, ver3;
4516

    
4517
    buf[0]= show_bits(gb, 8);
4518
    for(i=1; i<256; i++){
4519
        buf[i]= show_bits(gb, 16)&0xFF;
4520
        if(buf[i]==0) break;
4521
        skip_bits(gb, 8);
4522
    }
4523
    buf[255]=0;
4524
    
4525
    /* divx detection */
4526
    e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
4527
    if(e!=2)
4528
        e=sscanf(buf, "DivX%db%d", &ver, &build);
4529
    if(e==2){
4530
        s->divx_version= ver;
4531
        s->divx_build= build;
4532
        if(s->picture_number==0){
4533
            printf("This file was encoded with DivX%d Build%d\n", ver, build);
4534
        }
4535
    }
4536
    
4537
    /* ffmpeg detection */
4538
    e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
4539
    if(e!=4)
4540
        e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); 
4541
    if(e!=4){
4542
        if(strcmp(buf, "ffmpeg")==0){
4543
            s->ffmpeg_version= 0x000406;
4544
            s->lavc_build= 4600;
4545
        }
4546
    }
4547
    if(e==4){
4548
        s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
4549
        s->lavc_build= build;
4550
        if(s->picture_number==0)
4551
            printf("This file was encoded with libavcodec build %d\n", build);
4552
    }
4553
    
4554
    /* xvid detection */
4555
    e=sscanf(buf, "XviD%d", &build);
4556
    if(e==1){
4557
        s->xvid_build= build;
4558
        if(s->picture_number==0)
4559
            printf("This file was encoded with XviD build %d\n", build);
4560
    }
4561

    
4562
//printf("User Data: %s\n", buf);
4563
    return 0;
4564
}
4565

    
4566
static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
4567
    int time_incr, time_increment;
4568

    
4569
    s->pict_type = get_bits(gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
4570
    if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
4571
        printf("low_delay flag set, but shouldnt, clearing it\n");
4572
        s->low_delay=0;
4573
    }
4574
 
4575
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
4576
    if(s->partitioned_frame)
4577
        s->decode_mb= mpeg4_decode_partitioned_mb;
4578
    else
4579
        s->decode_mb= ff_h263_decode_mb;
4580

    
4581
    if(s->time_increment_resolution==0){
4582
        s->time_increment_resolution=1;
4583
//        fprintf(stderr, "time_increment_resolution is illegal\n");
4584
    }
4585
    time_incr=0;
4586
    while (get_bits1(gb) != 0) 
4587
        time_incr++;
4588

    
4589
    check_marker(gb, "before time_increment");
4590
    
4591
    if(s->picture_number==0 && (show_bits(gb, s->time_increment_bits+1)&1)==0){
4592
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4593
        
4594

    
4595
        for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
4596
            if(show_bits(gb, s->time_increment_bits+1)&1) break;
4597
        }
4598
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
4599
    }
4600
    
4601
    time_increment= get_bits(gb, s->time_increment_bits);
4602
//printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4603
    if(s->pict_type!=B_TYPE){
4604
        s->last_time_base= s->time_base;
4605
        s->time_base+= time_incr;
4606
        s->time= s->time_base*s->time_increment_resolution + time_increment;
4607
        if(s->workaround_bugs&FF_BUG_UMP4){
4608
            if(s->time < s->last_non_b_time){
4609
//                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4610
                s->time_base++;
4611
                s->time+= s->time_increment_resolution;
4612
            }
4613
        }
4614
        s->pp_time= s->time - s->last_non_b_time;
4615
        s->last_non_b_time= s->time;
4616
    }else{
4617
        s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4618
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4619
        if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4620
//            printf("messed up order, seeking?, skiping current b frame\n");
4621
            return FRAME_SKIPED;
4622
        }
4623
        
4624
        if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4625
        if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4626
//printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4627
        s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame) 
4628
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4629
        s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame) 
4630
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4631
    }
4632
    
4633
    s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4634
    if(s->avctx->debug&FF_DEBUG_PTS)
4635
        printf("MPEG4 PTS: %f\n", s->current_picture.pts/(1000.0*1000.0));
4636
    
4637
    check_marker(gb, "before vop_coded");
4638
    
4639
    /* vop coded */
4640
    if (get_bits1(gb) != 1){
4641
        printf("vop not coded\n");
4642
        return FRAME_SKIPED;
4643
    }
4644
//printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4645
//s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);  
4646
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4647
                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4648
        /* rounding type for motion estimation */
4649
        s->no_rounding = get_bits1(gb);
4650
    } else {
4651
        s->no_rounding = 0;
4652
    }
4653
//FIXME reduced res stuff
4654

    
4655
     if (s->shape != RECT_SHAPE) {
4656
         if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4657
             int width, height, hor_spat_ref, ver_spat_ref;
4658
 
4659
             width = get_bits(gb, 13);
4660
             skip_bits1(gb);   /* marker */
4661
             height = get_bits(gb, 13);
4662
             skip_bits1(gb);   /* marker */
4663
             hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
4664
             skip_bits1(gb);   /* marker */
4665
             ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
4666
         }
4667
         skip_bits1(gb); /* change_CR_disable */
4668
 
4669
         if (get_bits1(gb) != 0) {
4670
             skip_bits(gb, 8); /* constant_alpha_value */
4671
         }
4672
     }
4673
//FIXME complexity estimation stuff
4674
     
4675
     if (s->shape != BIN_ONLY_SHAPE) {
4676
         int t;
4677
         t=get_bits(gb, 3); /* intra dc VLC threshold */
4678
//printf("threshold %d\n", t);
4679
         if(!s->progressive_sequence){
4680
             s->top_field_first= get_bits1(gb);
4681
             s->alternate_scan= get_bits1(gb);
4682
         }else
4683
             s->alternate_scan= 0;
4684
     }
4685

    
4686
     if(s->alternate_scan){
4687
         ff_init_scantable(s, &s->inter_scantable  , ff_alternate_vertical_scan);
4688
         ff_init_scantable(s, &s->intra_scantable  , ff_alternate_vertical_scan);
4689
         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
4690
         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4691
     } else{
4692
         ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
4693
         ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
4694
         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
4695
         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4696
     }
4697
 
4698