Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ bc0219fd

History | View | Annotate | Download (178 KB)

1
/*
2
 * H263/MPEG4 backend for ffmpeg encoder and decoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 * H263+ support.
5
 * Copyright (c) 2001 Juan J. Sierralta P.
6
 *
7
 * This library is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2 of the License, or (at your option) any later version.
11
 *
12
 * This library is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library; if not, write to the Free Software
19
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20
 *
21
 * ac prediction encoding, b-frame support, error resilience, optimizations,
22
 * qpel decoding, gmc decoding, interlaced decoding, 
23
 * by Michael Niedermayer <michaelni@gmx.at>
24
 */
25

    
26
/**
27
 * @file h263.c
28
 * h263/mpeg4 codec.
29
 */
30
 
31
//#define DEBUG
32
#include <limits.h>
33

    
34
#include "common.h"
35
#include "dsputil.h"
36
#include "avcodec.h"
37
#include "mpegvideo.h"
38
#include "h263data.h"
39
#include "mpeg4data.h"
40

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

    
44
#define INTRA_MCBPC_VLC_BITS 6
45
#define INTER_MCBPC_VLC_BITS 7
46
#define CBPY_VLC_BITS 6
47
#define MV_VLC_BITS 9
48
#define DC_VLC_BITS 9
49
#define SPRITE_TRAJ_VLC_BITS 6
50
#define MB_TYPE_B_VLC_BITS 4
51
#define TEX_VLC_BITS 9
52

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

    
63
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
64
static int h263p_decode_umotion(MpegEncContext * s, int pred);
65
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
66
                             int n, int coded);
67
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
68
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
69
                              int n, int coded, int intra, int rvlc);
70
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
71
#ifdef CONFIG_ENCODERS
72
static void mpeg4_encode_visual_object_header(MpegEncContext * s);
73
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
74
#endif //CONFIG_ENCODERS
75
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
76
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
77

    
78
#ifdef CONFIG_ENCODERS
79
static uint8_t uni_DCtab_lum_len[512];
80
static uint8_t uni_DCtab_chrom_len[512];
81
static uint16_t uni_DCtab_lum_bits[512];
82
static uint16_t uni_DCtab_chrom_bits[512];
83

    
84
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
85
static uint8_t fcode_tab[MAX_MV*2+1];
86
static uint8_t umv_fcode_tab[MAX_MV*2+1];
87

    
88
static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
89
static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
90
static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
91
static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
92
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
93
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
94
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
95

    
96
/* mpeg4
97
inter
98
max level: 24/6
99
max run: 53/63
100

101
intra
102
max level: 53/16
103
max run: 29/41
104
*/
105
#endif
106

    
107
#if 0 //3IV1 is quite rare and tis slows things down a tiny bit
108
#define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
109
#else 
110
#define IS_3IV1 0
111
#endif
112

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

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

    
132
#ifdef CONFIG_ENCODERS
133

    
134
static void aspect_to_info(MpegEncContext * s, AVRational aspect){
135
    int i;
136

    
137
    if(aspect.num==0) aspect= (AVRational){1,1};
138

    
139
    for(i=1; i<6; i++){
140
        if(av_cmp_q(pixel_aspect[i], aspect) == 0){
141
            s->aspect_ratio_info=i;
142
            return;
143
        }
144
    }
145
    
146
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
147
}
148

    
149
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
150
{
151
      int format;
152

    
153
      align_put_bits(&s->pb);
154

    
155
      put_bits(&s->pb, 17, 1);
156
      put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
157
      put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / 
158
                           s->avctx->frame_rate) & 0xff); /* TemporalReference */
159
      if (s->width == 352 && s->height == 288)
160
        format = 2;
161
      else if (s->width == 176 && s->height == 144)
162
        format = 3;
163
      else if (s->width == 128 && s->height == 96)
164
        format = 4;
165
      else if (s->width == 320 && s->height == 240)
166
        format = 5;
167
      else if (s->width == 160 && s->height == 120)
168
        format = 6;
169
      else if (s->width <= 255 && s->height <= 255)
170
        format = 0; /* use 1 byte width & height */
171
      else
172
        format = 1; /* use 2 bytes width & height */
173
      put_bits(&s->pb, 3, format); /* PictureSize */
174
      if (format == 0) {
175
        put_bits(&s->pb, 8, s->width);
176
        put_bits(&s->pb, 8, s->height);
177
      } else if (format == 1) {
178
        put_bits(&s->pb, 16, s->width);
179
        put_bits(&s->pb, 16, s->height);
180
      }
181
      put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
182
      put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
183
      put_bits(&s->pb, 5, s->qscale); /* Quantizer */
184
      put_bits(&s->pb, 1, 0); /* ExtraInformation */
185

    
186
      if(s->h263_aic){
187
        s->y_dc_scale_table= 
188
          s->c_dc_scale_table= h263_aic_dc_scale_table;
189
      }else{
190
        s->y_dc_scale_table=
191
          s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
192
      }
193
}
194

    
195
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
196
{
197
    int format;
198

    
199
    align_put_bits(&s->pb);
200

    
201
    /* Update the pointer to last GOB */
202
    s->ptr_lastgob = pbBufPtr(&s->pb);
203
    s->gob_number = 0;
204

    
205
    put_bits(&s->pb, 22, 0x20); /* PSC */
206
    put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / 
207
                         s->avctx->frame_rate) & 0xff);
208

    
209
    put_bits(&s->pb, 1, 1);        /* marker */
210
    put_bits(&s->pb, 1, 0);        /* h263 id */
211
    put_bits(&s->pb, 1, 0);        /* split screen off */
212
    put_bits(&s->pb, 1, 0);        /* camera  off */
213
    put_bits(&s->pb, 1, 0);        /* freeze picture release off */
214
    
215
    format = h263_get_picture_format(s->width, s->height);
216
    if (!s->h263_plus) {
217
        /* H.263v1 */
218
        put_bits(&s->pb, 3, format);
219
        put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
220
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
221
        of H.263v1 UMV implies to check the predicted MV after
222
        calculation of the current MB to see if we're on the limits */
223
        put_bits(&s->pb, 1, 0);        /* unrestricted motion vector: off */
224
        put_bits(&s->pb, 1, 0);        /* SAC: off */
225
        put_bits(&s->pb, 1, 0);        /* advanced prediction mode: off */
226
        put_bits(&s->pb, 1, 0);        /* not PB frame */
227
        put_bits(&s->pb, 5, s->qscale);
228
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
229
    } else {
230
        /* H.263v2 */
231
        /* H.263 Plus PTYPE */
232
        put_bits(&s->pb, 3, 7);
233
        put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
234
        if (format == 7)
235
            put_bits(&s->pb,3,6); /* Custom Source Format */
236
        else
237
            put_bits(&s->pb, 3, format);
238
            
239
        put_bits(&s->pb,1,0); /* Custom PCF: off */
240
        s->umvplus = s->unrestricted_mv;
241
        put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
242
        put_bits(&s->pb,1,0); /* SAC: off */
243
        put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
244
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
245
        put_bits(&s->pb,1,0); /* Deblocking Filter: off */
246
        put_bits(&s->pb,1,0); /* Slice Structured: off */
247
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
248
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
249
        put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
250
        put_bits(&s->pb,1,0); /* Modified Quantization: off */
251
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
252
        put_bits(&s->pb,3,0); /* Reserved */
253
                
254
        put_bits(&s->pb, 3, s->pict_type == P_TYPE);
255
                
256
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
257
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
258
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
259
        put_bits(&s->pb,2,0); /* Reserved */
260
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
261
                
262
        /* This should be here if PLUSPTYPE */
263
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
264
                
265
                if (format == 7) {
266
            /* Custom Picture Format (CPFMT) */
267
            aspect_to_info(s, s->avctx->sample_aspect_ratio);
268

    
269
            put_bits(&s->pb,4,s->aspect_ratio_info);
270
            put_bits(&s->pb,9,(s->width >> 2) - 1);
271
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
272
            put_bits(&s->pb,9,(s->height >> 2));
273
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
274
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
275
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
276
            }
277
        }
278
        
279
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
280
        if (s->umvplus)
281
//            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
282
            put_bits(&s->pb,2,1); /* unlimited */
283

    
284
        put_bits(&s->pb, 5, s->qscale);
285
    }
286

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

    
289
    if(s->h263_aic){
290
         s->y_dc_scale_table= 
291
         s->c_dc_scale_table= h263_aic_dc_scale_table;
292
    }else{
293
        s->y_dc_scale_table=
294
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
295
    }
296
}
297

    
298
/**
299
 * Encodes a group of blocks header.
300
 */
301
int h263_encode_gob_header(MpegEncContext * s, int mb_line)
302
{
303
           align_put_bits(&s->pb);
304
           flush_put_bits(&s->pb);
305
           /* Call the RTP callback to send the last GOB */
306
           if (s->rtp_callback) {
307
               int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
308
               s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
309
           }
310
           put_bits(&s->pb, 17, 1); /* GBSC */
311
           s->gob_number = mb_line / s->gob_index;
312
           put_bits(&s->pb, 5, s->gob_number); /* GN */
313
           put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
314
           put_bits(&s->pb, 5, s->qscale); /* GQUANT */
315
           //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
316
    return 0;
317
}
318

    
319
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
320
    int last=0;
321
    int j;
322
    int rate=0;
323

    
324
    for(j=1; j<=block_last_index; j++){
325
        const int index= scantable[j];
326
        int level= block[index];
327
        if(level){
328
            level+= 64;
329
            if((level&(~127)) == 0){
330
                if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
331
                else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
332
            }else
333
                rate += s->ac_esc_length;
334
            level-= 64;
335

    
336
            last= j;
337
        }
338
    }
339
    
340
    return rate;
341
}
342

    
343
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
344
{
345
    int score= 0;
346
    int i, n;
347
    int8_t * const qscale_table= s->current_picture.qscale_table;
348

    
349
    memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
350
    
351
    for(n=0; n<6; n++){
352
        int16_t *ac_val, *ac_val1;
353
        
354
        score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
355

    
356
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
357
        ac_val1= ac_val;
358
        if(dir[n]){
359
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
360
            /* top prediction */
361
            ac_val-= s->block_wrap[n]*16;
362
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
363
                /* same qscale */
364
                for(i=1; i<8; i++){
365
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
366
                    block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
367
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
368
                    ac_val1[i+8]= level;
369
                }
370
            }else{
371
                /* different qscale, we must rescale */
372
                for(i=1; i<8; i++){
373
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
374
                    block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
375
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
376
                    ac_val1[i+8]= level;
377
                }
378
            }
379
            st[n]= s->intra_h_scantable.permutated;
380
        }else{
381
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
382
            /* left prediction */
383
            ac_val-= 16;
384
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
385
                /* same qscale */
386
                for(i=1; i<8; i++){
387
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
388
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
389
                    ac_val1[i  ]= level;
390
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
391
                }
392
            }else{
393
                /* different qscale, we must rescale */
394
                for(i=1; i<8; i++){
395
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
396
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
397
                    ac_val1[i  ]= level;
398
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
399
                }
400
            }
401
            st[n]= s->intra_v_scantable.permutated;
402
        }
403

    
404
        for(i=63; i>0; i--) //FIXME optimize
405
            if(block[n][ st[n][i] ]) break;
406
        s->block_last_index[n]= i;
407

    
408
        score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
409
    }
410

    
411
    return score < 0;
412
}
413

    
414
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
415
{
416
    int i, n;
417
    memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
418

    
419
    for(n=0; n<6; n++){
420
        int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
421

    
422
        st[n]= s->intra_scantable.permutated;
423
        if(dir[n]){
424
            /* top prediction */
425
            for(i=1; i<8; i++){
426
                block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
427
            }
428
        }else{
429
            /* left prediction */
430
            for(i=1; i<8; i++){
431
                block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
432
            }
433
        }
434
    }
435
}
436

    
437
/**
438
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
439
 */
440
void ff_clean_h263_qscales(MpegEncContext *s){
441
    int i;
442
    int8_t * const qscale_table= s->current_picture.qscale_table;
443
    
444
    for(i=1; i<s->mb_num; i++){
445
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
446
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
447
    }
448
    for(i=s->mb_num-2; i>=0; i--){
449
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
450
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
451
    }
452
}
453

    
454
/**
455
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
456
 */
457
void ff_clean_mpeg4_qscales(MpegEncContext *s){
458
    int i;
459
    int8_t * const qscale_table= s->current_picture.qscale_table;
460

    
461
    ff_clean_h263_qscales(s);
462
    
463
    for(i=1; i<s->mb_num; i++){
464
        int mb_xy= s->mb_index2xy[i];
465
    
466
        if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_INTER4V)){
467
            s->mb_type[mb_xy]&= ~MB_TYPE_INTER4V;
468
            s->mb_type[mb_xy]|= MB_TYPE_INTER;
469
        }
470
    }
471

    
472
    if(s->pict_type== B_TYPE){
473
        int odd=0;
474
        /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
475
           for the actual adaptive quantization */
476
        
477
        for(i=0; i<s->mb_num; i++){
478
            int mb_xy= s->mb_index2xy[i];
479
            odd += qscale_table[mb_xy]&1;
480
        }
481
        
482
        if(2*odd > s->mb_num) odd=1;
483
        else                  odd=0;
484
        
485
        for(i=0; i<s->mb_num; i++){
486
            int mb_xy= s->mb_index2xy[i];
487
            if((qscale_table[mb_xy]&1) != odd)
488
                qscale_table[mb_xy]++;
489
            if(qscale_table[mb_xy] > 31)
490
                qscale_table[mb_xy]= 31;
491
        }            
492
    
493
        for(i=1; i<s->mb_num; i++){
494
            int mb_xy= s->mb_index2xy[i];
495
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_DIRECT)){
496
                s->mb_type[mb_xy]&= ~MB_TYPE_DIRECT;
497
                s->mb_type[mb_xy]|= MB_TYPE_BIDIR;
498
            }
499
        }
500
    }
501
}
502

    
503
#endif //CONFIG_ENCODERS
504
/**
505
 *
506
 * @return the mb_type
507
 */
508
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
509
    const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
510
    const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next?
511
    int xy= s->block_index[0];
512
    uint16_t time_pp= s->pp_time;
513
    uint16_t time_pb= s->pb_time;
514
    int i;
515
    
516
    //FIXME avoid divides
517
    
518
    if(IS_8X8(colocated_mb_type)){
519
        s->mv_type = MV_TYPE_8X8;
520
        for(i=0; i<4; i++){
521
            xy= s->block_index[i];
522
            s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
523
            s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
524
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
525
                                : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
526
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1] 
527
                                : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
528
        }
529
        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
530
    } else if(IS_INTERLACED(colocated_mb_type)){
531
        s->mv_type = MV_TYPE_FIELD;
532
        for(i=0; i<2; i++){
533
            if(s->top_field_first){
534
                time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
535
                time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
536
            }else{
537
                time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
538
                time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
539
            }
540
            s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
541
            s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
542
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
543
                                : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
544
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] 
545
                                : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
546
        }
547
        return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
548
    }else{
549
        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;
550
        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;
551
        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]
552
                            : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
553
        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] 
554
                            : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
555
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
556
            s->mv_type= MV_TYPE_16X16;
557
        else
558
            s->mv_type= MV_TYPE_8X8;
559
        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
560
    }
561
}
562

    
563
void ff_h263_update_motion_val(MpegEncContext * s){
564
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
565
               //FIXME a lot of thet is only needed for !low_delay
566
    const int wrap = s->block_wrap[0];
567
    const int xy = s->block_index[0];
568
    
569
    s->current_picture.mbskip_table[mb_xy]= s->mb_skiped; 
570

    
571
    if(s->mv_type != MV_TYPE_8X8){
572
        int motion_x, motion_y;
573
        if (s->mb_intra) {
574
            motion_x = 0;
575
            motion_y = 0;
576
        } else if (s->mv_type == MV_TYPE_16X16) {
577
            motion_x = s->mv[0][0][0];
578
            motion_y = s->mv[0][0][1];
579
        } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
580
            int i;
581
            motion_x = s->mv[0][0][0] + s->mv[0][1][0];
582
            motion_y = s->mv[0][0][1] + s->mv[0][1][1];
583
            motion_x = (motion_x>>1) | (motion_x&1);
584
            for(i=0; i<2; i++){
585
                s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
586
                s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
587
                s->field_select_table[mb_xy][i]= s->field_select[0][i];
588
            }
589
        }
590
        
591
        /* no update if 8X8 because it has been done during parsing */
592
        s->motion_val[xy][0] = motion_x;
593
        s->motion_val[xy][1] = motion_y;
594
        s->motion_val[xy + 1][0] = motion_x;
595
        s->motion_val[xy + 1][1] = motion_y;
596
        s->motion_val[xy + wrap][0] = motion_x;
597
        s->motion_val[xy + wrap][1] = motion_y;
598
        s->motion_val[xy + 1 + wrap][0] = motion_x;
599
        s->motion_val[xy + 1 + wrap][1] = motion_y;
600
    }
601

    
602
    if(s->encoding){ //FIXME encoding MUST be cleaned up
603
        if (s->mv_type == MV_TYPE_8X8) 
604
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
605
        else
606
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
607
    }
608
}
609

    
610
#ifdef CONFIG_ENCODERS
611

    
612
static inline int get_p_cbp(MpegEncContext * s,
613
                      DCTELEM block[6][64],
614
                      int motion_x, int motion_y){
615
    int cbp, i;
616

    
617
    if(s->flags & CODEC_FLAG_CBP_RD){
618
        int best_cbpy_score= INT_MAX;
619
        int best_cbpc_score= INT_MAX;
620
        int cbpc, cbpy;
621
        const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
622
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
623

    
624
        for(i=0; i<4; i++){
625
            int score= inter_MCBPC_bits[i + offset] * lambda;
626
            if(i&1) score += s->coded_score[5];
627
            if(i&2) score += s->coded_score[4];
628

    
629
            if(score < best_cbpc_score){
630
                best_cbpc_score= score;
631
                cbpc= i;
632
            }
633
        }
634

    
635
        for(i=0; i<16; i++){
636
            int score= cbpy_tab[i ^ 0xF][1] * lambda;
637
            if(i&1) score += s->coded_score[3];
638
            if(i&2) score += s->coded_score[2];
639
            if(i&4) score += s->coded_score[1];
640
            if(i&8) score += s->coded_score[0];
641

    
642
            if(score < best_cbpy_score){
643
                best_cbpy_score= score;
644
                cbpy= i;
645
            }
646
        }
647
        cbp= cbpc + 4*cbpy;
648
        if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
649
            if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
650
                cbp= 0;
651
        }
652

    
653
        for (i = 0; i < 6; i++) {
654
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
655
                s->block_last_index[i]= -1;
656
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
657
            }
658
        }
659
    }else{
660
        cbp= 0;
661
        for (i = 0; i < 6; i++) {
662
            if (s->block_last_index[i] >= 0)
663
                cbp |= 1 << (5 - i);
664
        }
665
    }
666
    return cbp;
667
}
668

    
669
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
670
                            int motion_x, int motion_y, int mb_type){
671
    int cbp=0, i;
672

    
673
    if(s->flags & CODEC_FLAG_CBP_RD){
674
        int score=0;
675
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
676
        
677
        for(i=0; i<6; i++){
678
            if(s->coded_score[i] < 0){
679
                score += s->coded_score[i];
680
                cbp |= 1 << (5 - i);
681
            }
682
        }
683
        
684
        if(cbp){
685
            int zero_score= -6;
686
            if ((motion_x | motion_y | s->dquant | mb_type) == 0){
687
                zero_score-= 4; //2*MV + mb_type + cbp bit
688
            }
689

    
690
            zero_score*= lambda;
691
            if(zero_score <= score){
692
                cbp=0;
693
            }
694
        }
695

    
696
        for (i = 0; i < 6; i++) {
697
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
698
                s->block_last_index[i]= -1;
699
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
700
            }
701
        }
702
    }else{
703
        for (i = 0; i < 6; i++) {
704
            if (s->block_last_index[i] >= 0)
705
                cbp |= 1 << (5 - i);
706
        }
707
    }
708
    return cbp;
709
}
710

    
711
void mpeg4_encode_mb(MpegEncContext * s,
712
                    DCTELEM block[6][64],
713
                    int motion_x, int motion_y)
714
{
715
    int cbpc, cbpy, pred_x, pred_y;
716
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
717
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
718
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
719
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
720
    const int dquant_code[5]= {1,0,9,2,3};
721
    
722
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
723
    if (!s->mb_intra) {
724
        /* compute cbp */
725
        int i, cbp;
726
        
727
        if(s->pict_type==B_TYPE){
728
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
729
            int mb_type=  mb_type_table[s->mv_dir];
730
            
731
            if(s->mb_x==0){
732
                s->last_mv[0][0][0]= 
733
                s->last_mv[0][0][1]= 
734
                s->last_mv[1][0][0]= 
735
                s->last_mv[1][0][1]= 0;
736
            }
737
            
738
            assert(s->dquant>=-2 && s->dquant<=2);
739
            assert((s->dquant&1)==0);
740
            assert(mb_type>=0);
741

    
742
            /* nothing to do if this MB was skiped in the next P Frame */
743
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
744
                s->skip_count++;
745
                s->mv[0][0][0]= 
746
                s->mv[0][0][1]= 
747
                s->mv[1][0][0]= 
748
                s->mv[1][0][1]= 0;
749
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
750
                s->qscale -= s->dquant;
751
//                s->mb_skiped=1;
752

    
753
                return;
754
            }
755
            
756
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
757
            
758
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
759
                /* direct MB with MV={0,0} */
760
                assert(s->dquant==0);
761
                
762
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
763

    
764
                if(interleaved_stats){
765
                    s->misc_bits++;
766
                    s->last_bits++;
767
                }
768
                s->skip_count++;
769
                return;
770
            }
771
            
772
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
773
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
774
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
775
            if(cbp) put_bits(&s->pb, 6, cbp);
776
            
777
            if(cbp && mb_type){
778
                if(s->dquant)
779
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
780
                else
781
                    put_bits(&s->pb, 1, 0);
782
            }else
783
                s->qscale -= s->dquant;
784
            
785
            if(!s->progressive_sequence){
786
                if(cbp)
787
                    put_bits(&s->pb, 1, s->interlaced_dct);
788
                if(mb_type) // not diect mode
789
                    put_bits(&s->pb, 1, 0); // no interlaced ME yet
790
            }
791

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

    
796
            switch(mb_type)
797
            {
798
            case 0: /* direct */
799
                h263_encode_motion(s, motion_x, 1);
800
                h263_encode_motion(s, motion_y, 1);                
801
                s->b_count++;
802
                s->f_count++;
803
                break;
804
            case 1: /* bidir */
805
                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
806
                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
807
                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
808
                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
809
                s->last_mv[0][0][0]= s->mv[0][0][0];
810
                s->last_mv[0][0][1]= s->mv[0][0][1];
811
                s->last_mv[1][0][0]= s->mv[1][0][0];
812
                s->last_mv[1][0][1]= s->mv[1][0][1];
813
                s->b_count++;
814
                s->f_count++;
815
                break;
816
            case 2: /* backward */
817
                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
818
                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
819
                s->last_mv[1][0][0]= motion_x;
820
                s->last_mv[1][0][1]= motion_y;
821
                s->b_count++;
822
                break;
823
            case 3: /* forward */
824
                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
825
                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
826
                s->last_mv[0][0][0]= motion_x;
827
                s->last_mv[0][0][1]= motion_y;
828
                s->f_count++;
829
                break;
830
            default:
831
                printf("unknown mb type\n");
832
                return;
833
            }
834

    
835
            if(interleaved_stats){
836
                s->mv_bits+= get_bits_diff(s);
837
            }
838

    
839
            /* encode each block */
840
            for (i = 0; i < 6; i++) {
841
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
842
            }
843

    
844
            if(interleaved_stats){
845
                s->p_tex_bits+= get_bits_diff(s);
846
            }
847
        }else{ /* s->pict_type==B_TYPE */
848
            cbp= get_p_cbp(s, block, motion_x, motion_y);
849
        
850
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
851
                /* check if the B frames can skip it too, as we must skip it if we skip here 
852
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
853
                if(s->max_b_frames>0){
854
                    int i;
855
                    int x,y, offset;
856
                    uint8_t *p_pic;
857

    
858
                    x= s->mb_x*16;
859
                    y= s->mb_y*16;
860
                    if(x+16 > s->width)  x= s->width-16;
861
                    if(y+16 > s->height) y= s->height-16;
862

    
863
                    offset= x + y*s->linesize;
864
                    p_pic= s->new_picture.data[0] + offset;
865
                    
866
                    s->mb_skiped=1;
867
                    for(i=0; i<s->max_b_frames; i++){
868
                        uint8_t *b_pic;
869
                        int diff;
870
                        Picture *pic= s->reordered_input_picture[i+1];
871

    
872
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
873

    
874
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
875
                        diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
876
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
877
                            s->mb_skiped=0;
878
                            break;
879
                        }
880
                    }
881
                }else
882
                    s->mb_skiped=1; 
883

    
884
                if(s->mb_skiped==1){
885
                    /* skip macroblock */
886
                    put_bits(&s->pb, 1, 1);
887

    
888
                    if(interleaved_stats){
889
                        s->misc_bits++;
890
                        s->last_bits++;
891
                    }
892
                    s->skip_count++;
893
                    
894
                    return;
895
                }
896
            }
897

    
898
            put_bits(&s->pb, 1, 0);        /* mb coded */
899
            if(s->mv_type==MV_TYPE_16X16){
900
                cbpc = cbp & 3;
901
                if(s->dquant) cbpc+= 8;
902
                put_bits(&s->pb,
903
                        inter_MCBPC_bits[cbpc],
904
                        inter_MCBPC_code[cbpc]);
905

    
906
                cbpy = cbp >> 2;
907
                cbpy ^= 0xf;
908
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
909
                if(s->dquant)
910
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
911

    
912
                if(!s->progressive_sequence){
913
                    if(cbp)
914
                        put_bits(pb2, 1, s->interlaced_dct);
915
                    put_bits(pb2, 1, 0); // no interlaced ME yet
916
                }
917
                    
918
                if(interleaved_stats){
919
                    s->misc_bits+= get_bits_diff(s);
920
                }
921

    
922
                /* motion vectors: 16x16 mode */
923
                h263_pred_motion(s, 0, &pred_x, &pred_y);
924
            
925
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
926
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
927
            }else{
928
                cbpc = (cbp & 3)+16;
929
                put_bits(&s->pb,
930
                        inter_MCBPC_bits[cbpc],
931
                        inter_MCBPC_code[cbpc]);
932
                cbpy = cbp >> 2;
933
                cbpy ^= 0xf;
934
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
935

    
936
                if(!s->progressive_sequence){
937
                    if(cbp)
938
                        put_bits(pb2, 1, s->interlaced_dct);
939
                }
940
    
941
                if(interleaved_stats){
942
                    s->misc_bits+= get_bits_diff(s);
943
                }
944

    
945
                for(i=0; i<4; i++){
946
                    /* motion vectors: 8x8 mode*/
947
                    h263_pred_motion(s, i, &pred_x, &pred_y);
948

    
949
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
950
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
951
                }
952
            }
953

    
954
            if(interleaved_stats){ 
955
                s->mv_bits+= get_bits_diff(s);
956
            }
957

    
958
            /* encode each block */
959
            for (i = 0; i < 6; i++) {
960
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
961
            }
962

    
963
            if(interleaved_stats){
964
                s->p_tex_bits+= get_bits_diff(s);
965
            }
966
            s->f_count++;
967
        }
968
    } else {
969
        int cbp;
970
        int dc_diff[6];   //dc values with the dc prediction subtracted 
971
        int dir[6];  //prediction direction
972
        int zigzag_last_index[6];
973
        uint8_t *scan_table[6];
974
        int i;
975

    
976
        for(i=0; i<6; i++){
977
            const int level= block[i][0];
978
            uint16_t *dc_ptr;
979

    
980
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
981
            if (i < 4) {
982
                *dc_ptr = level * s->y_dc_scale;
983
            } else {
984
                *dc_ptr = level * s->c_dc_scale;
985
            }
986
        }
987

    
988
        if(s->flags & CODEC_FLAG_AC_PRED){
989
            s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
990
            if(!s->ac_pred)
991
                restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
992
        }else{
993
            for(i=0; i<6; i++)
994
                scan_table[i]= s->intra_scantable.permutated;
995
        }
996

    
997
        /* compute cbp */
998
        cbp = 0;
999
        for (i = 0; i < 6; i++) {
1000
            if (s->block_last_index[i] >= 1)
1001
                cbp |= 1 << (5 - i);
1002
        }
1003

    
1004
        cbpc = cbp & 3;
1005
        if (s->pict_type == I_TYPE) {
1006
            if(s->dquant) cbpc+=4;
1007
            put_bits(&s->pb,
1008
                intra_MCBPC_bits[cbpc],
1009
                intra_MCBPC_code[cbpc]);
1010
        } else {
1011
            if(s->dquant) cbpc+=8;
1012
            put_bits(&s->pb, 1, 0);        /* mb coded */
1013
            put_bits(&s->pb,
1014
                inter_MCBPC_bits[cbpc + 4],
1015
                inter_MCBPC_code[cbpc + 4]);
1016
        }
1017
        put_bits(pb2, 1, s->ac_pred);
1018
        cbpy = cbp >> 2;
1019
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1020
        if(s->dquant)
1021
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1022

    
1023
        if(!s->progressive_sequence){
1024
            put_bits(dc_pb, 1, s->interlaced_dct);
1025
        }
1026

    
1027
        if(interleaved_stats){
1028
            s->misc_bits+= get_bits_diff(s);
1029
        }
1030

    
1031
        /* encode each block */
1032
        for (i = 0; i < 6; i++) {
1033
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
1034
        }
1035

    
1036
        if(interleaved_stats){
1037
            s->i_tex_bits+= get_bits_diff(s);
1038
        }
1039
        s->i_count++;
1040

    
1041
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1042
        if(s->ac_pred)
1043
            restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1044
    }
1045
}
1046

    
1047
void h263_encode_mb(MpegEncContext * s,
1048
                    DCTELEM block[6][64],
1049
                    int motion_x, int motion_y)
1050
{
1051
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
1052
    int16_t pred_dc;
1053
    int16_t rec_intradc[6];
1054
    uint16_t *dc_ptr[6];
1055
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1056
    const int dquant_code[5]= {1,0,9,2,3};
1057
           
1058
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1059
    if (!s->mb_intra) {
1060
        /* compute cbp */
1061
        cbp= get_p_cbp(s, block, motion_x, motion_y);
1062

    
1063
        if ((cbp | motion_x | motion_y | s->dquant) == 0) {
1064
            /* skip macroblock */
1065
            put_bits(&s->pb, 1, 1);
1066
            if(interleaved_stats){
1067
                s->misc_bits++;
1068
                s->last_bits++;
1069
            }
1070
            return;
1071
        }
1072
        put_bits(&s->pb, 1, 0);        /* mb coded */
1073
        cbpc = cbp & 3;
1074
        if(s->dquant) cbpc+= 8;
1075
        put_bits(&s->pb,
1076
                    inter_MCBPC_bits[cbpc],
1077
                    inter_MCBPC_code[cbpc]);
1078
        cbpy = cbp >> 2;
1079
        cbpy ^= 0xf;
1080
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1081
        if(s->dquant)
1082
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1083

    
1084
        if(interleaved_stats){
1085
            s->misc_bits+= get_bits_diff(s);
1086
        }
1087

    
1088
        /* motion vectors: 16x16 mode only now */
1089
        h263_pred_motion(s, 0, &pred_x, &pred_y);
1090
      
1091
        if (!s->umvplus) {  
1092
            h263_encode_motion(s, motion_x - pred_x, s->f_code);
1093
            h263_encode_motion(s, motion_y - pred_y, s->f_code);
1094
        }
1095
        else {
1096
            h263p_encode_umotion(s, motion_x - pred_x);
1097
            h263p_encode_umotion(s, motion_y - pred_y);
1098
            if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1099
                /* To prevent Start Code emulation */
1100
                put_bits(&s->pb,1,1);
1101
        }
1102

    
1103
        if(interleaved_stats){
1104
            s->mv_bits+= get_bits_diff(s);
1105
        }
1106
    } else {
1107
        int li = s->h263_aic ? 0 : 1;
1108
        
1109
        cbp = 0;
1110
        for(i=0; i<6; i++) {
1111
            /* Predict DC */
1112
            if (s->h263_aic && s->mb_intra) {
1113
                int16_t level = block[i][0];
1114
            
1115
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1116
                level -= pred_dc;
1117
                /* Quant */
1118
                if (level < 0)
1119
                    level = (level + (s->qscale >> 1))/(s->y_dc_scale);
1120
                else
1121
                    level = (level - (s->qscale >> 1))/(s->y_dc_scale);
1122
                    
1123
                /* AIC can change CBP */
1124
                if (level == 0 && s->block_last_index[i] == 0)
1125
                    s->block_last_index[i] = -1;
1126
                else if (level < -127)
1127
                    level = -127;
1128
                else if (level > 127)
1129
                    level = 127;
1130
                
1131
                block[i][0] = level;
1132
                /* Reconstruction */ 
1133
                rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
1134
                /* Oddify */
1135
                rec_intradc[i] |= 1;
1136
                //if ((rec_intradc[i] % 2) == 0)
1137
                //    rec_intradc[i]++;
1138
                /* Clipping */
1139
                if (rec_intradc[i] < 0)
1140
                    rec_intradc[i] = 0;
1141
                else if (rec_intradc[i] > 2047)
1142
                    rec_intradc[i] = 2047;
1143
                                
1144
                /* Update AC/DC tables */
1145
                *dc_ptr[i] = rec_intradc[i];
1146
            }
1147
            /* compute cbp */
1148
            if (s->block_last_index[i] >= li)
1149
                cbp |= 1 << (5 - i);
1150
        }
1151

    
1152
        cbpc = cbp & 3;
1153
        if (s->pict_type == I_TYPE) {
1154
            if(s->dquant) cbpc+=4;
1155
            put_bits(&s->pb,
1156
                intra_MCBPC_bits[cbpc],
1157
                intra_MCBPC_code[cbpc]);
1158
        } else {
1159
            if(s->dquant) cbpc+=8;
1160
            put_bits(&s->pb, 1, 0);        /* mb coded */
1161
            put_bits(&s->pb,
1162
                inter_MCBPC_bits[cbpc + 4],
1163
                inter_MCBPC_code[cbpc + 4]);
1164
        }
1165
        if (s->h263_aic) {
1166
            /* XXX: currently, we do not try to use ac prediction */
1167
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
1168
        }
1169
        cbpy = cbp >> 2;
1170
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1171
        if(s->dquant)
1172
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1173

    
1174
        if(interleaved_stats){
1175
            s->misc_bits+= get_bits_diff(s);
1176
        }
1177
    }
1178

    
1179
    for(i=0; i<6; i++) {
1180
        /* encode each block */
1181
        h263_encode_block(s, block[i], i);
1182
    
1183
        /* Update INTRADC for decoding */
1184
        if (s->h263_aic && s->mb_intra) {
1185
            block[i][0] = rec_intradc[i];
1186
            
1187
        }
1188
    }
1189

    
1190
    if(interleaved_stats){
1191
        if (!s->mb_intra) {
1192
            s->p_tex_bits+= get_bits_diff(s);
1193
            s->f_count++;
1194
        }else{
1195
            s->i_tex_bits+= get_bits_diff(s);
1196
            s->i_count++;
1197
        }
1198
    }
1199
}
1200
#endif
1201

    
1202
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1203
{
1204
    int x, y, wrap, a, c, pred_dc, scale;
1205
    int16_t *dc_val, *ac_val;
1206

    
1207
    /* find prediction */
1208
    if (n < 4) {
1209
        x = 2 * s->mb_x + 1 + (n & 1);
1210
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1211
        wrap = s->mb_width * 2 + 2;
1212
        dc_val = s->dc_val[0];
1213
        ac_val = s->ac_val[0][0];
1214
        scale = s->y_dc_scale;
1215
    } else {
1216
        x = s->mb_x + 1;
1217
        y = s->mb_y + 1;
1218
        wrap = s->mb_width + 2;
1219
        dc_val = s->dc_val[n - 4 + 1];
1220
        ac_val = s->ac_val[n - 4 + 1][0];
1221
        scale = s->c_dc_scale;
1222
    }
1223
    /* B C
1224
     * A X 
1225
     */
1226
    a = dc_val[(x - 1) + (y) * wrap];
1227
    c = dc_val[(x) + (y - 1) * wrap];
1228
    
1229
    /* No prediction outside GOB boundary */
1230
    if (s->first_slice_line && ((n < 2) || (n > 3)))
1231
        c = 1024;
1232
    pred_dc = 1024;
1233
    /* just DC prediction */
1234
    if (a != 1024 && c != 1024)
1235
        pred_dc = (a + c) >> 1;
1236
    else if (a != 1024)
1237
        pred_dc = a;
1238
    else
1239
        pred_dc = c;
1240
    
1241
    /* we assume pred is positive */
1242
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1243
    *dc_val_ptr = &dc_val[x + y * wrap];
1244
    return pred_dc;
1245
}
1246

    
1247
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1248
{
1249
    int x, y, wrap, a, c, pred_dc, scale, i;
1250
    int16_t *dc_val, *ac_val, *ac_val1;
1251

    
1252
    /* find prediction */
1253
    if (n < 4) {
1254
        x = 2 * s->mb_x + 1 + (n & 1);
1255
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1256
        wrap = s->mb_width * 2 + 2;
1257
        dc_val = s->dc_val[0];
1258
        ac_val = s->ac_val[0][0];
1259
        scale = s->y_dc_scale;
1260
    } else {
1261
        x = s->mb_x + 1;
1262
        y = s->mb_y + 1;
1263
        wrap = s->mb_width + 2;
1264
        dc_val = s->dc_val[n - 4 + 1];
1265
        ac_val = s->ac_val[n - 4 + 1][0];
1266
        scale = s->c_dc_scale;
1267
    }
1268
    
1269
    ac_val += ((y) * wrap + (x)) * 16;
1270
    ac_val1 = ac_val;
1271
    
1272
    /* B C
1273
     * A X 
1274
     */
1275
    a = dc_val[(x - 1) + (y) * wrap];
1276
    c = dc_val[(x) + (y - 1) * wrap];
1277
    
1278
    /* No prediction outside GOB boundary */
1279
    if (s->first_slice_line && ((n < 2) || (n > 3)))
1280
        c = 1024;
1281
    pred_dc = 1024;
1282
    if (s->ac_pred) {
1283
        if (s->h263_aic_dir) {
1284
            /* left prediction */
1285
            if (a != 1024) {
1286
                ac_val -= 16;
1287
                for(i=1;i<8;i++) {
1288
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1289
                }
1290
                pred_dc = a;
1291
            }
1292
        } else {
1293
            /* top prediction */
1294
            if (c != 1024) {
1295
                ac_val -= 16 * wrap;
1296
                for(i=1;i<8;i++) {
1297
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1298
                }
1299
                pred_dc = c;
1300
            }
1301
        }
1302
    } else {
1303
        /* just DC prediction */
1304
        if (a != 1024 && c != 1024)
1305
            pred_dc = (a + c) >> 1;
1306
        else if (a != 1024)
1307
            pred_dc = a;
1308
        else
1309
            pred_dc = c;
1310
    }
1311
    
1312
    /* we assume pred is positive */
1313
    block[0]=block[0]*scale + pred_dc;
1314
    
1315
    if (block[0] < 0)
1316
        block[0] = 0;
1317
    else if (!(block[0] & 1))
1318
        block[0]++;
1319
    
1320
    /* Update AC/DC tables */
1321
    dc_val[(x) + (y) * wrap] = block[0];
1322
    
1323
    /* left copy */
1324
    for(i=1;i<8;i++)
1325
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1326
    /* top copy */
1327
    for(i=1;i<8;i++)
1328
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1329
}
1330

    
1331
int16_t *h263_pred_motion(MpegEncContext * s, int block, 
1332
                        int *px, int *py)
1333
{
1334
    int xy, wrap;
1335
    int16_t *A, *B, *C, *mot_val;
1336
    static const int off[4]= {2, 1, 1, -1};
1337

    
1338
    wrap = s->block_wrap[0];
1339
    xy = s->block_index[block];
1340

    
1341
    mot_val = s->motion_val[xy];
1342

    
1343
    A = s->motion_val[xy - 1];
1344
    /* special case for first (slice) line */
1345
    if (s->first_slice_line && block<3) {
1346
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1347
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1348
        if(block==0){ //most common case
1349
            if(s->mb_x  == s->resync_mb_x){ //rare
1350
                *px= *py = 0;
1351
            }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1352
                C = s->motion_val[xy + off[block] - wrap];
1353
                if(s->mb_x==0){
1354
                    *px = C[0];
1355
                    *py = C[1];
1356
                }else{
1357
                    *px = mid_pred(A[0], 0, C[0]);
1358
                    *py = mid_pred(A[1], 0, C[1]);
1359
                }
1360
            }else{
1361
                *px = A[0];
1362
                *py = A[1];
1363
            }
1364
        }else if(block==1){
1365
            if(s->mb_x + 1 == s->resync_mb_x){ //rare
1366
                C = s->motion_val[xy + off[block] - wrap];
1367
                *px = mid_pred(A[0], 0, C[0]);
1368
                *py = mid_pred(A[1], 0, C[1]);
1369
            }else{
1370
                *px = A[0];
1371
                *py = A[1];
1372
            }
1373
        }else{ /* block==2*/
1374
            B = s->motion_val[xy - wrap];
1375
            C = s->motion_val[xy + off[block] - wrap];
1376
            if(s->mb_x == s->resync_mb_x) //rare
1377
                A[0]=A[1]=0;
1378
    
1379
            *px = mid_pred(A[0], B[0], C[0]);
1380
            *py = mid_pred(A[1], B[1], C[1]);
1381
        }
1382
    } else {
1383
        B = s->motion_val[xy - wrap];
1384
        C = s->motion_val[xy + off[block] - wrap];
1385
        *px = mid_pred(A[0], B[0], C[0]);
1386
        *py = mid_pred(A[1], B[1], C[1]);
1387
    }
1388
    return mot_val;
1389
}
1390

    
1391
#ifdef CONFIG_ENCODERS
1392
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1393
{
1394
    int range, l, bit_size, sign, code, bits;
1395

    
1396
    if (val == 0) {
1397
        /* zero vector */
1398
        code = 0;
1399
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1400
    } else {
1401
        bit_size = f_code - 1;
1402
        range = 1 << bit_size;
1403
        /* modulo encoding */
1404
        l = range * 32;
1405
#if 1
1406
        val+= l;
1407
        val&= 2*l-1;
1408
        val-= l;
1409
        sign = val>>31;
1410
        val= (val^sign)-sign;
1411
        sign&=1;
1412
#else
1413
        if (val < -l) {
1414
            val += 2*l;
1415
        } else if (val >= l) {
1416
            val -= 2*l;
1417
        }
1418

    
1419
        assert(val>=-l && val<l);
1420

    
1421
        if (val >= 0) {
1422
            sign = 0;
1423
        } else {
1424
            val = -val;
1425
            sign = 1;
1426
        }
1427
#endif
1428
        val--;
1429
        code = (val >> bit_size) + 1;
1430
        bits = val & (range - 1);
1431

    
1432
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1433
        if (bit_size > 0) {
1434
            put_bits(&s->pb, bit_size, bits);
1435
        }
1436
    }
1437

    
1438
}
1439

    
1440
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1441
static void h263p_encode_umotion(MpegEncContext * s, int val)
1442
{
1443
    short sval = 0; 
1444
    short i = 0;
1445
    short n_bits = 0;
1446
    short temp_val;
1447
    int code = 0;
1448
    int tcode;
1449
    
1450
    if ( val == 0)
1451
        put_bits(&s->pb, 1, 1);
1452
    else if (val == 1)
1453
        put_bits(&s->pb, 3, 0);
1454
    else if (val == -1)
1455
        put_bits(&s->pb, 3, 2);
1456
    else {
1457
        
1458
        sval = ((val < 0) ? (short)(-val):(short)val);
1459
        temp_val = sval;
1460
        
1461
        while (temp_val != 0) {
1462
            temp_val = temp_val >> 1;
1463
            n_bits++;
1464
        }
1465
        
1466
        i = n_bits - 1;
1467
        while (i > 0) {
1468
            tcode = (sval & (1 << (i-1))) >> (i-1);
1469
            tcode = (tcode << 1) | 1;
1470
            code = (code << 2) | tcode;
1471
            i--;
1472
        }
1473
        code = ((code << 1) | (val < 0)) << 1;
1474
        put_bits(&s->pb, (2*n_bits)+1, code);
1475
        //printf("\nVal = %d\tCode = %d", sval, code);
1476
    }
1477
}
1478

    
1479
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1480
{
1481
    int f_code;
1482
    int mv;
1483
    
1484
    if(mv_penalty==NULL)
1485
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1486
    
1487
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1488
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1489
            int len;
1490

    
1491
            if(mv==0) len= mvtab[0][1];
1492
            else{
1493
                int val, bit_size, range, code;
1494

    
1495
                bit_size = s->f_code - 1;
1496
                range = 1 << bit_size;
1497

    
1498
                val=mv;
1499
                if (val < 0) 
1500
                    val = -val;
1501
                val--;
1502
                code = (val >> bit_size) + 1;
1503
                if(code<33){
1504
                    len= mvtab[code][1] + 1 + bit_size;
1505
                }else{
1506
                    len= mvtab[32][1] + 2 + bit_size;
1507
                }
1508
            }
1509

    
1510
            mv_penalty[f_code][mv+MAX_MV]= len;
1511
        }
1512
    }
1513

    
1514
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1515
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1516
            fcode_tab[mv+MAX_MV]= f_code;
1517
        }
1518
    }
1519

    
1520
    for(mv=0; mv<MAX_MV*2+1; mv++){
1521
        umv_fcode_tab[mv]= 1;
1522
    }
1523
}
1524
#endif
1525

    
1526
#ifdef CONFIG_ENCODERS
1527

    
1528
static void init_uni_dc_tab(void)
1529
{
1530
    int level, uni_code, uni_len;
1531

    
1532
    for(level=-256; level<256; level++){
1533
        int size, v, l;
1534
        /* find number of bits */
1535
        size = 0;
1536
        v = abs(level);
1537
        while (v) {
1538
            v >>= 1;
1539
            size++;
1540
        }
1541

    
1542
        if (level < 0)
1543
            l= (-level) ^ ((1 << size) - 1);
1544
        else
1545
            l= level;
1546

    
1547
        /* luminance */
1548
        uni_code= DCtab_lum[size][0];
1549
        uni_len = DCtab_lum[size][1];
1550

    
1551
        if (size > 0) {
1552
            uni_code<<=size; uni_code|=l;
1553
            uni_len+=size;
1554
            if (size > 8){
1555
                uni_code<<=1; uni_code|=1;
1556
                uni_len++;
1557
            }
1558
        }
1559
        uni_DCtab_lum_bits[level+256]= uni_code;
1560
        uni_DCtab_lum_len [level+256]= uni_len;
1561

    
1562
        /* chrominance */
1563
        uni_code= DCtab_chrom[size][0];
1564
        uni_len = DCtab_chrom[size][1];
1565
        
1566
        if (size > 0) {
1567
            uni_code<<=size; uni_code|=l;
1568
            uni_len+=size;
1569
            if (size > 8){
1570
                uni_code<<=1; uni_code|=1;
1571
                uni_len++;
1572
            }
1573
        }
1574
        uni_DCtab_chrom_bits[level+256]= uni_code;
1575
        uni_DCtab_chrom_len [level+256]= uni_len;
1576

    
1577
    }
1578
}
1579

    
1580
#endif //CONFIG_ENCODERS
1581

    
1582
#ifdef CONFIG_ENCODERS
1583
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1584
    int slevel, run, last;
1585
    
1586
    assert(MAX_LEVEL >= 64);
1587
    assert(MAX_RUN   >= 63);
1588

    
1589
    for(slevel=-64; slevel<64; slevel++){
1590
        if(slevel==0) continue;
1591
        for(run=0; run<64; run++){
1592
            for(last=0; last<=1; last++){
1593
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1594
                int level= slevel < 0 ? -slevel : slevel;
1595
                int sign= slevel < 0 ? 1 : 0;
1596
                int bits, len, code;
1597
                int level1, run1;
1598
                
1599
                len_tab[index]= 100;
1600
                     
1601
                /* ESC0 */
1602
                code= get_rl_index(rl, last, run, level);
1603
                bits= rl->table_vlc[code][0];
1604
                len=  rl->table_vlc[code][1];
1605
                bits=bits*2+sign; len++;
1606
                
1607
                if(code!=rl->n && len < len_tab[index]){
1608
                    bits_tab[index]= bits;
1609
                    len_tab [index]= len;
1610
                }
1611
#if 1
1612
                /* ESC1 */
1613
                bits= rl->table_vlc[rl->n][0];
1614
                len=  rl->table_vlc[rl->n][1];
1615
                bits=bits*2;    len++; //esc1
1616
                level1= level - rl->max_level[last][run];
1617
                if(level1>0){
1618
                    code= get_rl_index(rl, last, run, level1);
1619
                    bits<<= rl->table_vlc[code][1];
1620
                    len  += rl->table_vlc[code][1];
1621
                    bits += rl->table_vlc[code][0];
1622
                    bits=bits*2+sign; len++;
1623
                
1624
                    if(code!=rl->n && len < len_tab[index]){
1625
                        bits_tab[index]= bits;
1626
                        len_tab [index]= len;
1627
                    }
1628
                }
1629
#endif 
1630
#if 1
1631
                /* ESC2 */
1632
                bits= rl->table_vlc[rl->n][0];
1633
                len=  rl->table_vlc[rl->n][1];
1634
                bits=bits*4+2;    len+=2; //esc2
1635
                run1 = run - rl->max_run[last][level] - 1;
1636
                if(run1>=0){
1637
                    code= get_rl_index(rl, last, run1, level);
1638
                    bits<<= rl->table_vlc[code][1];
1639
                    len  += rl->table_vlc[code][1];
1640
                    bits += rl->table_vlc[code][0];
1641
                    bits=bits*2+sign; len++;
1642
                
1643
                    if(code!=rl->n && len < len_tab[index]){
1644
                        bits_tab[index]= bits;
1645
                        len_tab [index]= len;
1646
                    }
1647
                }
1648
#endif           
1649
                /* ESC3 */        
1650
                bits= rl->table_vlc[rl->n][0];
1651
                len = rl->table_vlc[rl->n][1];
1652
                bits=bits*4+3;    len+=2; //esc3
1653
                bits=bits*2+last; len++;
1654
                bits=bits*64+run; len+=6;
1655
                bits=bits*2+1;    len++;  //marker
1656
                bits=bits*4096+(slevel&0xfff); len+=12;
1657
                bits=bits*2+1;    len++;  //marker
1658
                
1659
                if(len < len_tab[index]){
1660
                    bits_tab[index]= bits;
1661
                    len_tab [index]= len;
1662
                }
1663
            }
1664
        }
1665
    }
1666
}
1667

    
1668
void h263_encode_init(MpegEncContext *s)
1669
{
1670
    static int done = 0;
1671

    
1672
    if (!done) {
1673
        done = 1;
1674

    
1675
        init_uni_dc_tab();
1676

    
1677
        init_rl(&rl_inter);
1678
        init_rl(&rl_intra);
1679
        init_rl(&rl_intra_aic);
1680
        
1681
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1682
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1683

    
1684
        init_mv_penalty_and_fcode(s);
1685
    }
1686
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1687
    
1688
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1689
    switch(s->codec_id){
1690
    case CODEC_ID_MPEG4:
1691
        s->fcode_tab= fcode_tab;
1692
        s->min_qcoeff= -2048;
1693
        s->max_qcoeff=  2047;
1694
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1695
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1696
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1697
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1698
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
1699
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1700
        s->ac_esc_length= 7+2+1+6+1+12+1;
1701
        
1702
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1703

    
1704
            s->avctx->extradata= av_malloc(1024);
1705
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
1706
            
1707
            mpeg4_encode_visual_object_header(s);
1708
            mpeg4_encode_vol_header(s, 0, 0);
1709

    
1710
//            ff_mpeg4_stuffing(&s->pb); ?
1711
            flush_put_bits(&s->pb);
1712
            s->avctx->extradata_size= (get_bit_count(&s->pb)+7)>>3;
1713
        }
1714
        
1715
        break;
1716
    case CODEC_ID_H263P:
1717
        s->fcode_tab= umv_fcode_tab;
1718
        s->min_qcoeff= -127;
1719
        s->max_qcoeff=  127;
1720
        break;
1721
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1722
    case CODEC_ID_FLV1:
1723
        if (s->h263_flv > 1) {
1724
            s->min_qcoeff= -1023;
1725
            s->max_qcoeff=  1023;
1726
        } else {
1727
            s->min_qcoeff= -127;
1728
            s->max_qcoeff=  127;
1729
        }
1730
        s->y_dc_scale_table=
1731
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1732
        break;
1733
    default: //nothing needed default table allready set in mpegvideo.c
1734
        s->min_qcoeff= -127;
1735
        s->max_qcoeff=  127;
1736
        s->y_dc_scale_table=
1737
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1738
    }
1739
}
1740

    
1741
/**
1742
 * encodes a 8x8 block.
1743
 * @param block the 8x8 block
1744
 * @param n block index (0-3 are luma, 4-5 are chroma)
1745
 */
1746
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1747
{
1748
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1749
    RLTable *rl;
1750

    
1751
    rl = &rl_inter;
1752
    if (s->mb_intra && !s->h263_aic) {
1753
        /* DC coef */
1754
        level = block[0];
1755
        /* 255 cannot be represented, so we clamp */
1756
        if (level > 254) {
1757
            level = 254;
1758
            block[0] = 254;
1759
        }
1760
        /* 0 cannot be represented also */
1761
        else if (level < 1) {
1762
            level = 1;
1763
            block[0] = 1;
1764
        }
1765
        if (level == 128) //FIXME check rv10
1766
            put_bits(&s->pb, 8, 0xff);
1767
        else
1768
            put_bits(&s->pb, 8, level & 0xff);
1769
        i = 1;
1770
    } else {
1771
        i = 0;
1772
        if (s->h263_aic && s->mb_intra)
1773
            rl = &rl_intra_aic;
1774
    }
1775
   
1776
    /* AC coefs */
1777
    last_index = s->block_last_index[n];
1778
    last_non_zero = i - 1;
1779
    for (; i <= last_index; i++) {
1780
        j = s->intra_scantable.permutated[i];
1781
        level = block[j];
1782
        if (level) {
1783
            run = i - last_non_zero - 1;
1784
            last = (i == last_index);
1785
            sign = 0;
1786
            slevel = level;
1787
            if (level < 0) {
1788
                sign = 1;
1789
                level = -level;
1790
            }
1791
            code = get_rl_index(rl, last, run, level);
1792
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1793
            if (code == rl->n) {
1794
              if(s->h263_flv <= 1){
1795
                put_bits(&s->pb, 1, last);
1796
                put_bits(&s->pb, 6, run);
1797
                
1798
                assert(slevel != 0);
1799

    
1800
                if(slevel < 128 && slevel > -128) 
1801
                    put_bits(&s->pb, 8, slevel & 0xff);
1802
                else{
1803
                    put_bits(&s->pb, 8, 128);
1804
                    put_bits(&s->pb, 5, slevel & 0x1f);
1805
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
1806
                }
1807
              }else{
1808
                    if(slevel < 64 && slevel > -64) {
1809
                        /* 7-bit level */
1810
                        put_bits(&s->pb, 1, 0);
1811
                        put_bits(&s->pb, 1, last);
1812
                        put_bits(&s->pb, 6, run);
1813

    
1814
                        put_bits(&s->pb, 7, slevel & 0x7f);
1815
                    } else {
1816
                        /* 11-bit level */
1817
                        put_bits(&s->pb, 1, 1);
1818
                        put_bits(&s->pb, 1, last);
1819
                        put_bits(&s->pb, 6, run);
1820

    
1821
                        put_bits(&s->pb, 11, slevel & 0x7ff);
1822
                    }
1823
              }
1824
            } else {
1825
                put_bits(&s->pb, 1, sign);
1826
            }
1827
            last_non_zero = i;
1828
        }
1829
    }
1830
}
1831
#endif
1832

    
1833
#ifdef CONFIG_ENCODERS
1834

    
1835
/***************************************************/
1836
/**
1837
 * add mpeg4 stuffing bits (01...1)
1838
 */
1839
void ff_mpeg4_stuffing(PutBitContext * pbc)
1840
{
1841
    int length;
1842
    put_bits(pbc, 1, 0);
1843
    length= (-get_bit_count(pbc))&7;
1844
    if(length) put_bits(pbc, length, (1<<length)-1);
1845
}
1846

    
1847
/* must be called before writing the header */
1848
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1849
    int time_div, time_mod;
1850

    
1851
    if(s->current_picture_ptr->pts)
1852
        s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1853
    else
1854
        s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
1855
    time_div= s->time/s->time_increment_resolution;
1856
    time_mod= s->time%s->time_increment_resolution;
1857

    
1858
    if(s->pict_type==B_TYPE){
1859
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1860
    }else{
1861
        s->last_time_base= s->time_base;
1862
        s->time_base= time_div;
1863
        s->pp_time= s->time - s->last_non_b_time;
1864
        s->last_non_b_time= s->time;
1865
    }
1866
}
1867

    
1868
static void mpeg4_encode_gop_header(MpegEncContext * s){
1869
    int hours, minutes, seconds;
1870
    
1871
    put_bits(&s->pb, 16, 0);
1872
    put_bits(&s->pb, 16, GOP_STARTCODE);
1873
    
1874
    seconds= s->time/s->time_increment_resolution;
1875
    minutes= seconds/60; seconds %= 60;
1876
    hours= minutes/60; minutes %= 60;
1877
    hours%=24;
1878

    
1879
    put_bits(&s->pb, 5, hours);
1880
    put_bits(&s->pb, 6, minutes);
1881
    put_bits(&s->pb, 1, 1);
1882
    put_bits(&s->pb, 6, seconds);
1883
    
1884
    put_bits(&s->pb, 1, 0); //closed gov == NO
1885
    put_bits(&s->pb, 1, 0); //broken link == NO
1886

    
1887
    ff_mpeg4_stuffing(&s->pb);
1888
}
1889

    
1890
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1891
    int profile_and_level_indication;
1892
    int vo_ver_id;
1893
    
1894
    if(s->max_b_frames || s->quarter_sample){
1895
        profile_and_level_indication= 0xF1; // adv simple level 1
1896
        vo_ver_id= 5;
1897
    }else{
1898
        profile_and_level_indication= 0x01; // simple level 1
1899
        vo_ver_id= 1;
1900
    }
1901
    //FIXME levels
1902

    
1903
    put_bits(&s->pb, 16, 0);
1904
    put_bits(&s->pb, 16, VOS_STARTCODE);
1905

    
1906
    put_bits(&s->pb, 8, profile_and_level_indication);
1907

    
1908
    put_bits(&s->pb, 16, 0);
1909
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1910
    
1911
    put_bits(&s->pb, 1, 1);
1912
        put_bits(&s->pb, 4, vo_ver_id);
1913
        put_bits(&s->pb, 3, 1); //priority
1914
 
1915
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
1916
    
1917
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1918

    
1919
    ff_mpeg4_stuffing(&s->pb);
1920
}
1921

    
1922
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
1923
{
1924
    int vo_ver_id;
1925

    
1926
    if(s->max_b_frames || s->quarter_sample){
1927
        vo_ver_id= 5;
1928
        s->vo_type= ADV_SIMPLE_VO_TYPE;
1929
    }else{
1930
        vo_ver_id= 1;
1931
        s->vo_type= SIMPLE_VO_TYPE;
1932
    }
1933

    
1934
    put_bits(&s->pb, 16, 0);
1935
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
1936
    put_bits(&s->pb, 16, 0);
1937
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
1938

    
1939
    put_bits(&s->pb, 1, 0);                /* random access vol */
1940
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1941
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1942
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1943
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1944
    
1945
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
1946

    
1947
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1948
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
1949
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
1950
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
1951
    }
1952

    
1953
    if(s->low_delay){
1954
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1955
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1956
        put_bits(&s->pb, 1, s->low_delay);
1957
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1958
    }else{
1959
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1960
    }
1961

    
1962
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1963
    put_bits(&s->pb, 1, 1);                /* marker bit */
1964
    
1965
    put_bits(&s->pb, 16, s->time_increment_resolution);
1966
    if (s->time_increment_bits < 1)
1967
        s->time_increment_bits = 1;
1968
    put_bits(&s->pb, 1, 1);                /* marker bit */
1969
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1970
    put_bits(&s->pb, 1, 1);                /* marker bit */
1971
    put_bits(&s->pb, 13, s->width);        /* vol width */
1972
    put_bits(&s->pb, 1, 1);                /* marker bit */
1973
    put_bits(&s->pb, 13, s->height);        /* vol height */
1974
    put_bits(&s->pb, 1, 1);                /* marker bit */
1975
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1976
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1977
    if (vo_ver_id == 1) {
1978
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1979
    }else{
1980
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1981
    }
1982
    
1983
    s->quant_precision=5;
1984
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
1985
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
1986

    
1987
    if(s->mpeg_quant){
1988
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
1989
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
1990
    }
1991

    
1992
    if (vo_ver_id != 1)
1993
        put_bits(&s->pb, 1, s->quarter_sample);
1994
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1995
    s->resync_marker= s->rtp_mode;
1996
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1997
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1998
    if(s->data_partitioning){
1999
        put_bits(&s->pb, 1, 0);                /* no rvlc */
2000
    }
2001

    
2002
    if (vo_ver_id != 1){
2003
        put_bits(&s->pb, 1, 0);                /* newpred */
2004
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
2005
    }
2006
    put_bits(&s->pb, 1, 0);                /* scalability */
2007
    
2008
    ff_mpeg4_stuffing(&s->pb);
2009

    
2010
    /* user data */
2011
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2012
        put_bits(&s->pb, 16, 0);
2013
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
2014
        put_string(&s->pb, LIBAVCODEC_IDENT);
2015
        ff_mpeg4_stuffing(&s->pb);
2016
    }
2017
}
2018

    
2019
/* write mpeg4 VOP header */
2020
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2021
{
2022
    int time_incr;
2023
    int time_div, time_mod;
2024
    
2025
    if(s->pict_type==I_TYPE){
2026
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2027
            if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2028
                mpeg4_encode_visual_object_header(s);
2029
            if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2030
                mpeg4_encode_vol_header(s, 0, 0);
2031
        }
2032
        mpeg4_encode_gop_header(s);
2033
    }
2034
    
2035
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2036

    
2037
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2038
    
2039
    put_bits(&s->pb, 16, 0);                /* vop header */
2040
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2041
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
2042

    
2043
    time_div= s->time/s->time_increment_resolution;
2044
    time_mod= s->time%s->time_increment_resolution;
2045
    time_incr= time_div - s->last_time_base;
2046
    while(time_incr--)
2047
        put_bits(&s->pb, 1, 1);
2048
        
2049
    put_bits(&s->pb, 1, 0);
2050

    
2051
    put_bits(&s->pb, 1, 1);        /* marker */
2052
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
2053
    put_bits(&s->pb, 1, 1);        /* marker */
2054
    put_bits(&s->pb, 1, 1);        /* vop coded */
2055
    if (    s->pict_type == P_TYPE 
2056
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2057
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
2058
    }
2059
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
2060
    if(!s->progressive_sequence){
2061
         put_bits(&s->pb, 1, s->top_field_first);
2062
         put_bits(&s->pb, 1, s->alternate_scan);
2063
    }
2064
    //FIXME sprite stuff
2065

    
2066
    put_bits(&s->pb, 5, s->qscale);
2067

    
2068
    if (s->pict_type != I_TYPE)
2069
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
2070
    if (s->pict_type == B_TYPE)
2071
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
2072
    //    printf("****frame %d\n", picture_number);
2073

    
2074
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
2075
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2076
}
2077

    
2078
#endif //CONFIG_ENCODERS
2079

    
2080
/**
2081
 * change qscale by given dquant and update qscale dependant variables.
2082
 */
2083
static void change_qscale(MpegEncContext * s, int dquant)
2084
{
2085
    s->qscale += dquant;
2086

    
2087
    if (s->qscale < 1)
2088
        s->qscale = 1;
2089
    else if (s->qscale > 31)
2090
        s->qscale = 31;
2091

    
2092
    s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2093
    s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2094
}
2095

    
2096
/**
2097
 * predicts the dc.
2098
 * @param n block index (0-3 are luma, 4-5 are chroma)
2099
 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
2100
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2101
 * @return the quantized predicted dc
2102
 */
2103
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
2104
{
2105
    int a, b, c, wrap, pred, scale;
2106
    uint16_t *dc_val;
2107

    
2108
    /* find prediction */
2109
    if (n < 4) {
2110
        scale = s->y_dc_scale;
2111
    } else {
2112
        scale = s->c_dc_scale;
2113
    }
2114
    if(IS_3IV1)
2115
        scale= 8;
2116

    
2117
    wrap= s->block_wrap[n];
2118
    dc_val = s->dc_val[0] + s->block_index[n];
2119

    
2120
    /* B C
2121
     * A X 
2122
     */
2123
    a = dc_val[ - 1];
2124
    b = dc_val[ - 1 - wrap];
2125
    c = dc_val[ - wrap];
2126

    
2127
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2128
    if(s->first_slice_line && n!=3){
2129
        if(n!=2) b=c= 1024;
2130
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2131
    }
2132
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2133
        if(n==0 || n==4 || n==5)
2134
            b=1024;
2135
    }
2136

    
2137
    if (abs(a - b) < abs(b - c)) {
2138
        pred = c;
2139
        *dir_ptr = 1; /* top */
2140
    } else {
2141
        pred = a;
2142
        *dir_ptr = 0; /* left */
2143
    }
2144
    /* we assume pred is positive */
2145
    pred = FASTDIV((pred + (scale >> 1)), scale);
2146

    
2147
    /* prepare address for prediction update */
2148
    *dc_val_ptr = &dc_val[0];
2149

    
2150
    return pred;
2151
}
2152

    
2153
/**
2154
 * predicts the ac.
2155
 * @param n block index (0-3 are luma, 4-5 are chroma)
2156
 * @param dir the ac prediction direction
2157
 */
2158
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2159
                   int dir)
2160
{
2161
    int i;
2162
    int16_t *ac_val, *ac_val1;
2163
    int8_t * const qscale_table= s->current_picture.qscale_table;
2164

    
2165
    /* find prediction */
2166
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2167
    ac_val1 = ac_val;
2168
    if (s->ac_pred) {
2169
        if (dir == 0) {
2170
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2171
            /* left prediction */
2172
            ac_val -= 16;
2173
            
2174
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2175
                /* same qscale */
2176
                for(i=1;i<8;i++) {
2177
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2178
                }
2179
            }else{
2180
                /* different qscale, we must rescale */
2181
                for(i=1;i<8;i++) {
2182
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2183
                }
2184
            }
2185
        } else {
2186
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2187
            /* top prediction */
2188
            ac_val -= 16 * s->block_wrap[n];
2189

    
2190
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2191
                /* same qscale */
2192
                for(i=1;i<8;i++) {
2193
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2194
                }
2195
            }else{
2196
                /* different qscale, we must rescale */
2197
                for(i=1;i<8;i++) {
2198
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2199
                }
2200
            }
2201
        }
2202
    }
2203
    /* left copy */
2204
    for(i=1;i<8;i++)
2205
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2206

    
2207
    /* top copy */
2208
    for(i=1;i<8;i++)
2209
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2210

    
2211
}
2212

    
2213
#ifdef CONFIG_ENCODERS
2214

    
2215
/**
2216
 * encodes the dc value.
2217
 * @param n block index (0-3 are luma, 4-5 are chroma)
2218
 */
2219
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2220
{
2221
#if 1
2222
//    if(level<-255 || level>255) printf("dc overflow\n");
2223
    level+=256;
2224
    if (n < 4) {
2225
        /* luminance */
2226
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2227
    } else {
2228
        /* chrominance */
2229
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2230
    }
2231
#else
2232
    int size, v;
2233
    /* find number of bits */
2234
    size = 0;
2235
    v = abs(level);
2236
    while (v) {
2237
        v >>= 1;
2238
        size++;
2239
    }
2240

    
2241
    if (n < 4) {
2242
        /* luminance */
2243
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2244
    } else {
2245
        /* chrominance */
2246
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2247
    }
2248

    
2249
    /* encode remaining bits */
2250
    if (size > 0) {
2251
        if (level < 0)
2252
            level = (-level) ^ ((1 << size) - 1);
2253
        put_bits(&s->pb, size, level);
2254
        if (size > 8)
2255
            put_bits(&s->pb, 1, 1);
2256
    }
2257
#endif
2258
}
2259

    
2260
/**
2261
 * encodes a 8x8 block
2262
 * @param n block index (0-3 are luma, 4-5 are chroma)
2263
 */
2264
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2265
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2266
{
2267
    int i, last_non_zero;
2268
#if 0 //variables for the outcommented version
2269
    int code, sign, last;
2270
#endif
2271
    const RLTable *rl;
2272
    uint32_t *bits_tab;
2273
    uint8_t *len_tab;
2274
    const int last_index = s->block_last_index[n];
2275

    
2276
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2277
        /* mpeg4 based DC predictor */
2278
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2279
        if(last_index<1) return;
2280
        i = 1;
2281
        rl = &rl_intra;
2282
        bits_tab= uni_mpeg4_intra_rl_bits;
2283
        len_tab = uni_mpeg4_intra_rl_len;
2284
    } else {
2285
        if(last_index<0) return;
2286
        i = 0;
2287
        rl = &rl_inter;
2288
        bits_tab= uni_mpeg4_inter_rl_bits;
2289
        len_tab = uni_mpeg4_inter_rl_len;
2290
    }
2291

    
2292
    /* AC coefs */
2293
    last_non_zero = i - 1;
2294
#if 1
2295
    for (; i < last_index; i++) {
2296
        int level = block[ scan_table[i] ];
2297
        if (level) {
2298
            int run = i - last_non_zero - 1;
2299
            level+=64;
2300
            if((level&(~127)) == 0){
2301
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2302
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2303
            }else{ //ESC3
2304
                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);
2305
            }
2306
            last_non_zero = i;
2307
        }
2308
    }
2309
    /*if(i<=last_index)*/{
2310
        int level = block[ scan_table[i] ];
2311
        int run = i - last_non_zero - 1;
2312
        level+=64;
2313
        if((level&(~127)) == 0){
2314
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2315
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2316
        }else{ //ESC3
2317
            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);
2318
        }
2319
    }
2320
#else
2321
    for (; i <= last_index; i++) {
2322
        const int slevel = block[ scan_table[i] ];
2323
        if (slevel) {
2324
            int level;
2325
            int run = i - last_non_zero - 1;
2326
            last = (i == last_index);
2327
            sign = 0;
2328
            level = slevel;
2329
            if (level < 0) {
2330
                sign = 1;
2331
                level = -level;
2332
            }
2333
            code = get_rl_index(rl, last, run, level);
2334
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2335
            if (code == rl->n) {
2336
                int level1, run1;
2337
                level1 = level - rl->max_level[last][run];
2338
                if (level1 < 1) 
2339
                    goto esc2;
2340
                code = get_rl_index(rl, last, run, level1);
2341
                if (code == rl->n) {
2342
                esc2:
2343
                    put_bits(ac_pb, 1, 1);
2344
                    if (level > MAX_LEVEL)
2345
                        goto esc3;
2346
                    run1 = run - rl->max_run[last][level] - 1;
2347
                    if (run1 < 0)
2348
                        goto esc3;
2349
                    code = get_rl_index(rl, last, run1, level);
2350
                    if (code == rl->n) {
2351
                    esc3:
2352
                        /* third escape */
2353
                        put_bits(ac_pb, 1, 1);
2354
                        put_bits(ac_pb, 1, last);
2355
                        put_bits(ac_pb, 6, run);
2356
                        put_bits(ac_pb, 1, 1);
2357
                        put_bits(ac_pb, 12, slevel & 0xfff);
2358
                        put_bits(ac_pb, 1, 1);
2359
                    } else {
2360
                        /* second escape */
2361
                        put_bits(ac_pb, 1, 0);
2362
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2363
                        put_bits(ac_pb, 1, sign);
2364
                    }
2365
                } else {
2366
                    /* first escape */
2367
                    put_bits(ac_pb, 1, 0);
2368
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2369
                    put_bits(ac_pb, 1, sign);
2370
                }
2371
            } else {
2372
                put_bits(ac_pb, 1, sign);
2373
            }
2374
            last_non_zero = i;
2375
        }
2376
    }
2377
#endif
2378
}
2379

    
2380
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2381
                               uint8_t *scan_table)
2382
{
2383
    int i, last_non_zero;
2384
    const RLTable *rl;
2385
    uint8_t *len_tab;
2386
    const int last_index = s->block_last_index[n];
2387
    int len=0;
2388

    
2389
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2390
        /* mpeg4 based DC predictor */
2391
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2392
        if(last_index<1) return len;
2393
        i = 1;
2394
        rl = &rl_intra;
2395
        len_tab = uni_mpeg4_intra_rl_len;
2396
    } else {
2397
        if(last_index<0) return 0;
2398
        i = 0;
2399
        rl = &rl_inter;
2400
        len_tab = uni_mpeg4_inter_rl_len;
2401
    }
2402

    
2403
    /* AC coefs */
2404
    last_non_zero = i - 1;
2405
    for (; i < last_index; i++) {
2406
        int level = block[ scan_table[i] ];
2407
        if (level) {
2408
            int run = i - last_non_zero - 1;
2409
            level+=64;
2410
            if((level&(~127)) == 0){
2411
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2412
                len += len_tab[index];
2413
            }else{ //ESC3
2414
                len += 7+2+1+6+1+12+1;
2415
            }
2416
            last_non_zero = i;
2417
        }
2418
    }
2419
    /*if(i<=last_index)*/{
2420
        int level = block[ scan_table[i] ];
2421
        int run = i - last_non_zero - 1;
2422
        level+=64;
2423
        if((level&(~127)) == 0){
2424
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2425
            len += len_tab[index];
2426
        }else{ //ESC3
2427
            len += 7+2+1+6+1+12+1;
2428
        }
2429
    }
2430
    
2431
    return len;
2432
}
2433

    
2434
#endif
2435

    
2436

    
2437
/***********************************************/
2438
/* decoding */
2439

    
2440
static VLC intra_MCBPC_vlc;
2441
static VLC inter_MCBPC_vlc;
2442
static VLC cbpy_vlc;
2443
static VLC mv_vlc;
2444
static VLC dc_lum, dc_chrom;
2445
static VLC sprite_trajectory;
2446
static VLC mb_type_b_vlc;
2447

    
2448
void init_vlc_rl(RLTable *rl)
2449
{
2450
    int i, q;
2451
    
2452
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2453
             &rl->table_vlc[0][1], 4, 2,
2454
             &rl->table_vlc[0][0], 4, 2);
2455

    
2456
    
2457
    for(q=0; q<32; q++){
2458
        int qmul= q*2;
2459
        int qadd= (q-1)|1;
2460
        
2461
        if(q==0){
2462
            qmul=1;
2463
            qadd=0;
2464
        }
2465
        
2466
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2467
        for(i=0; i<rl->vlc.table_size; i++){
2468
            int code= rl->vlc.table[i][0];
2469
            int len = rl->vlc.table[i][1];
2470
            int level, run;
2471
        
2472
            if(len==0){ // illegal code
2473
                run= 66;
2474
                level= MAX_LEVEL;
2475
            }else if(len<0){ //more bits needed
2476
                run= 0;
2477
                level= code;
2478
            }else{
2479
                if(code==rl->n){ //esc
2480
                    run= 66;
2481
                    level= 0;
2482
                }else{
2483
                    run=   rl->table_run  [code] + 1;
2484
                    level= rl->table_level[code] * qmul + qadd;
2485
                    if(code >= rl->last) run+=192;
2486
                }
2487
            }
2488
            rl->rl_vlc[q][i].len= len;
2489
            rl->rl_vlc[q][i].level= level;
2490
            rl->rl_vlc[q][i].run= run;
2491
        }
2492
    }
2493
}
2494

    
2495
/* init vlcs */
2496

    
2497
/* XXX: find a better solution to handle static init */
2498
void h263_decode_init_vlc(MpegEncContext *s)
2499
{
2500
    static int done = 0;
2501

    
2502
    if (!done) {
2503
        done = 1;
2504

    
2505
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, 
2506
                 intra_MCBPC_bits, 1, 1,
2507
                 intra_MCBPC_code, 1, 1);
2508
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, 
2509
                 inter_MCBPC_bits, 1, 1,
2510
                 inter_MCBPC_code, 1, 1);
2511
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2512
                 &cbpy_tab[0][1], 2, 1,
2513
                 &cbpy_tab[0][0], 2, 1);
2514
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2515
                 &mvtab[0][1], 2, 1,
2516
                 &mvtab[0][0], 2, 1);
2517
        init_rl(&rl_inter);
2518
        init_rl(&rl_intra);
2519
        init_rl(&rvlc_rl_inter);
2520
        init_rl(&rvlc_rl_intra);
2521
        init_rl(&rl_intra_aic);
2522
        init_vlc_rl(&rl_inter);
2523
        init_vlc_rl(&rl_intra);
2524
        init_vlc_rl(&rvlc_rl_inter);
2525
        init_vlc_rl(&rvlc_rl_intra);
2526
        init_vlc_rl(&rl_intra_aic);
2527
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2528
                 &DCtab_lum[0][1], 2, 1,
2529
                 &DCtab_lum[0][0], 2, 1);
2530
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2531
                 &DCtab_chrom[0][1], 2, 1,
2532
                 &DCtab_chrom[0][0], 2, 1);
2533
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2534
                 &sprite_trajectory_tab[0][1], 4, 2,
2535
                 &sprite_trajectory_tab[0][0], 4, 2);
2536
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2537
                 &mb_type_b_tab[0][1], 2, 1,
2538
                 &mb_type_b_tab[0][0], 2, 1);
2539
    }
2540
}
2541

    
2542
/**
2543
 * Get the GOB height based on picture height.
2544
 */
2545
int ff_h263_get_gob_height(MpegEncContext *s){
2546
    if (s->height <= 400)
2547
        return 1;
2548
    else if (s->height <= 800)
2549
        return  2;
2550
    else
2551
        return 4;
2552
}
2553

    
2554
/**
2555
 * decodes the group of blocks header.
2556
 * @return <0 if an error occured
2557
 */
2558
static int h263_decode_gob_header(MpegEncContext *s)
2559
{
2560
    unsigned int val, gfid;
2561
    int left;
2562
    
2563
    /* Check for GOB Start Code */
2564
    val = show_bits(&s->gb, 16);
2565
    if(val)
2566
        return -1;
2567

    
2568
        /* We have a GBSC probably with GSTUFF */
2569
    skip_bits(&s->gb, 16); /* Drop the zeros */
2570
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2571
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2572
    for(;left>13; left--){
2573
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2574
    }
2575
    if(left<=13) 
2576
        return -1;
2577

    
2578
#ifdef DEBUG
2579
    fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2580
#endif
2581
    s->gob_number = get_bits(&s->gb, 5); /* GN */
2582
    gfid = get_bits(&s->gb, 2); /* GFID */
2583
    s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2584
    if(s->qscale==0) 
2585
        return -1;
2586
    s->mb_x= 0;
2587
    s->mb_y= s->gob_index* s->gob_number;
2588
    if(s->mb_y >= s->mb_height) 
2589
        return -1;
2590
#ifdef DEBUG
2591
    fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2592
#endif
2593
    return 0;
2594
}
2595

    
2596
static inline void memsetw(short *tab, int val, int n)
2597
{
2598
    int i;
2599
    for(i=0;i<n;i++)
2600
        tab[i] = val;
2601
}
2602

    
2603
#ifdef CONFIG_ENCODERS
2604

    
2605
void ff_mpeg4_init_partitions(MpegEncContext *s)
2606
{
2607
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE);
2608
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE);
2609
}
2610

    
2611
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2612
{
2613
    const int pb2_len   = get_bit_count(&s->pb2   );
2614
    const int tex_pb_len= get_bit_count(&s->tex_pb);
2615
    const int bits= get_bit_count(&s->pb);
2616

    
2617
    if(s->pict_type==I_TYPE){
2618
        put_bits(&s->pb, 19, DC_MARKER);
2619
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2620
        s->i_tex_bits+= tex_pb_len;
2621
    }else{
2622
        put_bits(&s->pb, 17, MOTION_MARKER);
2623
        s->misc_bits+=17 + pb2_len;
2624
        s->mv_bits+= bits - s->last_bits;
2625
        s->p_tex_bits+= tex_pb_len;
2626
    }
2627

    
2628
    flush_put_bits(&s->pb2);
2629
    flush_put_bits(&s->tex_pb);
2630

    
2631
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2632
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2633
    s->last_bits= get_bit_count(&s->pb);
2634
}
2635

    
2636
#endif //CONFIG_ENCODERS
2637

    
2638
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2639
    switch(s->pict_type){
2640
        case I_TYPE:
2641
            return 16;
2642
        case P_TYPE:
2643
        case S_TYPE:
2644
            return s->f_code+15;
2645
        case B_TYPE:
2646
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2647
        default:
2648
            return -1;
2649
    }
2650
}
2651

    
2652
#ifdef CONFIG_ENCODERS
2653

    
2654
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2655
{
2656
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2657

    
2658
    ff_mpeg4_stuffing(&s->pb);
2659
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2660
    put_bits(&s->pb, 1, 1);
2661
    
2662
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2663
    put_bits(&s->pb, s->quant_precision, s->qscale);
2664
    put_bits(&s->pb, 1, 0); /* no HEC */
2665
}
2666

    
2667
#endif //CONFIG_ENCODERS
2668

    
2669
/**
2670
 * check if the next stuff is a resync marker or the end.
2671
 * @return 0 if not
2672
 */
2673
static inline int mpeg4_is_resync(MpegEncContext *s){
2674
    const int bits_count= get_bits_count(&s->gb);
2675
    
2676
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
2677
        return 0;
2678
    }
2679

    
2680
    if(bits_count + 8 >= s->gb.size_in_bits){
2681
        int v= show_bits(&s->gb, 8);
2682
        v|= 0x7F >> (7-(bits_count&7));
2683
                
2684
        if(v==0x7F)
2685
            return 1;
2686
    }else{
2687
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2688
            int len;
2689
            GetBitContext gb= s->gb;
2690
        
2691
            skip_bits(&s->gb, 1);
2692
            align_get_bits(&s->gb);
2693
        
2694
            for(len=0; len<32; len++){
2695
                if(get_bits1(&s->gb)) break;
2696
            }
2697

    
2698
            s->gb= gb;
2699

    
2700
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2701
                return 1;
2702
        }
2703
    }
2704
    return 0;
2705
}
2706

    
2707
/**
2708
 * decodes the next video packet.
2709
 * @return <0 if something went wrong
2710
 */
2711
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2712
{
2713
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2714
    int header_extension=0, mb_num, len;
2715
    
2716
    /* is there enough space left for a video packet + header */
2717
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
2718

    
2719
    for(len=0; len<32; len++){
2720
        if(get_bits1(&s->gb)) break;
2721
    }
2722

    
2723
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2724
        printf("marker does not match f_code\n");
2725
        return -1;
2726
    }
2727
    
2728
    if(s->shape != RECT_SHAPE){
2729
        header_extension= get_bits1(&s->gb);
2730
        //FIXME more stuff here
2731
    }
2732

    
2733
    mb_num= get_bits(&s->gb, mb_num_bits);
2734
    if(mb_num>=s->mb_num){
2735
        fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2736
        return -1;
2737
    }
2738
    if(s->pict_type == B_TYPE){
2739
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
2740
        if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
2741
    }
2742
    
2743
    s->mb_x= mb_num % s->mb_width;
2744
    s->mb_y= mb_num / s->mb_width;
2745

    
2746
    if(s->shape != BIN_ONLY_SHAPE){
2747
        int qscale= get_bits(&s->gb, s->quant_precision); 
2748
        if(qscale)
2749
            s->qscale= qscale;
2750
    }
2751

    
2752
    if(s->shape == RECT_SHAPE){
2753
        header_extension= get_bits1(&s->gb);
2754
    }
2755
    if(header_extension){
2756
        int time_increment;
2757
        int time_incr=0;
2758

    
2759
        while (get_bits1(&s->gb) != 0) 
2760
            time_incr++;
2761

    
2762
        check_marker(&s->gb, "before time_increment in video packed header");
2763
        time_increment= get_bits(&s->gb, s->time_increment_bits);
2764
        check_marker(&s->gb, "before vop_coding_type in video packed header");
2765
        
2766
        skip_bits(&s->gb, 2); /* vop coding type */
2767
        //FIXME not rect stuff here
2768

    
2769
        if(s->shape != BIN_ONLY_SHAPE){
2770
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2771
//FIXME dont just ignore everything
2772
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2773
                mpeg4_decode_sprite_trajectory(s);
2774
                fprintf(stderr, "untested\n");
2775
            }
2776

    
2777
            //FIXME reduced res stuff here
2778
            
2779
            if (s->pict_type != I_TYPE) {
2780
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
2781
                if(f_code==0){
2782
                    printf("Error, video packet header damaged (f_code=0)\n");
2783
                }
2784
            }
2785
            if (s->pict_type == B_TYPE) {
2786
                int b_code = get_bits(&s->gb, 3);
2787
                if(b_code==0){
2788
                    printf("Error, video packet header damaged (b_code=0)\n");
2789
                }
2790
            }       
2791
        }
2792
    }
2793
    //FIXME new-pred stuff
2794
    
2795
//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));
2796

    
2797
    return 0;
2798
}
2799

    
2800
void ff_mpeg4_clean_buffers(MpegEncContext *s)
2801
{
2802
    int c_wrap, c_xy, l_wrap, l_xy;
2803

    
2804
    l_wrap= s->block_wrap[0];
2805
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2806
    c_wrap= s->block_wrap[4];
2807
    c_xy= s->mb_y*c_wrap + s->mb_x;
2808

    
2809
#if 0
2810
    /* clean DC */
2811
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2812
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2813
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2814
#endif
2815

    
2816
    /* clean AC */
2817
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
2818
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2819
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2820

    
2821
    /* clean MV */
2822
    // we cant clear the MVs as they might be needed by a b frame
2823
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
2824
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2825
    s->last_mv[0][0][0]=
2826
    s->last_mv[0][0][1]=
2827
    s->last_mv[1][0][0]=
2828
    s->last_mv[1][0][1]= 0;
2829
}
2830

    
2831
/**
2832
 * decodes the group of blocks / video packet header.
2833
 * @return <0 if no resync found
2834
 */
2835
int ff_h263_resync(MpegEncContext *s){
2836
    int left, ret;
2837
    
2838
    if(s->codec_id==CODEC_ID_MPEG4){
2839
        skip_bits1(&s->gb);
2840
        align_get_bits(&s->gb);
2841
    }
2842

    
2843
    if(show_bits(&s->gb, 16)==0){
2844
        if(s->codec_id==CODEC_ID_MPEG4)
2845
            ret= mpeg4_decode_video_packet_header(s);
2846
        else
2847
            ret= h263_decode_gob_header(s);
2848
        if(ret>=0)
2849
            return 0;
2850
    }
2851
    //ok, its not where its supposed to be ...
2852
    s->gb= s->last_resync_gb;
2853
    align_get_bits(&s->gb);
2854
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2855
    
2856
    for(;left>16+1+5+5; left-=8){ 
2857
        if(show_bits(&s->gb, 16)==0){
2858
            GetBitContext bak= s->gb;
2859

    
2860
            if(s->codec_id==CODEC_ID_MPEG4)
2861
                ret= mpeg4_decode_video_packet_header(s);
2862
            else
2863
                ret= h263_decode_gob_header(s);
2864
            if(ret>=0)
2865
                return 0;
2866

    
2867
            s->gb= bak;
2868
        }
2869
        skip_bits(&s->gb, 8);
2870
    }
2871
    
2872
    return -1;
2873
}
2874

    
2875
/**
2876
 * gets the average motion vector for a GMC MB.
2877
 * @param n either 0 for the x component or 1 for y
2878
 * @returns the average MV for a GMC MB
2879
 */
2880
static inline int get_amv(MpegEncContext *s, int n){
2881
    int x, y, mb_v, sum, dx, dy, shift;
2882
    int len = 1 << (s->f_code + 4);
2883
    const int a= s->sprite_warping_accuracy;
2884

    
2885
    if(s->real_sprite_warping_points==1){
2886
        if(s->divx_version==500 && s->divx_build==413)
2887
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2888
        else
2889
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2890
    }else{
2891
        dx= s->sprite_delta[n][0];
2892
        dy= s->sprite_delta[n][1];
2893
        shift= s->sprite_shift[0];
2894
        if(n) dy -= 1<<(shift + a + 1);
2895
        else  dx -= 1<<(shift + a + 1);
2896
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2897

    
2898
        sum=0;
2899
        for(y=0; y<16; y++){
2900
            int v;
2901
        
2902
            v= mb_v + dy*y;
2903
            //XXX FIXME optimize
2904
            for(x=0; x<16; x++){
2905
                sum+= v>>shift;
2906
                v+= dx;
2907
            }
2908
        }
2909
        sum= RSHIFT(sum, a+8-s->quarter_sample);
2910
    }
2911

    
2912
    if      (sum < -len) sum= -len;
2913
    else if (sum >= len) sum= len-1;
2914

    
2915
    return sum;
2916
}
2917

    
2918
/**
2919
 * decodes first partition.
2920
 * @return number of MBs decoded or <0 if an error occured
2921
 */
2922
static int mpeg4_decode_partition_a(MpegEncContext *s){
2923
    int mb_num;
2924
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2925
    
2926
    /* decode first partition */
2927
    mb_num=0;
2928
    s->first_slice_line=1;
2929
    for(; s->mb_y<s->mb_height; s->mb_y++){
2930
        ff_init_block_index(s);
2931
        for(; s->mb_x<s->mb_width; s->mb_x++){
2932
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
2933
            int cbpc;
2934
            int dir=0;
2935
            
2936
            mb_num++;
2937
            ff_update_block_index(s);
2938
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2939
                s->first_slice_line=0;
2940
            
2941
            if(s->pict_type==I_TYPE){
2942
                int i;
2943

    
2944
                if(show_bits_long(&s->gb, 19)==DC_MARKER){
2945
                    return mb_num-1;
2946
                }
2947

    
2948
                do{
2949
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
2950
                    if (cbpc < 0){
2951
                        fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2952
                        return -1;
2953
                    }
2954
                }while(cbpc == 8);
2955

    
2956
                s->cbp_table[xy]= cbpc & 3;
2957
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
2958
                s->mb_intra = 1;
2959

    
2960
                if(cbpc & 4) {
2961
                    change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2962
                }
2963
                s->current_picture.qscale_table[xy]= s->qscale;
2964

    
2965
                s->mbintra_table[xy]= 1;
2966
                for(i=0; i<6; i++){
2967
                    int dc_pred_dir;
2968
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2969
                    if(dc < 0){
2970
                        fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2971
                        return -1;
2972
                    }
2973
                    dir<<=1;
2974
                    if(dc_pred_dir) dir|=1;
2975
                }
2976
                s->pred_dir_table[xy]= dir;
2977
            }else{ /* P/S_TYPE */
2978
                int mx, my, pred_x, pred_y, bits;
2979
                int16_t * const mot_val= s->motion_val[s->block_index[0]];
2980
                const int stride= s->block_wrap[0]*2;
2981

    
2982
//              do{ //FIXME
2983
                bits= show_bits(&s->gb, 17);
2984
                if(bits==MOTION_MARKER){
2985
                    return mb_num-1;
2986
                }
2987
                skip_bits1(&s->gb);
2988
                if(bits&0x10000){
2989
                    /* skip mb */
2990
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2991
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
2992
                        mx= get_amv(s, 0);
2993
                        my= get_amv(s, 1);
2994
                    }else{
2995
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
2996
                        mx=my=0;
2997
                    }
2998
                    mot_val[0       ]= mot_val[2       ]=
2999
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3000
                    mot_val[1       ]= mot_val[3       ]=
3001
                    mot_val[1+stride]= mot_val[3+stride]= my;
3002

    
3003
                    if(s->mbintra_table[xy])
3004
                        ff_clean_intra_table_entries(s);
3005
                    continue;
3006
                }
3007

    
3008
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3009
                if (cbpc < 0){
3010
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3011
                    return -1;
3012
                }
3013
//              }while(cbpc == 20);
3014

    
3015
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3016
    
3017
                s->mb_intra = ((cbpc & 4) != 0);
3018
        
3019
                if(s->mb_intra){
3020
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3021
                    s->mbintra_table[xy]= 1;
3022
                    mot_val[0       ]= mot_val[2       ]= 
3023
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3024
                    mot_val[1       ]= mot_val[3       ]=
3025
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3026
                }else{
3027
                    if(s->mbintra_table[xy])
3028
                        ff_clean_intra_table_entries(s);
3029

    
3030
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3031
                        s->mcsel= get_bits1(&s->gb);
3032
                    else s->mcsel= 0;
3033
        
3034
                    if ((cbpc & 16) == 0) {
3035
                        /* 16x16 motion prediction */
3036

    
3037
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
3038
                        if(!s->mcsel){
3039
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3040
                            if (mx >= 0xffff)
3041
                                return -1;
3042

    
3043
                            my = h263_decode_motion(s, pred_y, s->f_code);
3044
                            if (my >= 0xffff)
3045
                                return -1;
3046
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3047
                        } else {
3048
                            mx = get_amv(s, 0);
3049
                            my = get_amv(s, 1);
3050
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3051
                        }
3052

    
3053
                        mot_val[0       ]= mot_val[2       ] =
3054
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3055
                        mot_val[1       ]= mot_val[3       ]=
3056
                        mot_val[1+stride]= mot_val[3+stride]= my;
3057
                    } else {
3058
                        int i;
3059
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3060
                        for(i=0;i<4;i++) {
3061
                            int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
3062
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3063
                            if (mx >= 0xffff)
3064
                                return -1;
3065
                
3066
                            my = h263_decode_motion(s, pred_y, s->f_code);
3067
                            if (my >= 0xffff)
3068
                                return -1;
3069
                            mot_val[0] = mx;
3070
                            mot_val[1] = my;
3071
                        }
3072
                    }
3073
                }
3074
            }
3075
        }
3076
        s->mb_x= 0;
3077
    }
3078

    
3079
    return mb_num;
3080
}
3081

    
3082
/**
3083
 * decode second partition.
3084
 * @return <0 if an error occured
3085
 */
3086
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3087
    int mb_num=0;
3088
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3089

    
3090
    s->mb_x= s->resync_mb_x;
3091
    s->first_slice_line=1;
3092
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3093
        ff_init_block_index(s);
3094
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3095
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3096

    
3097
            mb_num++;
3098
            ff_update_block_index(s);
3099
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3100
                s->first_slice_line=0;
3101
            
3102
            if(s->pict_type==I_TYPE){
3103
                int ac_pred= get_bits1(&s->gb);
3104
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3105
                if(cbpy<0){
3106
                    fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3107
                    return -1;
3108
                }
3109
                
3110
                s->cbp_table[xy]|= cbpy<<2;
3111
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3112
            }else{ /* P || S_TYPE */
3113
                if(IS_INTRA(s->current_picture.mb_type[xy])){          
3114
                    int dir=0,i;
3115
                    int ac_pred = get_bits1(&s->gb);
3116
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3117

    
3118
                    if(cbpy<0){
3119
                        fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3120
                        return -1;
3121
                    }
3122
                    
3123
                    if(s->cbp_table[xy] & 8) {
3124
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3125
                    }
3126
                    s->current_picture.qscale_table[xy]= s->qscale;
3127

    
3128
                    for(i=0; i<6; i++){
3129
                        int dc_pred_dir;
3130
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3131
                        if(dc < 0){
3132
                            fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3133
                            return -1;
3134
                        }
3135
                        dir<<=1;
3136
                        if(dc_pred_dir) dir|=1;
3137
                    }
3138
                    s->cbp_table[xy]&= 3; //remove dquant
3139
                    s->cbp_table[xy]|= cbpy<<2;
3140
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3141
                    s->pred_dir_table[xy]= dir;
3142
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3143
                    s->current_picture.qscale_table[xy]= s->qscale;
3144
                    s->cbp_table[xy]= 0;
3145
                }else{
3146
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3147

    
3148
                    if(cbpy<0){
3149
                        fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3150
                        return -1;
3151
                    }
3152
                    
3153
                    if(s->cbp_table[xy] & 8) {
3154
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3155
                    }
3156
                    s->current_picture.qscale_table[xy]= s->qscale;
3157

    
3158
                    s->cbp_table[xy]&= 3; //remove dquant
3159
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3160
                }
3161
            }
3162
        }
3163
        if(mb_num >= mb_count) return 0;
3164
        s->mb_x= 0;
3165
    }
3166
    return 0;
3167
}
3168

    
3169
/**
3170
 * decodes the first & second partition
3171
 * @return <0 if error (and sets error type in the error_status_table)
3172
 */
3173
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3174
{
3175
    int mb_num;
3176
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3177
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3178
    
3179
    mb_num= mpeg4_decode_partition_a(s);    
3180
    if(mb_num<0){
3181
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3182
        return -1;
3183
    }
3184
    
3185
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3186
        fprintf(stderr, "slice below monitor ...\n");
3187
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3188
        return -1;
3189
    }
3190

    
3191
    s->mb_num_left= mb_num;
3192
        
3193
    if(s->pict_type==I_TYPE){
3194
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3195
            fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3196
            return -1;
3197
        }
3198
    }else{
3199
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3200
            fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3201
            return -1;
3202
        }
3203
    }
3204
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3205
    
3206
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3207
        if(s->pict_type==P_TYPE)
3208
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3209
        return -1;
3210
    }else{
3211
        if(s->pict_type==P_TYPE)
3212
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3213
    }
3214

    
3215
    return 0;        
3216
}
3217

    
3218
/**
3219
 * decode partition C of one MB.
3220
 * @return <0 if an error occured
3221
 */
3222
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3223
{
3224
    int cbp, mb_type;
3225
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3226

    
3227
    mb_type= s->current_picture.mb_type[xy];
3228
    cbp = s->cbp_table[xy];
3229

    
3230
    if(s->current_picture.qscale_table[xy] != s->qscale){
3231
        s->qscale= s->current_picture.qscale_table[xy];
3232
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3233
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3234
    }
3235
    
3236
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3237
        int i;
3238
        for(i=0; i<4; i++){
3239
            s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
3240
            s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
3241
        }
3242
        s->mb_intra = IS_INTRA(mb_type);
3243

    
3244
        if (IS_SKIP(mb_type)) {
3245
            /* skip mb */
3246
            for(i=0;i<6;i++)
3247
                s->block_last_index[i] = -1;
3248
            s->mv_dir = MV_DIR_FORWARD;
3249
            s->mv_type = MV_TYPE_16X16;
3250
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3251
                s->mcsel=1;
3252
                s->mb_skiped = 0;
3253
            }else{
3254
                s->mcsel=0;
3255
                s->mb_skiped = 1;
3256
            }
3257
        }else if(s->mb_intra){
3258
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3259
        }else if(!s->mb_intra){
3260
//            s->mcsel= 0; //FIXME do we need to init that
3261
            
3262
            s->mv_dir = MV_DIR_FORWARD;
3263
            if (IS_8X8(mb_type)) {
3264
                s->mv_type = MV_TYPE_8X8;
3265
            } else {
3266
                s->mv_type = MV_TYPE_16X16;
3267
            }
3268
        }
3269
    } else { /* I-Frame */
3270
        s->mb_intra = 1;
3271
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3272
    }
3273

    
3274
    if (!IS_SKIP(mb_type)) {
3275
        int i;
3276
        /* decode each block */
3277
        for (i = 0; i < 6; i++) {
3278
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3279
                fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3280
                return -1;
3281
            }
3282
            cbp+=cbp;
3283
        }
3284
    }
3285

    
3286
    /* per-MB end of slice check */
3287

    
3288
    if(--s->mb_num_left <= 0){
3289
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3290
        if(mpeg4_is_resync(s))
3291
            return SLICE_END;
3292
        else
3293
            return SLICE_NOEND;     
3294
    }else{
3295
        if(mpeg4_is_resync(s)){
3296
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3297
            if(s->cbp_table[xy+delta])
3298
                return SLICE_END;
3299
        }
3300
        return SLICE_OK;
3301
    }
3302
}
3303

    
3304
int ff_h263_decode_mb(MpegEncContext *s,
3305
                      DCTELEM block[6][64])
3306
{
3307
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3308
    int16_t *mot_val;
3309
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
3310
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3311
    
3312
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3313
      do{
3314
        if (get_bits1(&s->gb)) {
3315
            /* skip mb */
3316
            s->mb_intra = 0;
3317
            for(i=0;i<6;i++)
3318
                s->block_last_index[i] = -1;
3319
            s->mv_dir = MV_DIR_FORWARD;
3320
            s->mv_type = MV_TYPE_16X16;
3321
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3322
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3323
                s->mcsel=1;
3324
                s->mv[0][0][0]= get_amv(s, 0);
3325
                s->mv[0][0][1]= get_amv(s, 1);
3326

    
3327
                s->mb_skiped = 0;
3328
            }else{
3329
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3330
                s->mcsel=0;
3331
                s->mv[0][0][0] = 0;
3332
                s->mv[0][0][1] = 0;
3333
                s->mb_skiped = 1;
3334
            }
3335
            goto end;
3336
        }
3337
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3338
        //fprintf(stderr, "\tCBPC: %d", cbpc);
3339
        if (cbpc < 0){
3340
            fprintf(stderr, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3341
            return -1;
3342
        }
3343
      }while(cbpc == 20);
3344
        
3345
        dquant = cbpc & 8;
3346
        s->mb_intra = ((cbpc & 4) != 0);
3347
        if (s->mb_intra) goto intra;
3348
        
3349
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3350
            s->mcsel= get_bits1(&s->gb);
3351
        else s->mcsel= 0;
3352
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3353
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
3354
        if (dquant) {
3355
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3356
        }
3357
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
3358
            s->interlaced_dct= get_bits1(&s->gb);
3359
        
3360
        s->mv_dir = MV_DIR_FORWARD;
3361
        if ((cbpc & 16) == 0) {
3362
            if(s->mcsel){
3363
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3364
                /* 16x16 global motion prediction */
3365
                s->mv_type = MV_TYPE_16X16;
3366
                mx= get_amv(s, 0);
3367
                my= get_amv(s, 1);
3368
                s->mv[0][0][0] = mx;
3369
                s->mv[0][0][1] = my;
3370
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
3371
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; 
3372
                /* 16x8 field motion prediction */
3373
                s->mv_type= MV_TYPE_FIELD;
3374

    
3375
                s->field_select[0][0]= get_bits1(&s->gb);
3376
                s->field_select[0][1]= get_bits1(&s->gb);
3377

    
3378
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3379
                
3380
                for(i=0; i<2; i++){
3381
                    mx = h263_decode_motion(s, pred_x, s->f_code);
3382
                    if (mx >= 0xffff)
3383
                        return -1;
3384
            
3385
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
3386
                    if (my >= 0xffff)
3387
                        return -1;
3388

    
3389
                    s->mv[0][i][0] = mx;
3390
                    s->mv[0][i][1] = my;
3391
                }
3392
            }else{
3393
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
3394
                /* 16x16 motion prediction */
3395
                s->mv_type = MV_TYPE_16X16;
3396
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3397
                if (s->umvplus)
3398
                   mx = h263p_decode_umotion(s, pred_x);
3399
                else
3400
                   mx = h263_decode_motion(s, pred_x, s->f_code);
3401
            
3402
                if (mx >= 0xffff)
3403
                    return -1;
3404
            
3405
                if (s->umvplus)
3406
                   my = h263p_decode_umotion(s, pred_y);
3407
                else
3408
                   my = h263_decode_motion(s, pred_y, s->f_code);
3409
            
3410
                if (my >= 0xffff)
3411
                    return -1;
3412
                s->mv[0][0][0] = mx;
3413
                s->mv[0][0][1] = my;
3414

    
3415
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3416
                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3417
            }
3418
        } else {
3419
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3420
            s->mv_type = MV_TYPE_8X8;
3421
            for(i=0;i<4;i++) {
3422
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3423
                if (s->umvplus)
3424
                  mx = h263p_decode_umotion(s, pred_x);
3425
                else
3426
                  mx = h263_decode_motion(s, pred_x, s->f_code);
3427
                if (mx >= 0xffff)
3428
                    return -1;
3429
                
3430
                if (s->umvplus)
3431
                  my = h263p_decode_umotion(s, pred_y);
3432
                else    
3433
                  my = h263_decode_motion(s, pred_y, s->f_code);
3434
                if (my >= 0xffff)
3435
                    return -1;
3436
                s->mv[0][i][0] = mx;
3437
                s->mv[0][i][1] = my;
3438
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3439
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3440
                mot_val[0] = mx;
3441
                mot_val[1] = my;
3442
            }
3443
        }
3444
    } else if(s->pict_type==B_TYPE) {
3445
        int modb1; // first bit of modb
3446
        int modb2; // second bit of modb
3447
        int mb_type;
3448

    
3449
        s->mb_intra = 0; //B-frames never contain intra blocks
3450
        s->mcsel=0;      //     ...               true gmc blocks
3451

    
3452
        if(s->mb_x==0){
3453
            for(i=0; i<2; i++){
3454
                s->last_mv[i][0][0]= 
3455
                s->last_mv[i][0][1]= 
3456
                s->last_mv[i][1][0]= 
3457
                s->last_mv[i][1][1]= 0;
3458
            }
3459
        }
3460

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

    
3464
        if(s->mb_skiped){
3465
                /* skip mb */
3466
            for(i=0;i<6;i++)
3467
                s->block_last_index[i] = -1;
3468

    
3469
            s->mv_dir = MV_DIR_FORWARD;
3470
            s->mv_type = MV_TYPE_16X16;
3471
            s->mv[0][0][0] = 0;
3472
            s->mv[0][0][1] = 0;
3473
            s->mv[1][0][0] = 0;
3474
            s->mv[1][0][1] = 0;
3475
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 
3476
            goto end;
3477
        }
3478

    
3479
        modb1= get_bits1(&s->gb); 
3480
        if(modb1){
3481
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
3482
            cbp=0;
3483
        }else{
3484
            modb2= get_bits1(&s->gb);
3485
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3486
            if(mb_type<0){
3487
                printf("illegal MB_type\n");
3488
                return -1;
3489
            }
3490
            mb_type= mb_type_b_map[ mb_type ];
3491
            if(modb2) cbp= 0;
3492
            else      cbp= get_bits(&s->gb, 6);
3493

    
3494
            if ((!IS_DIRECT(mb_type)) && cbp) {
3495
                if(get_bits1(&s->gb)){
3496
                    change_qscale(s, get_bits1(&s->gb)*4 - 2);
3497
                }
3498
            }
3499

    
3500
            if(!s->progressive_sequence){
3501
                if(cbp)
3502
                    s->interlaced_dct= get_bits1(&s->gb);
3503

    
3504
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
3505
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
3506
                    mb_type &= ~MB_TYPE_16x16;
3507

    
3508
                    if(USES_LIST(mb_type, 0)){
3509
                        s->field_select[0][0]= get_bits1(&s->gb);
3510
                        s->field_select[0][1]= get_bits1(&s->gb);
3511
                    }
3512
                    if(USES_LIST(mb_type, 1)){
3513
                        s->field_select[1][0]= get_bits1(&s->gb);
3514
                        s->field_select[1][1]= get_bits1(&s->gb);
3515
                    }
3516
                }
3517
            }
3518

    
3519
            s->mv_dir = 0;
3520
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
3521
                s->mv_type= MV_TYPE_16X16;
3522

    
3523
                if(USES_LIST(mb_type, 0)){
3524
                    s->mv_dir = MV_DIR_FORWARD;
3525

    
3526
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3527
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3528
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3529
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3530
                }
3531
    
3532
                if(USES_LIST(mb_type, 1)){
3533
                    s->mv_dir |= MV_DIR_BACKWARD;
3534

    
3535
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3536
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3537
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3538
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3539
                }
3540
            }else if(!IS_DIRECT(mb_type)){
3541
                s->mv_type= MV_TYPE_FIELD;
3542

    
3543
                if(USES_LIST(mb_type, 0)){
3544
                    s->mv_dir = MV_DIR_FORWARD;
3545
                
3546
                    for(i=0; i<2; i++){
3547
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3548
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3549
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3550
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3551
                    }
3552
                }
3553
    
3554
                if(USES_LIST(mb_type, 1)){
3555
                    s->mv_dir |= MV_DIR_BACKWARD;
3556

    
3557
                    for(i=0; i<2; i++){
3558
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
3559
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3560
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
3561
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3562
                    }
3563
                }
3564
            }
3565
        }
3566
          
3567
        if(IS_DIRECT(mb_type)){
3568
            if(IS_SKIP(mb_type))
3569
                mx=my=0;
3570
            else{
3571
                mx = h263_decode_motion(s, 0, 1);
3572
                my = h263_decode_motion(s, 0, 1);
3573
            }
3574
 
3575
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3576
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
3577
        }
3578
        s->current_picture.mb_type[xy]= mb_type;
3579
    } else { /* I-Frame */
3580
        do{
3581
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3582
            if (cbpc < 0){
3583
                fprintf(stderr, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3584
                return -1;
3585
            }
3586
        }while(cbpc == 8);
3587

    
3588
        dquant = cbpc & 4;
3589
        s->mb_intra = 1;
3590
intra:
3591
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3592
        if (s->h263_pred || s->h263_aic) {
3593
            s->ac_pred = get_bits1(&s->gb);
3594
            if(s->ac_pred){
3595
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3596
            
3597
                if (s->h263_aic)
3598
                    s->h263_aic_dir = get_bits1(&s->gb);
3599
            }
3600
        }else
3601
            s->ac_pred = 0;
3602
        
3603
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3604
        if(cbpy<0){
3605
            fprintf(stderr, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3606
            return -1;
3607
        }
3608
        cbp = (cbpc & 3) | (cbpy << 2);
3609
        if (dquant) {
3610
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3611
        }
3612
        
3613
        if(!s->progressive_sequence)
3614
            s->interlaced_dct= get_bits1(&s->gb);
3615

    
3616
        /* decode each block */
3617
        if (s->h263_pred) {
3618
            for (i = 0; i < 6; i++) {
3619
                if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
3620
                    return -1;
3621
                cbp+=cbp;
3622
            }
3623
        } else {
3624
            for (i = 0; i < 6; i++) {
3625
                if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3626
                    return -1;
3627
                cbp+=cbp;
3628
            }
3629
        }
3630
        goto end;
3631
    }
3632

    
3633
    /* decode each block */
3634
    if (s->h263_pred) {
3635
        for (i = 0; i < 6; i++) {
3636
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
3637
                return -1;
3638
            cbp+=cbp;
3639
        }
3640
    } else {
3641
        for (i = 0; i < 6; i++) {
3642
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3643
                return -1;
3644
            cbp+=cbp;
3645
        }
3646
    }
3647
end:
3648

    
3649
        /* per-MB end of slice check */
3650
    if(s->codec_id==CODEC_ID_MPEG4){
3651
        if(mpeg4_is_resync(s)){
3652
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3653
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
3654
                return SLICE_OK;
3655
            return SLICE_END;
3656
        }
3657
    }else{
3658
        int v= show_bits(&s->gb, 16);
3659
    
3660
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3661
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3662
        }
3663

    
3664
        if(v==0)
3665
            return SLICE_END;
3666
    }
3667

    
3668
    return SLICE_OK;     
3669
}
3670

    
3671
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3672
{
3673
    int code, val, sign, shift, l;
3674
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3675

    
3676
    if (code == 0)
3677
        return pred;
3678
    if (code < 0)
3679
        return 0xffff;
3680

    
3681
    sign = get_bits1(&s->gb);
3682
    shift = f_code - 1;
3683
    val = code;
3684
    if (shift) {
3685
        val = (val - 1) << shift;
3686
        val |= get_bits(&s->gb, shift);
3687
        val++;
3688
    }
3689
    if (sign)
3690
        val = -val;
3691
    val += pred;
3692

    
3693
    /* modulo decoding */
3694
    if (!s->h263_long_vectors) {
3695
        l = 1 << (f_code + 4);
3696
        val = ((val + l)&(l*2-1)) - l;
3697
    } else {
3698
        /* horrible h263 long vector mode */
3699
        if (pred < -31 && val < -63)
3700
            val += 64;
3701
        if (pred > 32 && val > 63)
3702
            val -= 64;
3703
        
3704
    }
3705
    return val;
3706
}
3707

    
3708
/* Decodes RVLC of H.263+ UMV */
3709
static int h263p_decode_umotion(MpegEncContext * s, int pred)
3710
{
3711
   int code = 0, sign;
3712
   
3713
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
3714
      return pred;
3715
   
3716
   code = 2 + get_bits1(&s->gb);
3717
   
3718
   while (get_bits1(&s->gb))
3719
   {
3720
      code <<= 1;
3721
      code += get_bits1(&s->gb);
3722
   }
3723
   sign = code & 1;
3724
   code >>= 1;
3725
   
3726
   code = (sign) ? (pred - code) : (pred + code);
3727
#ifdef DEBUG
3728
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3729
#endif
3730
   return code;   
3731

    
3732
}
3733

    
3734
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3735
                             int n, int coded)
3736
{
3737
    int code, level, i, j, last, run;
3738
    RLTable *rl = &rl_inter;
3739
    const uint8_t *scan_table;
3740

    
3741
    scan_table = s->intra_scantable.permutated;
3742
    if (s->h263_aic && s->mb_intra) {
3743
        rl = &rl_intra_aic;
3744
        i = 0;
3745
        if (s->ac_pred) {
3746
            if (s->h263_aic_dir) 
3747
                scan_table = s->intra_v_scantable.permutated; /* left */
3748
            else
3749
                scan_table = s->intra_h_scantable.permutated; /* top */
3750
        }
3751
    } else if (s->mb_intra) {
3752
        /* DC coef */
3753
        if(s->h263_rv10){
3754
          if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
3755
            int component, diff;
3756
            component = (n <= 3 ? 0 : n - 4 + 1);
3757
            level = s->last_dc[component];
3758
            if (s->rv10_first_dc_coded[component]) {
3759
                diff = rv_decode_dc(s, n);
3760
                if (diff == 0xffff)
3761
                    return -1;
3762
                level += diff;
3763
                level = level & 0xff; /* handle wrap round */
3764
                s->last_dc[component] = level;
3765
            } else {
3766
                s->rv10_first_dc_coded[component] = 1;
3767
            }
3768
          } else {
3769
                level = get_bits(&s->gb, 8);
3770
          }
3771
        }else{
3772
            level = get_bits(&s->gb, 8);
3773
            if((level&0x7F) == 0){
3774
                fprintf(stderr, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
3775
                return -1;
3776
            }
3777
            if (level == 255)
3778
                level = 128;
3779
        }
3780
        block[0] = level;
3781
        i = 1;
3782
    } else {
3783
        i = 0;
3784
    }
3785
    if (!coded) {
3786
        if (s->mb_intra && s->h263_aic)
3787
            goto not_coded;
3788
        s->block_last_index[n] = i - 1;
3789
        return 0;
3790
    }
3791

    
3792
    for(;;) {
3793
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3794
        if (code < 0){
3795
            fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3796
            return -1;
3797
        }
3798
        if (code == rl->n) {
3799
            /* escape */
3800
            if (s->h263_flv > 1) {
3801
                int is11 = get_bits1(&s->gb);
3802
                last = get_bits1(&s->gb);
3803
                run = get_bits(&s->gb, 6);
3804
                if(is11){
3805
                    level = get_sbits(&s->gb, 11);
3806
                } else {
3807
                    level = get_sbits(&s->gb, 7);
3808
                }
3809
            } else {
3810
                last = get_bits1(&s->gb);
3811
                run = get_bits(&s->gb, 6);
3812
                level = (int8_t)get_bits(&s->gb, 8);
3813
                if(level == -128){
3814
                    if (s->h263_rv10) {
3815
                        /* XXX: should patch encoder too */
3816
                        level = get_sbits(&s->gb, 12);
3817
                    }else{
3818
                        level = get_bits(&s->gb, 5);
3819
                        level |= get_sbits(&s->gb, 6)<<5;
3820
                    }
3821
                }
3822
            }
3823
        } else {
3824
            run = rl->table_run[code];
3825
            level = rl->table_level[code];
3826
            last = code >= rl->last;
3827
            if (get_bits1(&s->gb))
3828
                level = -level;
3829
        }
3830
        i += run;
3831
        if (i >= 64){
3832
            fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
3833
            return -1;
3834
        }
3835
        j = scan_table[i];
3836
        block[j] = level;
3837
        if (last)
3838
            break;
3839
        i++;
3840
    }
3841
not_coded:    
3842
    if (s->mb_intra && s->h263_aic) {
3843
        h263_pred_acdc(s, block, n);
3844
        i = 63;
3845
    }
3846
    s->block_last_index[n] = i;
3847
    return 0;
3848
}
3849

    
3850
/**
3851
 * decodes the dc value.
3852
 * @param n block index (0-3 are luma, 4-5 are chroma)
3853
 * @param dir_ptr the prediction direction will be stored here
3854
 * @return the quantized dc
3855
 */
3856
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3857
{
3858
    int level, pred, code;
3859
    uint16_t *dc_val;
3860

    
3861
    if (n < 4) 
3862
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3863
    else 
3864
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3865
    if (code < 0 || code > 9 /* && s->nbit<9 */){
3866
        fprintf(stderr, "illegal dc vlc\n");
3867
        return -1;
3868
    }
3869
    if (code == 0) {
3870
        level = 0;
3871
    } else {
3872
        if(IS_3IV1){
3873
            if(code==1)
3874
                level= 2*get_bits1(&s->gb)-1;
3875
            else{
3876
                if(get_bits1(&s->gb))
3877
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
3878
                else
3879
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
3880
            }
3881
        }else{
3882
            level = get_xbits(&s->gb, code);
3883
        }
3884

    
3885
        if (code > 8){
3886
            if(get_bits1(&s->gb)==0){ /* marker */
3887
                if(s->error_resilience>=2){
3888
                    fprintf(stderr, "dc marker bit missing\n");
3889
                    return -1;
3890
                }
3891
            }
3892
        }
3893
    }
3894
    pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3895
    level += pred;
3896
    if (level < 0){
3897
        if(s->error_resilience>=3){
3898
            fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3899
            return -1;
3900
        }
3901
        level = 0;
3902
    }
3903
    if (n < 4) {
3904
        *dc_val = level * s->y_dc_scale;
3905
    } else {
3906
        *dc_val = level * s->c_dc_scale;
3907
    }
3908
    if(IS_3IV1)
3909
        *dc_val = level * 8;
3910
    
3911
    if(s->error_resilience>=3){
3912
        if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3913
            fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3914
            return -1;
3915
        }
3916
    }
3917
    return level;
3918
}
3919

    
3920
/**
3921
 * decodes a block.
3922
 * @return <0 if an error occured
3923
 */
3924
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3925
                              int n, int coded, int intra, int rvlc)
3926
{
3927
    int level, i, last, run;
3928
    int dc_pred_dir;
3929
    RLTable * rl;
3930
    RL_VLC_ELEM * rl_vlc;
3931
    const uint8_t * scan_table;
3932
    int qmul, qadd;
3933

    
3934
    //Note intra & rvlc should be optimized away if this is inlined
3935
    
3936
    if(intra) {
3937
      if(s->qscale < s->intra_dc_threshold){
3938
        /* DC coef */
3939
        if(s->partitioned_frame){
3940
            level = s->dc_val[0][ s->block_index[n] ];
3941
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
3942
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
3943
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
3944
        }else{
3945
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3946
            if (level < 0)
3947
                return -1;
3948
        }
3949
        block[0] = level;
3950
        i = 0;
3951
      }else{
3952
            i = -1;
3953
      }  
3954
        if (!coded) 
3955
            goto not_coded;
3956
        
3957
        if(rvlc){        
3958
            rl = &rvlc_rl_intra;
3959
            rl_vlc = rvlc_rl_intra.rl_vlc[0];
3960
        }else{
3961
            rl = &rl_intra;
3962
            rl_vlc = rl_intra.rl_vlc[0];
3963
        }
3964
        if (s->ac_pred) {
3965
            if (dc_pred_dir == 0) 
3966
                scan_table = s->intra_v_scantable.permutated; /* left */
3967
            else
3968
                scan_table = s->intra_h_scantable.permutated; /* top */
3969
        } else {
3970
            scan_table = s->intra_scantable.permutated;
3971
        }
3972
        qmul=1;
3973
        qadd=0;
3974
    } else {
3975
        i = -1;
3976
        if (!coded) {
3977
            s->block_last_index[n] = i;
3978
            return 0;
3979
        }
3980
        if(rvlc) rl = &rvlc_rl_inter;
3981
        else     rl = &rl_inter;
3982
   
3983
        scan_table = s->intra_scantable.permutated;
3984

    
3985
        if(s->mpeg_quant){
3986
            qmul=1;
3987
            qadd=0;
3988
            if(rvlc){        
3989
                rl_vlc = rvlc_rl_inter.rl_vlc[0];        
3990
            }else{
3991
                rl_vlc = rl_inter.rl_vlc[0];        
3992
            }
3993
        }else{
3994
            qmul = s->qscale << 1;
3995
            qadd = (s->qscale - 1) | 1;
3996
            if(rvlc){        
3997
                rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];        
3998
            }else{
3999
                rl_vlc = rl_inter.rl_vlc[s->qscale];        
4000
            }
4001
        }
4002
    }
4003
  {
4004
    OPEN_READER(re, &s->gb);
4005
    for(;;) {
4006
        UPDATE_CACHE(re, &s->gb);
4007
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4008
        if (level==0) {
4009
          /* escape */                
4010
          if(rvlc){
4011
                if(SHOW_UBITS(re, &s->gb, 1)==0){
4012
                    fprintf(stderr, "1. marker bit missing in rvlc esc\n");
4013
                    return -1;
4014
                }; SKIP_CACHE(re, &s->gb, 1);
4015
 
4016
                last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4017
                run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4018
                SKIP_COUNTER(re, &s->gb, 1+1+6);
4019
                UPDATE_CACHE(re, &s->gb);
4020
              
4021
                if(SHOW_UBITS(re, &s->gb, 1)==0){
4022
                    fprintf(stderr, "2. marker bit missing in rvlc esc\n");
4023
                    return -1;
4024
                }; SKIP_CACHE(re, &s->gb, 1);
4025
 
4026
                level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4027
 
4028
                if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4029
                    fprintf(stderr, "reverse esc missing\n");
4030
                    return -1;
4031
                }; SKIP_CACHE(re, &s->gb, 5);
4032

    
4033
                level=  level * qmul + qadd;
4034
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4035
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4036

    
4037
                i+= run + 1;
4038
                if(last) i+=192;
4039
          }else{
4040
            int cache;
4041
            cache= GET_CACHE(re, &s->gb);
4042

    
4043
            if(IS_3IV1) 
4044
                cache ^= 0xC0000000;
4045

    
4046
            if (cache&0x80000000) {
4047
                if (cache&0x40000000) {
4048
                    /* third escape */
4049
                    SKIP_CACHE(re, &s->gb, 2);
4050
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4051
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4052
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
4053
                    UPDATE_CACHE(re, &s->gb);
4054

    
4055
                    if(IS_3IV1){
4056
                        level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4057
                    }else{
4058
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
4059
                            fprintf(stderr, "1. marker bit missing in 3. esc\n");
4060
                            return -1;
4061
                        }; SKIP_CACHE(re, &s->gb, 1);
4062

    
4063
                        level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4064

    
4065
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
4066
                            fprintf(stderr, "2. marker bit missing in 3. esc\n");
4067
                            return -1;
4068
                        }; LAST_SKIP_CACHE(re, &s->gb, 1);
4069

    
4070
                        SKIP_COUNTER(re, &s->gb, 1+12+1);
4071
                    }
4072
 
4073
                    if(level*s->qscale>1024 || level*s->qscale<-1024){
4074
                        fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4075
                        return -1;
4076
                    }
4077
#if 0
4078
                    if(s->error_resilience >= FF_ER_COMPLIANT){
4079
                        const int abs_level= ABS(level);
4080
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4081
                            const int run1= run - rl->max_run[last][abs_level] - 1;
4082
                            if(abs_level <= rl->max_level[last][run]){
4083
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
4084
                                return -1;
4085
                            }
4086
                            if(s->error_resilience > FF_ER_COMPLIANT){
4087
                                if(abs_level <= rl->max_level[last][run]*2){
4088
                                    fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
4089
                                    return -1;
4090
                                }
4091
                                if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4092
                                    fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
4093
                                    return -1;
4094
                                }
4095
                            }
4096
                        }
4097
                    }
4098
#endif
4099
                    if (level>0) level= level * qmul + qadd;
4100
                    else         level= level * qmul - qadd;
4101

    
4102
                    i+= run + 1;
4103
                    if(last) i+=192;
4104
                } else {
4105
                    /* second escape */
4106
#if MIN_CACHE_BITS < 20
4107
                    LAST_SKIP_BITS(re, &s->gb, 2);
4108
                    UPDATE_CACHE(re, &s->gb);
4109
#else
4110
                    SKIP_BITS(re, &s->gb, 2);
4111
#endif
4112
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4113
                    i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4114
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4115
                    LAST_SKIP_BITS(re, &s->gb, 1);
4116
                }
4117
            } else {
4118
                /* first escape */
4119
#if MIN_CACHE_BITS < 19
4120
                LAST_SKIP_BITS(re, &s->gb, 1);
4121
                UPDATE_CACHE(re, &s->gb);
4122
#else
4123
                SKIP_BITS(re, &s->gb, 1);
4124
#endif
4125
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4126
                i+= run;
4127
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4128
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4129
                LAST_SKIP_BITS(re, &s->gb, 1);
4130
            }
4131
          }
4132
        } else {
4133
            i+= run;
4134
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4135
            LAST_SKIP_BITS(re, &s->gb, 1);
4136
        }
4137
        if (i > 62){
4138
            i-= 192;
4139
            if(i&(~63)){
4140
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4141
                return -1;
4142
            }
4143

    
4144
            block[scan_table[i]] = level;
4145
            break;
4146
        }
4147

    
4148
        block[scan_table[i]] = level;
4149
    }
4150
    CLOSE_READER(re, &s->gb);
4151
  }
4152
 not_coded:
4153
    if (intra) {
4154
        if(s->qscale >= s->intra_dc_threshold){
4155
            uint16_t *dc_val;
4156
            block[0] += ff_mpeg4_pred_dc(s, n, &dc_val, &dc_pred_dir);
4157
            if (n < 4) {
4158
                *dc_val = block[0] * s->y_dc_scale;
4159
            } else {
4160
                *dc_val = block[0] * s->c_dc_scale;
4161
            }
4162

    
4163
            if(i == -1) i=0;
4164
        }
4165

    
4166
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
4167
        if (s->ac_pred) {
4168
            i = 63; /* XXX: not optimal */
4169
        }
4170
    }
4171
    s->block_last_index[n] = i;
4172
    return 0;
4173
}
4174

    
4175
/* most is hardcoded. should extend to handle all h263 streams */
4176
int h263_decode_picture_header(MpegEncContext *s)
4177
{
4178
    int format, width, height, i;
4179
    uint32_t startcode;
4180
    
4181
    align_get_bits(&s->gb);
4182

    
4183
    startcode= get_bits(&s->gb, 22-8);
4184

    
4185
    for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4186
        startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4187
        
4188
        if(startcode == 0x20)
4189
            break;
4190
    }
4191
        
4192
    if (startcode != 0x20) {
4193
        fprintf(stderr, "Bad picture start code\n");
4194
        return -1;
4195
    }
4196
    /* temporal reference */
4197
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4198

    
4199
    /* PTYPE starts here */    
4200
    if (get_bits1(&s->gb) != 1) {
4201
        /* marker */
4202
        fprintf(stderr, "Bad marker\n");
4203
        return -1;
4204
    }
4205
    if (get_bits1(&s->gb) != 0) {
4206
        fprintf(stderr, "Bad H263 id\n");
4207
        return -1;        /* h263 id */
4208
    }
4209
    skip_bits1(&s->gb);        /* split screen off */
4210
    skip_bits1(&s->gb);        /* camera  off */
4211
    skip_bits1(&s->gb);        /* freeze picture release off */
4212

    
4213
    /* Reset GOB number */
4214
    s->gob_number = 0;
4215
        
4216
    format = get_bits(&s->gb, 3);
4217
    /*
4218
        0    forbidden
4219
        1    sub-QCIF
4220
        10   QCIF
4221
        7        extended PTYPE (PLUSPTYPE)
4222
    */
4223

    
4224
    if (format != 7 && format != 6) {
4225
        s->h263_plus = 0;
4226
        /* H.263v1 */
4227
        width = h263_format[format][0];
4228
        height = h263_format[format][1];
4229
        if (!width)
4230
            return -1;
4231
        
4232
        s->pict_type = I_TYPE + get_bits1(&s->gb);
4233

    
4234
        s->unrestricted_mv = get_bits1(&s->gb); 
4235
        s->h263_long_vectors = s->unrestricted_mv;
4236

    
4237
        if (get_bits1(&s->gb) != 0) {
4238
            fprintf(stderr, "H263 SAC not supported\n");
4239
            return -1;        /* SAC: off */
4240
        }
4241
        if (get_bits1(&s->gb) != 0) {
4242
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
4243
        }   
4244
        
4245
        if (get_bits1(&s->gb) != 0) {
4246
            fprintf(stderr, "H263 PB frame not supported\n");
4247
            return -1;        /* not PB frame */
4248
        }
4249
        s->qscale = get_bits(&s->gb, 5);
4250
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
4251

    
4252
        s->width = width;
4253
        s->height = height;
4254
    } else {
4255
        int ufep;
4256
        
4257
        /* H.263v2 */
4258
        s->h263_plus = 1;
4259
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
4260

    
4261
        /* ufep other than 0 and 1 are reserved */        
4262
        if (ufep == 1) {
4263
            /* OPPTYPE */       
4264
            format = get_bits(&s->gb, 3);
4265
            dprintf("ufep=1, format: %d\n", format);
4266
            skip_bits(&s->gb,1); /* Custom PCF */
4267
            s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
4268
            s->unrestricted_mv = s->umvplus;
4269
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
4270
            if (get_bits1(&s->gb) != 0) {
4271
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
4272
            }
4273
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
4274
                s->h263_aic = 1;
4275
            }
4276
            
4277
            if (get_bits1(&s->gb) != 0) {
4278
                fprintf(stderr, "Deblocking Filter not supported\n");
4279
            }
4280
            if (get_bits1(&s->gb) != 0) {
4281
                fprintf(stderr, "Slice Structured not supported\n");
4282
            }
4283
            if (get_bits1(&s->gb) != 0) {
4284
                fprintf(stderr, "Reference Picture Selection not supported\n");
4285
            }
4286
            if (get_bits1(&s->gb) != 0) {
4287
                fprintf(stderr, "Independent Segment Decoding not supported\n");
4288
            }
4289
            if (get_bits1(&s->gb) != 0) {
4290
                fprintf(stderr, "Alternative Inter VLC not supported\n");
4291
            }
4292
            if (get_bits1(&s->gb) != 0) {
4293
                fprintf(stderr, "Modified Quantization not supported\n");
4294
            }
4295
            
4296
            skip_bits(&s->gb, 1); /* Prevent start code emulation */
4297

    
4298
            skip_bits(&s->gb, 3); /* Reserved */
4299
        } else if (ufep != 0) {
4300
            fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
4301
            return -1;
4302
        }
4303
            
4304
        /* MPPTYPE */
4305
        s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
4306
        dprintf("pict_type: %d\n", s->pict_type);
4307
        if (s->pict_type == 8 && s->avctx->codec_tag == ff_get_fourcc("ZYGO"))
4308
            s->pict_type = I_TYPE;
4309
        if (s->pict_type != I_TYPE &&
4310
            s->pict_type != P_TYPE)
4311
            return -1;
4312
        skip_bits(&s->gb, 2);
4313
        s->no_rounding = get_bits1(&s->gb);
4314
        dprintf("RTYPE: %d\n", s->no_rounding);
4315
        skip_bits(&s->gb, 4);
4316
        
4317
        /* Get the picture dimensions */
4318
        if (ufep) {
4319
            if (format == 6) {
4320
                /* Custom Picture Format (CPFMT) */
4321
                s->aspect_ratio_info = get_bits(&s->gb, 4);
4322
                dprintf("aspect: %d\n", s->aspect_ratio_info);
4323
                /* aspect ratios:
4324
                0 - forbidden
4325
                1 - 1:1
4326
                2 - 12:11 (CIF 4:3)
4327
                3 - 10:11 (525-type 4:3)
4328
                4 - 16:11 (CIF 16:9)
4329
                5 - 40:33 (525-type 16:9)
4330
                6-14 - reserved
4331
                */
4332
                width = (get_bits(&s->gb, 9) + 1) * 4;
4333
                skip_bits1(&s->gb);
4334
                height = get_bits(&s->gb, 9) * 4;
4335
                dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
4336
                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
4337
                    /* aspected dimensions */
4338
                    s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
4339
                    s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
4340
                }else{
4341
                    s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
4342
                }
4343
            } else {
4344
                width = h263_format[format][0];
4345
                height = h263_format[format][1];
4346
            }
4347
            if ((width == 0) || (height == 0))
4348
                return -1;
4349
            s->width = width;
4350
            s->height = height;
4351
            if (s->umvplus) {
4352
                if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
4353
                    skip_bits1(&s->gb); 
4354
            }
4355
        }
4356
            
4357
        s->qscale = get_bits(&s->gb, 5);
4358
    }
4359
    /* PEI */
4360
    while (get_bits1(&s->gb) != 0) {
4361
        skip_bits(&s->gb, 8);
4362
    }
4363
    s->f_code = 1;
4364
    
4365
    if(s->h263_aic){
4366
         s->y_dc_scale_table= 
4367
         s->c_dc_scale_table= h263_aic_dc_scale_table;
4368
    }else{
4369
        s->y_dc_scale_table=
4370
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4371
    }
4372

    
4373
     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4374
         printf("qp:%d %c size:%d rnd:%d %s %s %s %s\n", 
4375
         s->qscale, av_get_pict_type_char(s->pict_type),
4376
         s->gb.size_in_bits, 1-s->no_rounding,
4377
         s->mv_type == MV_TYPE_8X8 ? "ADV" : "",
4378
         s->umvplus ? "UMV" : "",
4379
         s->h263_long_vectors ? "LONG" : "",
4380
         s->h263_plus ? "+" : ""
4381
         ); 
4382
     }
4383
#if 1
4384
    if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
4385
        int i,j;
4386
        for(i=0; i<85; i++) printf("%d", get_bits1(&s->gb));
4387
        printf("\n");
4388
        for(i=0; i<13; i++){
4389
            for(j=0; j<3; j++){
4390
                int v= get_bits(&s->gb, 8);
4391
                v |= get_sbits(&s->gb, 8)<<8;
4392
                printf(" %5d", v);
4393
            }
4394
            printf("\n");
4395
        }
4396
        for(i=0; i<50; i++) printf("%d", get_bits1(&s->gb));
4397
    }
4398
#endif
4399

    
4400
    return 0;
4401
}
4402

    
4403
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
4404
{
4405
    int i;
4406
    int a= 2<<s->sprite_warping_accuracy;
4407
    int rho= 3-s->sprite_warping_accuracy;
4408
    int r=16/a;
4409
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
4410
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
4411
    int sprite_ref[4][2];
4412
    int virtual_ref[2][2];
4413
    int w2, h2, w3, h3;
4414
    int alpha=0, beta=0;
4415
    int w= s->width;
4416
    int h= s->height;
4417
    int min_ab;
4418

    
4419
    for(i=0; i<s->num_sprite_warping_points; i++){
4420
        int length;
4421
        int x=0, y=0;
4422

    
4423
        length= get_vlc(&s->gb, &sprite_trajectory);
4424
        if(length){
4425
            x= get_xbits(&s->gb, length);
4426
        }
4427
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4428
        
4429
        length= get_vlc(&s->gb, &sprite_trajectory);
4430
        if(length){
4431
            y=get_xbits(&s->gb, length);
4432
        }
4433
        skip_bits1(&s->gb); /* marker bit */
4434
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4435
        d[i][0]= x;
4436
        d[i][1]= y;
4437
    }
4438

    
4439
    while((1<<alpha)<w) alpha++;
4440
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
4441
    w2= 1<<alpha;
4442
    h2= 1<<beta;
4443

    
4444
// Note, the 4th point isnt used for GMC
4445
    if(s->divx_version==500 && s->divx_build==413){
4446
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
4447
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
4448
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
4449
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
4450
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
4451
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
4452
    } else {
4453
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
4454
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
4455
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
4456
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
4457
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
4458
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
4459
    }
4460
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
4461
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
4462
    
4463
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
4464
// perhaps it should be reordered to be more readable ...
4465
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
4466
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
4467
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
4468
        + 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);
4469
    virtual_ref[0][1]= 16*vop_ref[0][1] 
4470
        + 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);
4471
    virtual_ref[1][0]= 16*vop_ref[0][0] 
4472
        + 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);
4473
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
4474
        + 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);
4475
        
4476
    switch(s->num_sprite_warping_points)
4477
    {
4478
        case 0:
4479
            s->sprite_offset[0][0]= 0;
4480
            s->sprite_offset[0][1]= 0;
4481
            s->sprite_offset[1][0]= 0;
4482
            s->sprite_offset[1][1]= 0;
4483
            s->sprite_delta[0][0]= a;
4484
            s->sprite_delta[0][1]= 0;
4485
            s->sprite_delta[1][0]= 0;
4486
            s->sprite_delta[1][1]= a;
4487
            s->sprite_shift[0]= 0;
4488
            s->sprite_shift[1]= 0;
4489
            break;
4490
        case 1: //GMC only
4491
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
4492
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
4493
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
4494
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
4495
            s->sprite_delta[0][0]= a;
4496
            s->sprite_delta[0][1]= 0;
4497
            s->sprite_delta[1][0]= 0;
4498
            s->sprite_delta[1][1]= a;
4499
            s->sprite_shift[0]= 0;
4500
            s->sprite_shift[1]= 0;
4501
            break;
4502
        case 2:
4503
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
4504
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
4505
                                                  + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
4506
                                                  + (1<<(alpha+rho-1));
4507
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
4508
                                                  + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
4509
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
4510
                                                  + (1<<(alpha+rho-1));
4511
            s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
4512
                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
4513
                                     +2*w2*r*sprite_ref[0][0] 
4514
                                     - 16*w2 
4515
                                     + (1<<(alpha+rho+1)));
4516
            s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
4517
                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
4518
                                     +2*w2*r*sprite_ref[0][1] 
4519
                                     - 16*w2
4520
                                     + (1<<(alpha+rho+1)));
4521
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4522
            s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
4523
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
4524
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4525
            
4526
            s->sprite_shift[0]= alpha+rho;
4527
            s->sprite_shift[1]= alpha+rho+2;
4528
            break;
4529
        case 3:
4530
            min_ab= FFMIN(alpha, beta);
4531
            w3= w2>>min_ab;
4532
            h3= h2>>min_ab;
4533
            s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
4534
                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
4535
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
4536
                                   + (1<<(alpha+beta+rho-min_ab-1));
4537
            s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
4538
                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
4539
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
4540
                                   + (1<<(alpha+beta+rho-min_ab-1));
4541
            s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
4542
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
4543
                                   + 2*w2*h3*r*sprite_ref[0][0]
4544
                                   - 16*w2*h3
4545
                                   + (1<<(alpha+beta+rho-min_ab+1));
4546
            s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4547
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4548
                                   + 2*w2*h3*r*sprite_ref[0][1]
4549
                                   - 16*w2*h3
4550
                                   + (1<<(alpha+beta+rho-min_ab+1));
4551
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4552
            s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4553
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4554
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4555
                                   
4556
            s->sprite_shift[0]= alpha + beta + rho - min_ab;
4557
            s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4558
            break;
4559
    }
4560
    /* try to simplify the situation */ 
4561
    if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4562
       && s->sprite_delta[0][1] == 0
4563
       && s->sprite_delta[1][0] == 0
4564
       && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4565
    {
4566
        s->sprite_offset[0][0]>>=s->sprite_shift[0];
4567
        s->sprite_offset[0][1]>>=s->sprite_shift[0];
4568
        s->sprite_offset[1][0]>>=s->sprite_shift[1];
4569
        s->sprite_offset[1][1]>>=s->sprite_shift[1];
4570
        s->sprite_delta[0][0]= a;
4571
        s->sprite_delta[0][1]= 0;
4572
        s->sprite_delta[1][0]= 0;
4573
        s->sprite_delta[1][1]= a;
4574
        s->sprite_shift[0]= 0;
4575
        s->sprite_shift[1]= 0;
4576
        s->real_sprite_warping_points=1;
4577
    }
4578
    else{
4579
        int shift_y= 16 - s->sprite_shift[0];
4580
        int shift_c= 16 - s->sprite_shift[1];
4581
//printf("shifts %d %d\n", shift_y, shift_c);
4582
        for(i=0; i<2; i++){
4583
            s->sprite_offset[0][i]<<= shift_y;
4584
            s->sprite_offset[1][i]<<= shift_c;
4585
            s->sprite_delta[0][i]<<= shift_y;
4586
            s->sprite_delta[1][i]<<= shift_y;
4587
            s->sprite_shift[i]= 16;
4588
        }
4589
        s->real_sprite_warping_points= s->num_sprite_warping_points;
4590
    }
4591
#if 0
4592
printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4593
    vop_ref[0][0], vop_ref[0][1],
4594
    vop_ref[1][0], vop_ref[1][1],
4595
    vop_ref[2][0], vop_ref[2][1],
4596
    sprite_ref[0][0], sprite_ref[0][1], 
4597
    sprite_ref[1][0], sprite_ref[1][1], 
4598
    sprite_ref[2][0], sprite_ref[2][1], 
4599
    virtual_ref[0][0], virtual_ref[0][1], 
4600
    virtual_ref[1][0], virtual_ref[1][1]
4601
    );
4602
    
4603
printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4604
    s->sprite_offset[0][0], s->sprite_offset[0][1],
4605
    s->sprite_delta[0][0], s->sprite_delta[0][1],
4606
    s->sprite_delta[1][0], s->sprite_delta[1][1],
4607
    s->sprite_shift[0]
4608
    );
4609
#endif
4610
}
4611

    
4612
static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
4613
    int hours, minutes, seconds;
4614

    
4615
    hours= get_bits(gb, 5);
4616
    minutes= get_bits(gb, 6);
4617
    skip_bits1(gb);
4618
    seconds= get_bits(gb, 6);
4619

    
4620
    s->time_base= seconds + 60*(minutes + 60*hours);
4621

    
4622
    skip_bits1(gb);
4623
    skip_bits1(gb);
4624
    
4625
    return 0;
4626
}
4627

    
4628
static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4629
    int width, height, vo_ver_id;
4630

    
4631
    /* vol header */
4632
    skip_bits(gb, 1); /* random access */
4633
    s->vo_type= get_bits(gb, 8);
4634
    if (get_bits1(gb) != 0) { /* is_ol_id */
4635
        vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4636
        skip_bits(gb, 3); /* vo_priority */
4637
    } else {
4638
        vo_ver_id = 1;
4639
    }
4640
//printf("vo type:%d\n",s->vo_type);
4641
    s->aspect_ratio_info= get_bits(gb, 4);
4642
    if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){            
4643
        s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
4644
        s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
4645
    }else{
4646
        s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
4647
    }
4648

    
4649
    if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4650
        int chroma_format= get_bits(gb, 2);
4651
        if(chroma_format!=1){
4652
            printf("illegal chroma format\n");
4653
        }
4654
        s->low_delay= get_bits1(gb);
4655
        if(get_bits1(gb)){ /* vbv parameters */
4656
            get_bits(gb, 15);        /* first_half_bitrate */
4657
            skip_bits1(gb);        /* marker */
4658
            get_bits(gb, 15);        /* latter_half_bitrate */
4659
            skip_bits1(gb);        /* marker */
4660
            get_bits(gb, 15);        /* first_half_vbv_buffer_size */
4661
            skip_bits1(gb);        /* marker */
4662
            get_bits(gb, 3);        /* latter_half_vbv_buffer_size */
4663
            get_bits(gb, 11);        /* first_half_vbv_occupancy */
4664
            skip_bits1(gb);        /* marker */
4665
            get_bits(gb, 15);        /* latter_half_vbv_occupancy */
4666
            skip_bits1(gb);        /* marker */               
4667
        }
4668
    }else{
4669
        // set low delay flag only once so the smart? low delay detection wont be overriden
4670
        if(s->picture_number==0)
4671
            s->low_delay=0;
4672
    }
4673

    
4674
    s->shape = get_bits(gb, 2); /* vol shape */
4675
    if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4676
    if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4677
        printf("Gray shape not supported\n");
4678
        skip_bits(gb, 4);  //video_object_layer_shape_extension
4679
    }
4680

    
4681
    check_marker(gb, "before time_increment_resolution");
4682
    
4683
    s->time_increment_resolution = get_bits(gb, 16);
4684
    
4685
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4686
    if (s->time_increment_bits < 1)
4687
        s->time_increment_bits = 1;
4688
        
4689
    check_marker(gb, "before fixed_vop_rate");
4690

    
4691
    if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
4692
        skip_bits(gb, s->time_increment_bits);
4693
    }
4694

    
4695
    if (s->shape != BIN_ONLY_SHAPE) {
4696
        if (s->shape == RECT_SHAPE) {
4697
            skip_bits1(gb);   /* marker */
4698
            width = get_bits(gb, 13);
4699
            skip_bits1(gb);   /* marker */
4700
            height = get_bits(gb, 13);
4701
            skip_bits1(gb);   /* marker */
4702
            if(width && height){ /* they should