Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 399cec2f

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

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

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

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

    
45
#define INTRA_MCBPC_VLC_BITS 6
46
#define INTER_MCBPC_VLC_BITS 7
47
#define CBPY_VLC_BITS 6
48
#define MV_VLC_BITS 9
49
#define DC_VLC_BITS 9
50
#define SPRITE_TRAJ_VLC_BITS 6
51
#define MB_TYPE_B_VLC_BITS 4
52
#define TEX_VLC_BITS 9
53
#define H263_MBTYPE_B_VLC_BITS 6
54
#define CBPC_B_VLC_BITS 3
55

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

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

    
81
#ifdef CONFIG_ENCODERS
82
static uint8_t uni_DCtab_lum_len[512];
83
static uint8_t uni_DCtab_chrom_len[512];
84
static uint16_t uni_DCtab_lum_bits[512];
85
static uint16_t uni_DCtab_chrom_bits[512];
86

    
87
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
88
static uint8_t fcode_tab[MAX_MV*2+1];
89
static uint8_t umv_fcode_tab[MAX_MV*2+1];
90

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

    
99
/* mpeg4
100
inter
101
max level: 24/6
102
max run: 53/63
103

104
intra
105
max level: 53/16
106
max run: 29/41
107
*/
108
#endif
109

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

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

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

    
135
#ifdef CONFIG_ENCODERS
136

    
137
static void aspect_to_info(MpegEncContext * s, AVRational aspect){
138
    int i;
139

    
140
    if(aspect.num==0) aspect= (AVRational){1,1};
141

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

    
152
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
153
{
154
      int format;
155

    
156
      align_put_bits(&s->pb);
157

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

    
189
      if(s->h263_aic){
190
        s->y_dc_scale_table= 
191
          s->c_dc_scale_table= ff_aic_dc_scale_table;
192
      }else{
193
        s->y_dc_scale_table=
194
          s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
195
      }
196
}
197

    
198
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
199
{
200
    int format;
201

    
202
    align_put_bits(&s->pb);
203

    
204
    /* Update the pointer to last GOB */
205
    s->ptr_lastgob = pbBufPtr(&s->pb);
206
    put_bits(&s->pb, 22, 0x20); /* PSC */
207
    put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / 
208
                         s->avctx->frame_rate) & 0xff);
209

    
210
    put_bits(&s->pb, 1, 1);        /* marker */
211
    put_bits(&s->pb, 1, 0);        /* h263 id */
212
    put_bits(&s->pb, 1, 0);        /* split screen off */
213
    put_bits(&s->pb, 1, 0);        /* camera  off */
214
    put_bits(&s->pb, 1, 0);        /* freeze picture release off */
215
    
216
    format = h263_get_picture_format(s->width, s->height);
217
    if (!s->h263_plus) {
218
        /* H.263v1 */
219
        put_bits(&s->pb, 3, format);
220
        put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
221
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
222
        of H.263v1 UMV implies to check the predicted MV after
223
        calculation of the current MB to see if we're on the limits */
224
        put_bits(&s->pb, 1, 0);        /* unrestricted motion vector: off */
225
        put_bits(&s->pb, 1, 0);        /* SAC: off */
226
        put_bits(&s->pb, 1, s->obmc);        /* advanced prediction mode */
227
        put_bits(&s->pb, 1, 0);        /* not PB frame */
228
        put_bits(&s->pb, 5, s->qscale);
229
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
230
    } else {
231
        /* H.263v2 */
232
        /* H.263 Plus PTYPE */
233
        put_bits(&s->pb, 3, 7);
234
        put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
235
        if (format == 7)
236
            put_bits(&s->pb,3,6); /* Custom Source Format */
237
        else
238
            put_bits(&s->pb, 3, format);
239
            
240
        put_bits(&s->pb,1,0); /* Custom PCF: off */
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,s->obmc); /* Advanced Prediction Mode */
244
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
245
        put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
246
        put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
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,s->alt_inter_vlc); /* Alternative Inter VLC */
250
        put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
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
//FIXME check actual requested range
283
            put_bits(&s->pb,2,1); /* unlimited */
284
        if(s->h263_slice_structured)
285
            put_bits(&s->pb,2,0); /* no weird submodes */
286

    
287
        put_bits(&s->pb, 5, s->qscale);
288
    }
289

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

    
292
    if(s->h263_slice_structured){
293
        put_bits(&s->pb, 1, 1);
294
        
295
        assert(s->mb_x == 0 && s->mb_y == 0);
296
        ff_h263_encode_mba(s);
297

    
298
        put_bits(&s->pb, 1, 1);
299
    }
300

    
301
    if(s->h263_aic){
302
         s->y_dc_scale_table= 
303
         s->c_dc_scale_table= ff_aic_dc_scale_table;
304
    }else{
305
        s->y_dc_scale_table=
306
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
307
    }
308
}
309

    
310
/**
311
 * Encodes a group of blocks header.
312
 */
313
void h263_encode_gob_header(MpegEncContext * s, int mb_line)
314
{
315
    put_bits(&s->pb, 17, 1); /* GBSC */
316

    
317
    if(s->h263_slice_structured){
318
        put_bits(&s->pb, 1, 1);
319

    
320
        ff_h263_encode_mba(s);
321

    
322
        if(s->mb_num > 1583)
323
            put_bits(&s->pb, 1, 1);
324
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
325
        put_bits(&s->pb, 1, 1);
326
        put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
327
    }else{
328
        int gob_number= mb_line / s->gob_index;
329

    
330
        put_bits(&s->pb, 5, gob_number); /* GN */
331
        put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
332
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
333
    }
334
}
335

    
336
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
337
    int last=0;
338
    int j;
339
    int rate=0;
340

    
341
    for(j=1; j<=block_last_index; j++){
342
        const int index= scantable[j];
343
        int level= block[index];
344
        if(level){
345
            level+= 64;
346
            if((level&(~127)) == 0){
347
                if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
348
                else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
349
            }else
350
                rate += s->ac_esc_length;
351
            level-= 64;
352

    
353
            last= j;
354
        }
355
    }
356
    
357
    return rate;
358
}
359

    
360
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
361
{
362
    int score= 0;
363
    int i, n;
364
    int8_t * const qscale_table= s->current_picture.qscale_table;
365

    
366
    memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
367
    
368
    for(n=0; n<6; n++){
369
        int16_t *ac_val, *ac_val1;
370
        
371
        score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
372

    
373
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
374
        ac_val1= ac_val;
375
        if(dir[n]){
376
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
377
            /* top prediction */
378
            ac_val-= s->block_wrap[n]*16;
379
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
380
                /* same qscale */
381
                for(i=1; i<8; i++){
382
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
383
                    block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
384
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
385
                    ac_val1[i+8]= level;
386
                }
387
            }else{
388
                /* different qscale, we must rescale */
389
                for(i=1; i<8; i++){
390
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
391
                    block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
392
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
393
                    ac_val1[i+8]= level;
394
                }
395
            }
396
            st[n]= s->intra_h_scantable.permutated;
397
        }else{
398
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
399
            /* left prediction */
400
            ac_val-= 16;
401
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
402
                /* same qscale */
403
                for(i=1; i<8; i++){
404
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
405
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
406
                    ac_val1[i  ]= level;
407
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
408
                }
409
            }else{
410
                /* different qscale, we must rescale */
411
                for(i=1; i<8; i++){
412
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
413
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
414
                    ac_val1[i  ]= level;
415
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
416
                }
417
            }
418
            st[n]= s->intra_v_scantable.permutated;
419
        }
420

    
421
        for(i=63; i>0; i--) //FIXME optimize
422
            if(block[n][ st[n][i] ]) break;
423
        s->block_last_index[n]= i;
424

    
425
        score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
426
    }
427

    
428
    return score < 0;
429
}
430

    
431
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
432
{
433
    int i, n;
434
    memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
435

    
436
    for(n=0; n<6; n++){
437
        int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
438

    
439
        st[n]= s->intra_scantable.permutated;
440
        if(dir[n]){
441
            /* top prediction */
442
            for(i=1; i<8; i++){
443
                block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
444
            }
445
        }else{
446
            /* left prediction */
447
            for(i=1; i<8; i++){
448
                block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
449
            }
450
        }
451
    }
452
}
453

    
454
/**
455
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
456
 */
457
void ff_clean_h263_qscales(MpegEncContext *s){
458
    int i;
459
    int8_t * const qscale_table= s->current_picture.qscale_table;
460
    
461
    for(i=1; i<s->mb_num; i++){
462
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
463
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
464
    }
465
    for(i=s->mb_num-2; i>=0; i--){
466
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
467
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
468
    }
469
}
470

    
471
/**
472
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
473
 */
474
void ff_clean_mpeg4_qscales(MpegEncContext *s){
475
    int i;
476
    int8_t * const qscale_table= s->current_picture.qscale_table;
477

    
478
    ff_clean_h263_qscales(s);
479
    
480
    for(i=1; i<s->mb_num; i++){
481
        int mb_xy= s->mb_index2xy[i];
482
    
483
        if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
484
            s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
485
            s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
486
        }
487
    }
488

    
489
    if(s->pict_type== B_TYPE){
490
        int odd=0;
491
        /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
492
           for the actual adaptive quantization */
493
        
494
        for(i=0; i<s->mb_num; i++){
495
            int mb_xy= s->mb_index2xy[i];
496
            odd += qscale_table[mb_xy]&1;
497
        }
498
        
499
        if(2*odd > s->mb_num) odd=1;
500
        else                  odd=0;
501
        
502
        for(i=0; i<s->mb_num; i++){
503
            int mb_xy= s->mb_index2xy[i];
504
            if((qscale_table[mb_xy]&1) != odd)
505
                qscale_table[mb_xy]++;
506
            if(qscale_table[mb_xy] > 31)
507
                qscale_table[mb_xy]= 31;
508
        }            
509
    
510
        for(i=1; i<s->mb_num; i++){
511
            int mb_xy= s->mb_index2xy[i];
512
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
513
                s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
514
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
515
            }
516
        }
517
    }
518
}
519

    
520
#endif //CONFIG_ENCODERS
521
/**
522
 *
523
 * @return the mb_type
524
 */
525
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
526
    const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
527
    const int colocated_mb_type= s->next_picture.mb_type[mb_index];
528
    int xy= s->block_index[0];
529
    uint16_t time_pp= s->pp_time;
530
    uint16_t time_pb= s->pb_time;
531
    int i;
532
    
533
    //FIXME avoid divides
534
    
535
    if(IS_8X8(colocated_mb_type)){
536
        s->mv_type = MV_TYPE_8X8;
537
        for(i=0; i<4; i++){
538
            xy= s->block_index[i];
539
            s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
540
            s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
541
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0]
542
                                : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
543
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1] 
544
                                : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
545
        }
546
        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
547
    } else if(IS_INTERLACED(colocated_mb_type)){
548
        s->mv_type = MV_TYPE_FIELD;
549
        for(i=0; i<2; i++){
550
            if(s->top_field_first){
551
                time_pp= s->pp_field_time - s->p_field_select_table[i][mb_index] + i;
552
                time_pb= s->pb_field_time - s->p_field_select_table[i][mb_index] + i;
553
            }else{
554
                time_pp= s->pp_field_time + s->p_field_select_table[i][mb_index] - i;
555
                time_pb= s->pb_field_time + s->p_field_select_table[i][mb_index] - i;
556
            }
557
            s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
558
            s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
559
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
560
                                : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
561
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] 
562
                                : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
563
        }
564
        return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
565
    }else{
566
        s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
567
        s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
568
        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->next_picture.motion_val[0][xy][0]
569
                            : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
570
        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->next_picture.motion_val[0][xy][1] 
571
                            : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
572
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
573
            s->mv_type= MV_TYPE_16X16;
574
        else
575
            s->mv_type= MV_TYPE_8X8;
576
        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
577
    }
578
}
579

    
580
void ff_h263_update_motion_val(MpegEncContext * s){
581
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
582
               //FIXME a lot of thet is only needed for !low_delay
583
    const int wrap = s->block_wrap[0];
584
    const int xy = s->block_index[0];
585
    
586
    s->current_picture.mbskip_table[mb_xy]= s->mb_skiped; 
587

    
588
    if(s->mv_type != MV_TYPE_8X8){
589
        int motion_x, motion_y;
590
        if (s->mb_intra) {
591
            motion_x = 0;
592
            motion_y = 0;
593
        } else if (s->mv_type == MV_TYPE_16X16) {
594
            motion_x = s->mv[0][0][0];
595
            motion_y = s->mv[0][0][1];
596
        } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
597
            int i;
598
            motion_x = s->mv[0][0][0] + s->mv[0][1][0];
599
            motion_y = s->mv[0][0][1] + s->mv[0][1][1];
600
            motion_x = (motion_x>>1) | (motion_x&1);
601
            for(i=0; i<2; i++){
602
                s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
603
                s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
604
                s->p_field_select_table[i][mb_xy]= s->field_select[0][i];
605
            }
606
        }
607
        
608
        /* no update if 8X8 because it has been done during parsing */
609
        s->current_picture.motion_val[0][xy][0] = motion_x;
610
        s->current_picture.motion_val[0][xy][1] = motion_y;
611
        s->current_picture.motion_val[0][xy + 1][0] = motion_x;
612
        s->current_picture.motion_val[0][xy + 1][1] = motion_y;
613
        s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
614
        s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
615
        s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
616
        s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
617
    }
618

    
619
    if(s->encoding){ //FIXME encoding MUST be cleaned up
620
        if (s->mv_type == MV_TYPE_8X8) 
621
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
622
        else if(s->mb_intra)
623
            s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
624
        else
625
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
626
    }
627
}
628

    
629
#ifdef CONFIG_ENCODERS
630

    
631
static inline int get_p_cbp(MpegEncContext * s,
632
                      DCTELEM block[6][64],
633
                      int motion_x, int motion_y){
634
    int cbp, i;
635

    
636
    if(s->flags & CODEC_FLAG_CBP_RD){
637
        int best_cbpy_score= INT_MAX;
638
        int best_cbpc_score= INT_MAX;
639
        int cbpc = (-1), cbpy= (-1);
640
        const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
641
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
642

    
643
        for(i=0; i<4; i++){
644
            int score= inter_MCBPC_bits[i + offset] * lambda;
645
            if(i&1) score += s->coded_score[5];
646
            if(i&2) score += s->coded_score[4];
647

    
648
            if(score < best_cbpc_score){
649
                best_cbpc_score= score;
650
                cbpc= i;
651
            }
652
        }
653

    
654
        for(i=0; i<16; i++){
655
            int score= cbpy_tab[i ^ 0xF][1] * lambda;
656
            if(i&1) score += s->coded_score[3];
657
            if(i&2) score += s->coded_score[2];
658
            if(i&4) score += s->coded_score[1];
659
            if(i&8) score += s->coded_score[0];
660

    
661
            if(score < best_cbpy_score){
662
                best_cbpy_score= score;
663
                cbpy= i;
664
            }
665
        }
666
        cbp= cbpc + 4*cbpy;
667
        if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
668
            if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
669
                cbp= 0;
670
        }
671

    
672
        for (i = 0; i < 6; i++) {
673
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
674
                s->block_last_index[i]= -1;
675
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
676
            }
677
        }
678
    }else{
679
        cbp= 0;
680
        for (i = 0; i < 6; i++) {
681
            if (s->block_last_index[i] >= 0)
682
                cbp |= 1 << (5 - i);
683
        }
684
    }
685
    return cbp;
686
}
687

    
688
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
689
                            int motion_x, int motion_y, int mb_type){
690
    int cbp=0, i;
691

    
692
    if(s->flags & CODEC_FLAG_CBP_RD){
693
        int score=0;
694
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
695
        
696
        for(i=0; i<6; i++){
697
            if(s->coded_score[i] < 0){
698
                score += s->coded_score[i];
699
                cbp |= 1 << (5 - i);
700
            }
701
        }
702
        
703
        if(cbp){
704
            int zero_score= -6;
705
            if ((motion_x | motion_y | s->dquant | mb_type) == 0){
706
                zero_score-= 4; //2*MV + mb_type + cbp bit
707
            }
708

    
709
            zero_score*= lambda;
710
            if(zero_score <= score){
711
                cbp=0;
712
            }
713
        }
714

    
715
        for (i = 0; i < 6; i++) {
716
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
717
                s->block_last_index[i]= -1;
718
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
719
            }
720
        }
721
    }else{
722
        for (i = 0; i < 6; i++) {
723
            if (s->block_last_index[i] >= 0)
724
                cbp |= 1 << (5 - i);
725
        }
726
    }
727
    return cbp;
728
}
729

    
730
void mpeg4_encode_mb(MpegEncContext * s,
731
                    DCTELEM block[6][64],
732
                    int motion_x, int motion_y)
733
{
734
    int cbpc, cbpy, pred_x, pred_y;
735
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
736
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
737
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
738
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
739
    const int dquant_code[5]= {1,0,9,2,3};
740
    
741
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
742
    if (!s->mb_intra) {
743
        int i, cbp;
744
        
745
        if(s->pict_type==B_TYPE){
746
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
747
            int mb_type=  mb_type_table[s->mv_dir];
748

    
749
            if(s->mb_x==0){
750
                for(i=0; i<2; i++){
751
                    s->last_mv[i][0][0]= 
752
                    s->last_mv[i][0][1]= 
753
                    s->last_mv[i][1][0]= 
754
                    s->last_mv[i][1][1]= 0;
755
                }
756
            }
757
            
758
            assert(s->dquant>=-2 && s->dquant<=2);
759
            assert((s->dquant&1)==0);
760
            assert(mb_type>=0);
761

    
762
            /* nothing to do if this MB was skiped in the next P Frame */
763
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
764
                s->skip_count++;
765
                s->mv[0][0][0]= 
766
                s->mv[0][0][1]= 
767
                s->mv[1][0][0]= 
768
                s->mv[1][0][1]= 0;
769
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
770
                s->qscale -= s->dquant;
771
//                s->mb_skiped=1;
772

    
773
                return;
774
            }
775
            
776
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
777
            
778
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
779
                /* direct MB with MV={0,0} */
780
                assert(s->dquant==0);
781
                
782
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
783

    
784
                if(interleaved_stats){
785
                    s->misc_bits++;
786
                    s->last_bits++;
787
                }
788
                s->skip_count++;
789
                return;
790
            }
791
            
792
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
793
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
794
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
795
            if(cbp) put_bits(&s->pb, 6, cbp);
796
            
797
            if(cbp && mb_type){
798
                if(s->dquant)
799
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
800
                else
801
                    put_bits(&s->pb, 1, 0);
802
            }else
803
                s->qscale -= s->dquant;
804
            
805
            if(!s->progressive_sequence){
806
                if(cbp)
807
                    put_bits(&s->pb, 1, s->interlaced_dct);
808
                if(mb_type) // not diect mode
809
                    put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
810
            }
811

    
812
            if(interleaved_stats){
813
                s->misc_bits+= get_bits_diff(s);
814
            }
815

    
816
            if(mb_type == 0){
817
                assert(s->mv_dir & MV_DIRECT);
818
                h263_encode_motion(s, motion_x, 1);
819
                h263_encode_motion(s, motion_y, 1);                
820
                s->b_count++;
821
                s->f_count++;
822
            }else{
823
                assert(mb_type > 0 && mb_type < 4);
824
                if(s->mv_type != MV_TYPE_FIELD){
825
                    if(s->mv_dir & MV_DIR_FORWARD){
826
                        h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
827
                        h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
828
                        s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
829
                        s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
830
                        s->f_count++;
831
                    }
832
                    if(s->mv_dir & MV_DIR_BACKWARD){
833
                        h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
834
                        h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
835
                        s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
836
                        s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
837
                        s->b_count++;
838
                    }
839
                }else{
840
                    if(s->mv_dir & MV_DIR_FORWARD){
841
                        put_bits(&s->pb, 1, s->field_select[0][0]);
842
                        put_bits(&s->pb, 1, s->field_select[0][1]);
843
                    }
844
                    if(s->mv_dir & MV_DIR_BACKWARD){
845
                        put_bits(&s->pb, 1, s->field_select[1][0]);
846
                        put_bits(&s->pb, 1, s->field_select[1][1]);
847
                    }
848
                    if(s->mv_dir & MV_DIR_FORWARD){
849
                        for(i=0; i<2; i++){
850
                            h263_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0]  , s->f_code);
851
                            h263_encode_motion(s, s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
852
                            s->last_mv[0][i][0]= s->mv[0][i][0];
853
                            s->last_mv[0][i][1]= s->mv[0][i][1]*2;
854
                        }
855
                        s->f_count++;
856
                    }
857
                    if(s->mv_dir & MV_DIR_BACKWARD){
858
                        for(i=0; i<2; i++){
859
                            h263_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0]  , s->b_code);
860
                            h263_encode_motion(s, s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
861
                            s->last_mv[1][i][0]= s->mv[1][i][0];
862
                            s->last_mv[1][i][1]= s->mv[1][i][1]*2;
863
                        }
864
                        s->b_count++;
865
                    }
866
                }
867
            }
868

    
869
            if(interleaved_stats){
870
                s->mv_bits+= get_bits_diff(s);
871
            }
872

    
873
            /* encode each block */
874
            for (i = 0; i < 6; i++) {
875
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
876
            }
877

    
878
            if(interleaved_stats){
879
                s->p_tex_bits+= get_bits_diff(s);
880
            }
881

    
882
        }else{ /* s->pict_type==B_TYPE */
883
            cbp= get_p_cbp(s, block, motion_x, motion_y);
884
        
885
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
886
                /* check if the B frames can skip it too, as we must skip it if we skip here 
887
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
888
                if(s->max_b_frames>0){
889
                    int i;
890
                    int x,y, offset;
891
                    uint8_t *p_pic;
892

    
893
                    x= s->mb_x*16;
894
                    y= s->mb_y*16;
895
                    if(x+16 > s->width)  x= s->width-16;
896
                    if(y+16 > s->height) y= s->height-16;
897

    
898
                    offset= x + y*s->linesize;
899
                    p_pic= s->new_picture.data[0] + offset;
900
                    
901
                    s->mb_skiped=1;
902
                    for(i=0; i<s->max_b_frames; i++){
903
                        uint8_t *b_pic;
904
                        int diff;
905
                        Picture *pic= s->reordered_input_picture[i+1];
906

    
907
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
908

    
909
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
910
                        diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
911
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
912
                            s->mb_skiped=0;
913
                            break;
914
                        }
915
                    }
916
                }else
917
                    s->mb_skiped=1; 
918

    
919
                if(s->mb_skiped==1){
920
                    /* skip macroblock */
921
                    put_bits(&s->pb, 1, 1);
922

    
923
                    if(interleaved_stats){
924
                        s->misc_bits++;
925
                        s->last_bits++;
926
                    }
927
                    s->skip_count++;
928
                    
929
                    return;
930
                }
931
            }
932

    
933
            put_bits(&s->pb, 1, 0);        /* mb coded */
934
            cbpc = cbp & 3;
935
            cbpy = cbp >> 2;
936
            cbpy ^= 0xf;
937
            if(s->mv_type==MV_TYPE_16X16){
938
                if(s->dquant) cbpc+= 8;
939
                put_bits(&s->pb,
940
                        inter_MCBPC_bits[cbpc],
941
                        inter_MCBPC_code[cbpc]);
942

    
943
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
944
                if(s->dquant)
945
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
946

    
947
                if(!s->progressive_sequence){
948
                    if(cbp)
949
                        put_bits(pb2, 1, s->interlaced_dct);
950
                    put_bits(pb2, 1, 0);
951
                }
952
                    
953
                if(interleaved_stats){
954
                    s->misc_bits+= get_bits_diff(s);
955
                }
956

    
957
                /* motion vectors: 16x16 mode */
958
                h263_pred_motion(s, 0, &pred_x, &pred_y);
959
            
960
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
961
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
962
            }else if(s->mv_type==MV_TYPE_FIELD){
963
                if(s->dquant) cbpc+= 8;
964
                put_bits(&s->pb,
965
                        inter_MCBPC_bits[cbpc],
966
                        inter_MCBPC_code[cbpc]);
967

    
968
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
969
                if(s->dquant)
970
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
971

    
972
                assert(!s->progressive_sequence);
973
                if(cbp)
974
                    put_bits(pb2, 1, s->interlaced_dct);
975
                put_bits(pb2, 1, 1);
976
                    
977
                if(interleaved_stats){
978
                    s->misc_bits+= get_bits_diff(s);
979
                }
980

    
981
                /* motion vectors: 16x8 interlaced mode */
982
                h263_pred_motion(s, 0, &pred_x, &pred_y);
983
                pred_y /=2;
984
                
985
                put_bits(&s->pb, 1, s->field_select[0][0]);
986
                put_bits(&s->pb, 1, s->field_select[0][1]);
987
            
988
                h263_encode_motion(s, s->mv[0][0][0] - pred_x, s->f_code);
989
                h263_encode_motion(s, s->mv[0][0][1] - pred_y, s->f_code);
990
                h263_encode_motion(s, s->mv[0][1][0] - pred_x, s->f_code);
991
                h263_encode_motion(s, s->mv[0][1][1] - pred_y, s->f_code);
992
            }else{
993
                assert(s->mv_type==MV_TYPE_8X8);
994
                put_bits(&s->pb,
995
                        inter_MCBPC_bits[cbpc+16],
996
                        inter_MCBPC_code[cbpc+16]);
997
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
998

    
999
                if(!s->progressive_sequence){
1000
                    if(cbp)
1001
                        put_bits(pb2, 1, s->interlaced_dct);
1002
                }
1003
    
1004
                if(interleaved_stats){
1005
                    s->misc_bits+= get_bits_diff(s);
1006
                }
1007

    
1008
                for(i=0; i<4; i++){
1009
                    /* motion vectors: 8x8 mode*/
1010
                    h263_pred_motion(s, i, &pred_x, &pred_y);
1011

    
1012
                    h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, s->f_code);
1013
                    h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1014
                }
1015
            }
1016

    
1017
            if(interleaved_stats){ 
1018
                s->mv_bits+= get_bits_diff(s);
1019
            }
1020

    
1021
            /* encode each block */
1022
            for (i = 0; i < 6; i++) {
1023
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
1024
            }
1025

    
1026
            if(interleaved_stats){
1027
                s->p_tex_bits+= get_bits_diff(s);
1028
            }
1029
            s->f_count++;
1030
        }
1031
    } else {
1032
        int cbp;
1033
        int dc_diff[6];   //dc values with the dc prediction subtracted 
1034
        int dir[6];  //prediction direction
1035
        int zigzag_last_index[6];
1036
        uint8_t *scan_table[6];
1037
        int i;
1038

    
1039
        for(i=0; i<6; i++){
1040
            const int level= block[i][0];
1041
            uint16_t *dc_ptr;
1042

    
1043
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
1044
            if (i < 4) {
1045
                *dc_ptr = level * s->y_dc_scale;
1046
            } else {
1047
                *dc_ptr = level * s->c_dc_scale;
1048
            }
1049
        }
1050

    
1051
        if(s->flags & CODEC_FLAG_AC_PRED){
1052
            s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1053
            if(!s->ac_pred)
1054
                restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1055
        }else{
1056
            for(i=0; i<6; i++)
1057
                scan_table[i]= s->intra_scantable.permutated;
1058
        }
1059

    
1060
        /* compute cbp */
1061
        cbp = 0;
1062
        for (i = 0; i < 6; i++) {
1063
            if (s->block_last_index[i] >= 1)
1064
                cbp |= 1 << (5 - i);
1065
        }
1066

    
1067
        cbpc = cbp & 3;
1068
        if (s->pict_type == I_TYPE) {
1069
            if(s->dquant) cbpc+=4;
1070
            put_bits(&s->pb,
1071
                intra_MCBPC_bits[cbpc],
1072
                intra_MCBPC_code[cbpc]);
1073
        } else {
1074
            if(s->dquant) cbpc+=8;
1075
            put_bits(&s->pb, 1, 0);        /* mb coded */
1076
            put_bits(&s->pb,
1077
                inter_MCBPC_bits[cbpc + 4],
1078
                inter_MCBPC_code[cbpc + 4]);
1079
        }
1080
        put_bits(pb2, 1, s->ac_pred);
1081
        cbpy = cbp >> 2;
1082
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1083
        if(s->dquant)
1084
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1085

    
1086
        if(!s->progressive_sequence){
1087
            put_bits(dc_pb, 1, s->interlaced_dct);
1088
        }
1089

    
1090
        if(interleaved_stats){
1091
            s->misc_bits+= get_bits_diff(s);
1092
        }
1093

    
1094
        /* encode each block */
1095
        for (i = 0; i < 6; i++) {
1096
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
1097
        }
1098

    
1099
        if(interleaved_stats){
1100
            s->i_tex_bits+= get_bits_diff(s);
1101
        }
1102
        s->i_count++;
1103

    
1104
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1105
        if(s->ac_pred)
1106
            restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1107
    }
1108
}
1109

    
1110
void h263_encode_mb(MpegEncContext * s,
1111
                    DCTELEM block[6][64],
1112
                    int motion_x, int motion_y)
1113
{
1114
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
1115
    int16_t pred_dc;
1116
    int16_t rec_intradc[6];
1117
    uint16_t *dc_ptr[6];
1118
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1119
    const int dquant_code[5]= {1,0,9,2,3};
1120
           
1121
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1122
    if (!s->mb_intra) {
1123
        /* compute cbp */
1124
        cbp= get_p_cbp(s, block, motion_x, motion_y);
1125

    
1126
        if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1127
            /* skip macroblock */
1128
            put_bits(&s->pb, 1, 1);
1129
            if(interleaved_stats){
1130
                s->misc_bits++;
1131
                s->last_bits++;
1132
            }
1133
            s->skip_count++;
1134

    
1135
            return;
1136
        }
1137
        put_bits(&s->pb, 1, 0);        /* mb coded */
1138
        
1139
        cbpc = cbp & 3;
1140
        cbpy = cbp >> 2;
1141
        if(s->alt_inter_vlc==0 || cbpc!=3)
1142
            cbpy ^= 0xF;
1143
        if(s->dquant) cbpc+= 8;
1144
        if(s->mv_type==MV_TYPE_16X16){
1145
            put_bits(&s->pb,
1146
                    inter_MCBPC_bits[cbpc],
1147
                    inter_MCBPC_code[cbpc]);
1148

    
1149
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1150
            if(s->dquant)
1151
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1152
                
1153
            if(interleaved_stats){
1154
                s->misc_bits+= get_bits_diff(s);
1155
            }
1156

    
1157
            /* motion vectors: 16x16 mode */
1158
            h263_pred_motion(s, 0, &pred_x, &pred_y);
1159
            
1160
            if (!s->umvplus) {  
1161
                h263_encode_motion(s, motion_x - pred_x, 1);
1162
                h263_encode_motion(s, motion_y - pred_y, 1);
1163
            }
1164
            else {
1165
                h263p_encode_umotion(s, motion_x - pred_x);
1166
                h263p_encode_umotion(s, motion_y - pred_y);
1167
                if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1168
                    /* To prevent Start Code emulation */
1169
                    put_bits(&s->pb,1,1);
1170
            }
1171
        }else{
1172
            put_bits(&s->pb,
1173
                    inter_MCBPC_bits[cbpc+16],
1174
                    inter_MCBPC_code[cbpc+16]);
1175
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1176
            if(s->dquant)
1177
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1178

    
1179
            if(interleaved_stats){
1180
                s->misc_bits+= get_bits_diff(s);
1181
            }
1182

    
1183
            for(i=0; i<4; i++){
1184
                /* motion vectors: 8x8 mode*/
1185
                h263_pred_motion(s, i, &pred_x, &pred_y);
1186

    
1187
                motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1188
                motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1189
                if (!s->umvplus) {  
1190
                    h263_encode_motion(s, motion_x - pred_x, 1);
1191
                    h263_encode_motion(s, motion_y - pred_y, 1);
1192
                }
1193
                else {
1194
                    h263p_encode_umotion(s, motion_x - pred_x);
1195
                    h263p_encode_umotion(s, motion_y - pred_y);
1196
                    if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1197
                        /* To prevent Start Code emulation */
1198
                        put_bits(&s->pb,1,1);
1199
                }
1200
            }
1201
        }
1202

    
1203
        if(interleaved_stats){
1204
            s->mv_bits+= get_bits_diff(s);
1205
        }
1206
    } else {
1207
        assert(s->mb_intra);
1208
        
1209
        cbp = 0;
1210
        if (s->h263_aic) {
1211
            /* Predict DC */
1212
            for(i=0; i<6; i++) {
1213
                int16_t level = block[i][0];
1214
                int scale;
1215
                
1216
                if(i<4) scale= s->y_dc_scale;
1217
                else    scale= s->c_dc_scale;
1218

    
1219
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1220
                level -= pred_dc;
1221
                /* Quant */
1222
                if (level >= 0)
1223
                    level = (level + (scale>>1))/scale;
1224
                else
1225
                    level = (level - (scale>>1))/scale;
1226
                    
1227
                /* AIC can change CBP */
1228
                if (level == 0 && s->block_last_index[i] == 0)
1229
                    s->block_last_index[i] = -1;
1230

    
1231
                if(!s->modified_quant){
1232
                    if (level < -127)
1233
                        level = -127;
1234
                    else if (level > 127)
1235
                        level = 127;
1236
                }
1237

    
1238
                block[i][0] = level;
1239
                /* Reconstruction */ 
1240
                rec_intradc[i] = scale*level + pred_dc;
1241
                /* Oddify */
1242
                rec_intradc[i] |= 1;
1243
                //if ((rec_intradc[i] % 2) == 0)
1244
                //    rec_intradc[i]++;
1245
                /* Clipping */
1246
                if (rec_intradc[i] < 0)
1247
                    rec_intradc[i] = 0;
1248
                else if (rec_intradc[i] > 2047)
1249
                    rec_intradc[i] = 2047;
1250
                                
1251
                /* Update AC/DC tables */
1252
                *dc_ptr[i] = rec_intradc[i];
1253
                if (s->block_last_index[i] >= 0)
1254
                    cbp |= 1 << (5 - i);
1255
            }
1256
        }else{
1257
            for(i=0; i<6; i++) {
1258
                /* compute cbp */
1259
                if (s->block_last_index[i] >= 1)
1260
                    cbp |= 1 << (5 - i);
1261
            }
1262
        }
1263

    
1264
        cbpc = cbp & 3;
1265
        if (s->pict_type == I_TYPE) {
1266
            if(s->dquant) cbpc+=4;
1267
            put_bits(&s->pb,
1268
                intra_MCBPC_bits[cbpc],
1269
                intra_MCBPC_code[cbpc]);
1270
        } else {
1271
            if(s->dquant) cbpc+=8;
1272
            put_bits(&s->pb, 1, 0);        /* mb coded */
1273
            put_bits(&s->pb,
1274
                inter_MCBPC_bits[cbpc + 4],
1275
                inter_MCBPC_code[cbpc + 4]);
1276
        }
1277
        if (s->h263_aic) {
1278
            /* XXX: currently, we do not try to use ac prediction */
1279
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
1280
        }
1281
        cbpy = cbp >> 2;
1282
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1283
        if(s->dquant)
1284
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1285

    
1286
        if(interleaved_stats){
1287
            s->misc_bits+= get_bits_diff(s);
1288
        }
1289
    }
1290

    
1291
    for(i=0; i<6; i++) {
1292
        /* encode each block */
1293
        h263_encode_block(s, block[i], i);
1294
    
1295
        /* Update INTRADC for decoding */
1296
        if (s->h263_aic && s->mb_intra) {
1297
            block[i][0] = rec_intradc[i];
1298
            
1299
        }
1300
    }
1301

    
1302
    if(interleaved_stats){
1303
        if (!s->mb_intra) {
1304
            s->p_tex_bits+= get_bits_diff(s);
1305
            s->f_count++;
1306
        }else{
1307
            s->i_tex_bits+= get_bits_diff(s);
1308
            s->i_count++;
1309
        }
1310
    }
1311
}
1312
#endif
1313

    
1314
void ff_h263_loop_filter(MpegEncContext * s){
1315
    int qp_c;
1316
    const int linesize  = s->linesize;
1317
    const int uvlinesize= s->uvlinesize;
1318
    const int xy = s->mb_y * s->mb_stride + s->mb_x;
1319
    uint8_t *dest_y = s->dest[0];
1320
    uint8_t *dest_cb= s->dest[1];
1321
    uint8_t *dest_cr= s->dest[2];
1322
    
1323
//    if(s->pict_type==B_TYPE && !s->readable) return;
1324

    
1325
    /*
1326
       Diag Top
1327
       Left Center
1328
    */
1329
    if(!IS_SKIP(s->current_picture.mb_type[xy])){
1330
        qp_c= s->qscale;
1331
        s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
1332
        s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1333
    }else
1334
        qp_c= 0;
1335

    
1336
    if(s->mb_y){
1337
        int qp_dt, qp_t, qp_tc;
1338

    
1339
        if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1340
            qp_t=0;
1341
        else 
1342
            qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1343

    
1344
        if(qp_c) 
1345
            qp_tc= qp_c;
1346
        else
1347
            qp_tc= qp_t;
1348
            
1349
        if(qp_tc){
1350
            const int chroma_qp= s->chroma_qscale_table[qp_tc];
1351
            s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
1352
            s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
1353
        
1354
            s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1355
            s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1356
        }
1357
        
1358
        if(qp_t)
1359
            s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_t);
1360
        
1361
        if(s->mb_x){
1362
            if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1363
                qp_dt= qp_t;
1364
            else
1365
                qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1366
            
1367
            if(qp_dt){
1368
                const int chroma_qp= s->chroma_qscale_table[qp_dt];
1369
                s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
1370
                s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1371
                s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1372
            }
1373
        }
1374
    }
1375

    
1376
    if(qp_c){
1377
        s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
1378
        if(s->mb_y + 1 == s->mb_height)
1379
            s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
1380
    }
1381
    
1382
    if(s->mb_x){
1383
        int qp_lc;
1384
        if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1385
            qp_lc= qp_c;
1386
        else
1387
            qp_lc= s->current_picture.qscale_table[xy-1];
1388
        
1389
        if(qp_lc){
1390
            s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
1391
            if(s->mb_y + 1 == s->mb_height){
1392
                const int chroma_qp= s->chroma_qscale_table[qp_lc];
1393
                s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
1394
                s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
1395
                s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
1396
            }
1397
        }
1398
    }
1399
}
1400

    
1401
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1402
{
1403
    int x, y, wrap, a, c, pred_dc, scale;
1404
    int16_t *dc_val, *ac_val;
1405

    
1406
    /* find prediction */
1407
    if (n < 4) {
1408
        x = 2 * s->mb_x + 1 + (n & 1);
1409
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1410
        wrap = s->mb_width * 2 + 2;
1411
        dc_val = s->dc_val[0];
1412
        ac_val = s->ac_val[0][0];
1413
        scale = s->y_dc_scale;
1414
    } else {
1415
        x = s->mb_x + 1;
1416
        y = s->mb_y + 1;
1417
        wrap = s->mb_width + 2;
1418
        dc_val = s->dc_val[n - 4 + 1];
1419
        ac_val = s->ac_val[n - 4 + 1][0];
1420
        scale = s->c_dc_scale;
1421
    }
1422
    /* B C
1423
     * A X 
1424
     */
1425
    a = dc_val[(x - 1) + (y) * wrap];
1426
    c = dc_val[(x) + (y - 1) * wrap];
1427
    
1428
    /* No prediction outside GOB boundary */
1429
    if (s->first_slice_line && ((n < 2) || (n > 3)))
1430
        c = 1024;
1431
    pred_dc = 1024;
1432
    /* just DC prediction */
1433
    if (a != 1024 && c != 1024)
1434
        pred_dc = (a + c) >> 1;
1435
    else if (a != 1024)
1436
        pred_dc = a;
1437
    else
1438
        pred_dc = c;
1439
    
1440
    /* we assume pred is positive */
1441
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1442
    *dc_val_ptr = &dc_val[x + y * wrap];
1443
    return pred_dc;
1444
}
1445

    
1446
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1447
{
1448
    int x, y, wrap, a, c, pred_dc, scale, i;
1449
    int16_t *dc_val, *ac_val, *ac_val1;
1450

    
1451
    /* find prediction */
1452
    if (n < 4) {
1453
        x = 2 * s->mb_x + 1 + (n & 1);
1454
        y = 2 * s->mb_y + 1 + (n>> 1);
1455
        wrap = s->mb_width * 2 + 2;
1456
        dc_val = s->dc_val[0];
1457
        ac_val = s->ac_val[0][0];
1458
        scale = s->y_dc_scale;
1459
    } else {
1460
        x = s->mb_x + 1;
1461
        y = s->mb_y + 1;
1462
        wrap = s->mb_width + 2;
1463
        dc_val = s->dc_val[n - 4 + 1];
1464
        ac_val = s->ac_val[n - 4 + 1][0];
1465
        scale = s->c_dc_scale;
1466
    }
1467
    
1468
    ac_val += ((y) * wrap + (x)) * 16;
1469
    ac_val1 = ac_val;
1470
    
1471
    /* B C
1472
     * A X 
1473
     */
1474
    a = dc_val[(x - 1) + (y) * wrap];
1475
    c = dc_val[(x) + (y - 1) * wrap];
1476
    
1477
    /* No prediction outside GOB boundary */
1478
    if(s->first_slice_line && n!=3){
1479
        if(n!=2) c= 1024;
1480
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1481
    }
1482
    
1483
    if (s->ac_pred) {
1484
        pred_dc = 1024;
1485
        if (s->h263_aic_dir) {
1486
            /* left prediction */
1487
            if (a != 1024) {
1488
                ac_val -= 16;
1489
                for(i=1;i<8;i++) {
1490
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1491
                }
1492
                pred_dc = a;
1493
            }
1494
        } else {
1495
            /* top prediction */
1496
            if (c != 1024) {
1497
                ac_val -= 16 * wrap;
1498
                for(i=1;i<8;i++) {
1499
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1500
                }
1501
                pred_dc = c;
1502
            }
1503
        }
1504
    } else {
1505
        /* just DC prediction */
1506
        if (a != 1024 && c != 1024)
1507
            pred_dc = (a + c) >> 1;
1508
        else if (a != 1024)
1509
            pred_dc = a;
1510
        else
1511
            pred_dc = c;
1512
    }
1513
    
1514
    /* we assume pred is positive */
1515
    block[0]=block[0]*scale + pred_dc;
1516
    
1517
    if (block[0] < 0)
1518
        block[0] = 0;
1519
    else 
1520
        block[0] |= 1;
1521
    
1522
    /* Update AC/DC tables */
1523
    dc_val[(x) + (y) * wrap] = block[0];
1524
    
1525
    /* left copy */
1526
    for(i=1;i<8;i++)
1527
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1528
    /* top copy */
1529
    for(i=1;i<8;i++)
1530
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1531
}
1532

    
1533
int16_t *h263_pred_motion(MpegEncContext * s, int block, 
1534
                        int *px, int *py)
1535
{
1536
    int xy, wrap;
1537
    int16_t *A, *B, *C, *mot_val;
1538
    static const int off[4]= {2, 1, 1, -1};
1539

    
1540
    wrap = s->block_wrap[0];
1541
    xy = s->block_index[block];
1542

    
1543
    mot_val = s->current_picture.motion_val[0][xy];
1544

    
1545
    A = s->current_picture.motion_val[0][xy - 1];
1546
    /* special case for first (slice) line */
1547
    if (s->first_slice_line && block<3) {
1548
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1549
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1550
        if(block==0){ //most common case
1551
            if(s->mb_x  == s->resync_mb_x){ //rare
1552
                *px= *py = 0;
1553
            }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1554
                C = s->current_picture.motion_val[0][xy + off[block] - wrap];
1555
                if(s->mb_x==0){
1556
                    *px = C[0];
1557
                    *py = C[1];
1558
                }else{
1559
                    *px = mid_pred(A[0], 0, C[0]);
1560
                    *py = mid_pred(A[1], 0, C[1]);
1561
                }
1562
            }else{
1563
                *px = A[0];
1564
                *py = A[1];
1565
            }
1566
        }else if(block==1){
1567
            if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1568
                C = s->current_picture.motion_val[0][xy + off[block] - wrap];
1569
                *px = mid_pred(A[0], 0, C[0]);
1570
                *py = mid_pred(A[1], 0, C[1]);
1571
            }else{
1572
                *px = A[0];
1573
                *py = A[1];
1574
            }
1575
        }else{ /* block==2*/
1576
            B = s->current_picture.motion_val[0][xy - wrap];
1577
            C = s->current_picture.motion_val[0][xy + off[block] - wrap];
1578
            if(s->mb_x == s->resync_mb_x) //rare
1579
                A[0]=A[1]=0;
1580
    
1581
            *px = mid_pred(A[0], B[0], C[0]);
1582
            *py = mid_pred(A[1], B[1], C[1]);
1583
        }
1584
    } else {
1585
        B = s->current_picture.motion_val[0][xy - wrap];
1586
        C = s->current_picture.motion_val[0][xy + off[block] - wrap];
1587
        *px = mid_pred(A[0], B[0], C[0]);
1588
        *py = mid_pred(A[1], B[1], C[1]);
1589
    }
1590
    return mot_val;
1591
}
1592

    
1593
// identical to above but with s->current_picture->motion_val, the above one will be removed, and this renamed to it
1594
int16_t *h263_pred_motion2(MpegEncContext * s, int block, int dir,
1595
                        int *px, int *py)
1596
{
1597
    int xy, wrap;
1598
    int16_t *A, *B, *C, (*mot_val)[2];
1599
    static const int off[4]= {2, 1, 1, -1};
1600

    
1601
    wrap = s->b8_stride;
1602
    xy = 2*(s->mb_x + s->mb_y * wrap);
1603

    
1604
    mot_val = s->current_picture.motion_val[dir] + xy;
1605

    
1606
    A = mot_val[ - 1];
1607
    /* special case for first (slice) line */
1608
    if (s->first_slice_line && block<3) {
1609
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1610
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1611
        if(block==0){ //most common case
1612
            if(s->mb_x  == s->resync_mb_x){ //rare
1613
                *px= *py = 0;
1614
            }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1615
                C = mot_val[off[block] - wrap];
1616
                if(s->mb_x==0){
1617
                    *px = C[0];
1618
                    *py = C[1];
1619
                }else{
1620
                    *px = mid_pred(A[0], 0, C[0]);
1621
                    *py = mid_pred(A[1], 0, C[1]);
1622
                }
1623
            }else{
1624
                *px = A[0];
1625
                *py = A[1];
1626
            }
1627
        }else if(block==1){
1628
            if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1629
                C = mot_val[off[block] - wrap];
1630
                *px = mid_pred(A[0], 0, C[0]);
1631
                *py = mid_pred(A[1], 0, C[1]);
1632
            }else{
1633
                *px = A[0];
1634
                *py = A[1];
1635
            }
1636
        }else{ /* block==2*/
1637
            B = mot_val[ - wrap];
1638
            C = mot_val[off[block] - wrap];
1639
            if(s->mb_x == s->resync_mb_x) //rare
1640
                A[0]=A[1]=0;
1641
    
1642
            *px = mid_pred(A[0], B[0], C[0]);
1643
            *py = mid_pred(A[1], B[1], C[1]);
1644
        }
1645
    } else {
1646
        B = mot_val[ - wrap];
1647
        C = mot_val[off[block] - wrap];
1648
        *px = mid_pred(A[0], B[0], C[0]);
1649
        *py = mid_pred(A[1], B[1], C[1]);
1650
    }
1651
    return *mot_val;
1652
}
1653

    
1654
#ifdef CONFIG_ENCODERS
1655
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1656
{
1657
    int range, l, bit_size, sign, code, bits;
1658

    
1659
    if (val == 0) {
1660
        /* zero vector */
1661
        code = 0;
1662
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1663
    } else {
1664
        bit_size = f_code - 1;
1665
        range = 1 << bit_size;
1666
        /* modulo encoding */
1667
        l = range * 32;
1668
#if 1
1669
        val+= l;
1670
        val&= 2*l-1;
1671
        val-= l;
1672
        sign = val>>31;
1673
        val= (val^sign)-sign;
1674
        sign&=1;
1675
#else
1676
        if (val < -l) {
1677
            val += 2*l;
1678
        } else if (val >= l) {
1679
            val -= 2*l;
1680
        }
1681

    
1682
        assert(val>=-l && val<l);
1683

    
1684
        if (val >= 0) {
1685
            sign = 0;
1686
        } else {
1687
            val = -val;
1688
            sign = 1;
1689
        }
1690
#endif
1691
        val--;
1692
        code = (val >> bit_size) + 1;
1693
        bits = val & (range - 1);
1694

    
1695
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1696
        if (bit_size > 0) {
1697
            put_bits(&s->pb, bit_size, bits);
1698
        }
1699
    }
1700

    
1701
}
1702

    
1703
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1704
static void h263p_encode_umotion(MpegEncContext * s, int val)
1705
{
1706
    short sval = 0; 
1707
    short i = 0;
1708
    short n_bits = 0;
1709
    short temp_val;
1710
    int code = 0;
1711
    int tcode;
1712
    
1713
    if ( val == 0)
1714
        put_bits(&s->pb, 1, 1);
1715
    else if (val == 1)
1716
        put_bits(&s->pb, 3, 0);
1717
    else if (val == -1)
1718
        put_bits(&s->pb, 3, 2);
1719
    else {
1720
        
1721
        sval = ((val < 0) ? (short)(-val):(short)val);
1722
        temp_val = sval;
1723
        
1724
        while (temp_val != 0) {
1725
            temp_val = temp_val >> 1;
1726
            n_bits++;
1727
        }
1728
        
1729
        i = n_bits - 1;
1730
        while (i > 0) {
1731
            tcode = (sval & (1 << (i-1))) >> (i-1);
1732
            tcode = (tcode << 1) | 1;
1733
            code = (code << 2) | tcode;
1734
            i--;
1735
        }
1736
        code = ((code << 1) | (val < 0)) << 1;
1737
        put_bits(&s->pb, (2*n_bits)+1, code);
1738
        //printf("\nVal = %d\tCode = %d", sval, code);
1739
    }
1740
}
1741

    
1742
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1743
{
1744
    int f_code;
1745
    int mv;
1746
    
1747
    if(mv_penalty==NULL)
1748
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1749
    
1750
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1751
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1752
            int len;
1753

    
1754
            if(mv==0) len= mvtab[0][1];
1755
            else{
1756
                int val, bit_size, range, code;
1757

    
1758
                bit_size = s->f_code - 1;
1759
                range = 1 << bit_size;
1760

    
1761
                val=mv;
1762
                if (val < 0) 
1763
                    val = -val;
1764
                val--;
1765
                code = (val >> bit_size) + 1;
1766
                if(code<33){
1767
                    len= mvtab[code][1] + 1 + bit_size;
1768
                }else{
1769
                    len= mvtab[32][1] + 2 + bit_size;
1770
                }
1771
            }
1772

    
1773
            mv_penalty[f_code][mv+MAX_MV]= len;
1774
        }
1775
    }
1776

    
1777
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1778
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1779
            fcode_tab[mv+MAX_MV]= f_code;
1780
        }
1781
    }
1782

    
1783
    for(mv=0; mv<MAX_MV*2+1; mv++){
1784
        umv_fcode_tab[mv]= 1;
1785
    }
1786
}
1787
#endif
1788

    
1789
#ifdef CONFIG_ENCODERS
1790

    
1791
static void init_uni_dc_tab(void)
1792
{
1793
    int level, uni_code, uni_len;
1794

    
1795
    for(level=-256; level<256; level++){
1796
        int size, v, l;
1797
        /* find number of bits */
1798
        size = 0;
1799
        v = abs(level);
1800
        while (v) {
1801
            v >>= 1;
1802
            size++;
1803
        }
1804

    
1805
        if (level < 0)
1806
            l= (-level) ^ ((1 << size) - 1);
1807
        else
1808
            l= level;
1809

    
1810
        /* luminance */
1811
        uni_code= DCtab_lum[size][0];
1812
        uni_len = DCtab_lum[size][1];
1813

    
1814
        if (size > 0) {
1815
            uni_code<<=size; uni_code|=l;
1816
            uni_len+=size;
1817
            if (size > 8){
1818
                uni_code<<=1; uni_code|=1;
1819
                uni_len++;
1820
            }
1821
        }
1822
        uni_DCtab_lum_bits[level+256]= uni_code;
1823
        uni_DCtab_lum_len [level+256]= uni_len;
1824

    
1825
        /* chrominance */
1826
        uni_code= DCtab_chrom[size][0];
1827
        uni_len = DCtab_chrom[size][1];
1828
        
1829
        if (size > 0) {
1830
            uni_code<<=size; uni_code|=l;
1831
            uni_len+=size;
1832
            if (size > 8){
1833
                uni_code<<=1; uni_code|=1;
1834
                uni_len++;
1835
            }
1836
        }
1837
        uni_DCtab_chrom_bits[level+256]= uni_code;
1838
        uni_DCtab_chrom_len [level+256]= uni_len;
1839

    
1840
    }
1841
}
1842

    
1843
#endif //CONFIG_ENCODERS
1844

    
1845
#ifdef CONFIG_ENCODERS
1846
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1847
    int slevel, run, last;
1848
    
1849
    assert(MAX_LEVEL >= 64);
1850
    assert(MAX_RUN   >= 63);
1851

    
1852
    for(slevel=-64; slevel<64; slevel++){
1853
        if(slevel==0) continue;
1854
        for(run=0; run<64; run++){
1855
            for(last=0; last<=1; last++){
1856
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1857
                int level= slevel < 0 ? -slevel : slevel;
1858
                int sign= slevel < 0 ? 1 : 0;
1859
                int bits, len, code;
1860
                int level1, run1;
1861
                
1862
                len_tab[index]= 100;
1863
                     
1864
                /* ESC0 */
1865
                code= get_rl_index(rl, last, run, level);
1866
                bits= rl->table_vlc[code][0];
1867
                len=  rl->table_vlc[code][1];
1868
                bits=bits*2+sign; len++;
1869
                
1870
                if(code!=rl->n && len < len_tab[index]){
1871
                    bits_tab[index]= bits;
1872
                    len_tab [index]= len;
1873
                }
1874
#if 1
1875
                /* ESC1 */
1876
                bits= rl->table_vlc[rl->n][0];
1877
                len=  rl->table_vlc[rl->n][1];
1878
                bits=bits*2;    len++; //esc1
1879
                level1= level - rl->max_level[last][run];
1880
                if(level1>0){
1881
                    code= get_rl_index(rl, last, run, level1);
1882
                    bits<<= rl->table_vlc[code][1];
1883
                    len  += rl->table_vlc[code][1];
1884
                    bits += rl->table_vlc[code][0];
1885
                    bits=bits*2+sign; len++;
1886
                
1887
                    if(code!=rl->n && len < len_tab[index]){
1888
                        bits_tab[index]= bits;
1889
                        len_tab [index]= len;
1890
                    }
1891
                }
1892
#endif 
1893
#if 1
1894
                /* ESC2 */
1895
                bits= rl->table_vlc[rl->n][0];
1896
                len=  rl->table_vlc[rl->n][1];
1897
                bits=bits*4+2;    len+=2; //esc2
1898
                run1 = run - rl->max_run[last][level] - 1;
1899
                if(run1>=0){
1900
                    code= get_rl_index(rl, last, run1, level);
1901
                    bits<<= rl->table_vlc[code][1];
1902
                    len  += rl->table_vlc[code][1];
1903
                    bits += rl->table_vlc[code][0];
1904
                    bits=bits*2+sign; len++;
1905
                
1906
                    if(code!=rl->n && len < len_tab[index]){
1907
                        bits_tab[index]= bits;
1908
                        len_tab [index]= len;
1909
                    }
1910
                }
1911
#endif           
1912
                /* ESC3 */        
1913
                bits= rl->table_vlc[rl->n][0];
1914
                len = rl->table_vlc[rl->n][1];
1915
                bits=bits*4+3;    len+=2; //esc3
1916
                bits=bits*2+last; len++;
1917
                bits=bits*64+run; len+=6;
1918
                bits=bits*2+1;    len++;  //marker
1919
                bits=bits*4096+(slevel&0xfff); len+=12;
1920
                bits=bits*2+1;    len++;  //marker
1921
                
1922
                if(len < len_tab[index]){
1923
                    bits_tab[index]= bits;
1924
                    len_tab [index]= len;
1925
                }
1926
            }
1927
        }
1928
    }
1929
}
1930

    
1931
void h263_encode_init(MpegEncContext *s)
1932
{
1933
    static int done = 0;
1934

    
1935
    if (!done) {
1936
        done = 1;
1937

    
1938
        init_uni_dc_tab();
1939

    
1940
        init_rl(&rl_inter);
1941
        init_rl(&rl_intra);
1942
        init_rl(&rl_intra_aic);
1943
        
1944
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1945
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1946

    
1947
        init_mv_penalty_and_fcode(s);
1948
    }
1949
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1950
    
1951
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1952
    switch(s->codec_id){
1953
    case CODEC_ID_MPEG4:
1954
        s->fcode_tab= fcode_tab;
1955
        s->min_qcoeff= -2048;
1956
        s->max_qcoeff=  2047;
1957
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1958
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1959
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1960
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1961
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
1962
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1963
        s->ac_esc_length= 7+2+1+6+1+12+1;
1964
        s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
1965
        s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1966

    
1967
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1968

    
1969
            s->avctx->extradata= av_malloc(1024);
1970
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
1971
            
1972
            mpeg4_encode_visual_object_header(s);
1973
            mpeg4_encode_vol_header(s, 0, 0);
1974

    
1975
//            ff_mpeg4_stuffing(&s->pb); ?
1976
            flush_put_bits(&s->pb);
1977
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
1978
        }
1979
        
1980
        break;
1981
    case CODEC_ID_H263P:
1982
        if(s->umvplus)
1983
            s->fcode_tab= umv_fcode_tab;
1984
        if(s->modified_quant){
1985
            s->min_qcoeff= -2047;
1986
            s->max_qcoeff=  2047;
1987
        }else{
1988
            s->min_qcoeff= -127;
1989
            s->max_qcoeff=  127;
1990
        }
1991
        break;
1992
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1993
    case CODEC_ID_FLV1:
1994
        if (s->h263_flv > 1) {
1995
            s->min_qcoeff= -1023;
1996
            s->max_qcoeff=  1023;
1997
        } else {
1998
            s->min_qcoeff= -127;
1999
            s->max_qcoeff=  127;
2000
        }
2001
        s->y_dc_scale_table=
2002
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2003
        break;
2004
    default: //nothing needed default table allready set in mpegvideo.c
2005
        s->min_qcoeff= -127;
2006
        s->max_qcoeff=  127;
2007
        s->y_dc_scale_table=
2008
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2009
    }
2010
}
2011

    
2012
/**
2013
 * encodes a 8x8 block.
2014
 * @param block the 8x8 block
2015
 * @param n block index (0-3 are luma, 4-5 are chroma)
2016
 */
2017
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2018
{
2019
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2020
    RLTable *rl;
2021

    
2022
    rl = &rl_inter;
2023
    if (s->mb_intra && !s->h263_aic) {
2024
        /* DC coef */
2025
        level = block[0];
2026
        /* 255 cannot be represented, so we clamp */
2027
        if (level > 254) {
2028
            level = 254;
2029
            block[0] = 254;
2030
        }
2031
        /* 0 cannot be represented also */
2032
        else if (level < 1) {
2033
            level = 1;
2034
            block[0] = 1;
2035
        }
2036
        if (level == 128) //FIXME check rv10
2037
            put_bits(&s->pb, 8, 0xff);
2038
        else
2039
            put_bits(&s->pb, 8, level);
2040
        i = 1;
2041
    } else {
2042
        i = 0;
2043
        if (s->h263_aic && s->mb_intra)
2044
            rl = &rl_intra_aic;
2045
            
2046
        if(s->alt_inter_vlc && !s->mb_intra){
2047
            int aic_vlc_bits=0;
2048
            int inter_vlc_bits=0;
2049
            int wrong_pos=-1;
2050
            int aic_code;
2051
            
2052
            last_index = s->block_last_index[n];
2053
            last_non_zero = i - 1;
2054
            for (; i <= last_index; i++) {
2055
                j = s->intra_scantable.permutated[i];
2056
                level = block[j];
2057
                if (level) {
2058
                    run = i - last_non_zero - 1;
2059
                    last = (i == last_index);
2060
                    
2061
                    if(level<0) level= -level;
2062
                
2063
                    code = get_rl_index(rl, last, run, level);
2064
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2065
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2066
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2067

    
2068
                    if (code == rl->n) {
2069
                        inter_vlc_bits += 1+6+8-1;
2070
                    }                
2071
                    if (aic_code == rl_intra_aic.n) {
2072
                        aic_vlc_bits += 1+6+8-1;
2073
                        wrong_pos += run + 1;
2074
                    }else
2075
                        wrong_pos += wrong_run[aic_code];
2076
                    last_non_zero = i;
2077
                }    
2078
            }
2079
            i = 0;
2080
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2081
                rl = &rl_intra_aic;
2082
        }
2083
    }
2084
   
2085
    /* AC coefs */
2086
    last_index = s->block_last_index[n];
2087
    last_non_zero = i - 1;
2088
    for (; i <= last_index; i++) {
2089
        j = s->intra_scantable.permutated[i];
2090
        level = block[j];
2091
        if (level) {
2092
            run = i - last_non_zero - 1;
2093
            last = (i == last_index);
2094
            sign = 0;
2095
            slevel = level;
2096
            if (level < 0) {
2097
                sign = 1;
2098
                level = -level;
2099
            }
2100
            code = get_rl_index(rl, last, run, level);
2101
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2102
            if (code == rl->n) {
2103
              if(s->h263_flv <= 1){
2104
                put_bits(&s->pb, 1, last);
2105
                put_bits(&s->pb, 6, run);
2106
                
2107
                assert(slevel != 0);
2108

    
2109
                if(level < 128) 
2110
                    put_bits(&s->pb, 8, slevel & 0xff);
2111
                else{
2112
                    put_bits(&s->pb, 8, 128);
2113
                    put_bits(&s->pb, 5, slevel & 0x1f);
2114
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2115
                }
2116
              }else{
2117
                if(level < 64) { // 7-bit level
2118
                        put_bits(&s->pb, 1, 0);
2119
                        put_bits(&s->pb, 1, last);
2120
                        put_bits(&s->pb, 6, run);
2121

    
2122
                        put_bits(&s->pb, 7, slevel & 0x7f);
2123
                    } else {
2124
                        /* 11-bit level */
2125
                        put_bits(&s->pb, 1, 1);
2126
                        put_bits(&s->pb, 1, last);
2127
                        put_bits(&s->pb, 6, run);
2128

    
2129
                        put_bits(&s->pb, 11, slevel & 0x7ff);
2130
                    }
2131
              }
2132
            } else {
2133
                put_bits(&s->pb, 1, sign);
2134
            }
2135
            last_non_zero = i;
2136
        }
2137
    }
2138
}
2139
#endif
2140

    
2141
#ifdef CONFIG_ENCODERS
2142

    
2143
/***************************************************/
2144
/**
2145
 * add mpeg4 stuffing bits (01...1)
2146
 */
2147
void ff_mpeg4_stuffing(PutBitContext * pbc)
2148
{
2149
    int length;
2150
    put_bits(pbc, 1, 0);
2151
    length= (-put_bits_count(pbc))&7;
2152
    if(length) put_bits(pbc, length, (1<<length)-1);
2153
}
2154

    
2155
/* must be called before writing the header */
2156
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2157
    int time_div, time_mod;
2158

    
2159
    assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2160
    s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2161

    
2162
    time_div= s->time/s->time_increment_resolution;
2163
    time_mod= s->time%s->time_increment_resolution;
2164

    
2165
    if(s->pict_type==B_TYPE){
2166
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2167
    }else{
2168
        s->last_time_base= s->time_base;
2169
        s->time_base= time_div;
2170
        s->pp_time= s->time - s->last_non_b_time;
2171
        s->last_non_b_time= s->time;
2172
    }
2173
}
2174

    
2175
static void mpeg4_encode_gop_header(MpegEncContext * s){
2176
    int hours, minutes, seconds;
2177
    int64_t time;
2178
    
2179
    put_bits(&s->pb, 16, 0);
2180
    put_bits(&s->pb, 16, GOP_STARTCODE);
2181
    
2182
    time= s->current_picture_ptr->pts;
2183
    if(s->reordered_input_picture[1])
2184
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2185
    time= (time*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2186

    
2187
    seconds= time/s->time_increment_resolution;
2188
    minutes= seconds/60; seconds %= 60;
2189
    hours= minutes/60; minutes %= 60;
2190
    hours%=24;
2191

    
2192
    put_bits(&s->pb, 5, hours);
2193
    put_bits(&s->pb, 6, minutes);
2194
    put_bits(&s->pb, 1, 1);
2195
    put_bits(&s->pb, 6, seconds);
2196
    
2197
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); 
2198
    put_bits(&s->pb, 1, 0); //broken link == NO
2199
    
2200
    s->last_time_base= time / s->time_increment_resolution; 
2201

    
2202
    ff_mpeg4_stuffing(&s->pb);
2203
}
2204

    
2205
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2206
    int profile_and_level_indication;
2207
    int vo_ver_id;
2208
    
2209
    if(s->max_b_frames || s->quarter_sample){
2210
        profile_and_level_indication= 0xF1; // adv simple level 1
2211
        vo_ver_id= 5;
2212
    }else{
2213
        profile_and_level_indication= 0x01; // simple level 1
2214
        vo_ver_id= 1;
2215
    }
2216
    //FIXME levels
2217

    
2218
    put_bits(&s->pb, 16, 0);
2219
    put_bits(&s->pb, 16, VOS_STARTCODE);
2220

    
2221
    put_bits(&s->pb, 8, profile_and_level_indication);
2222

    
2223
    put_bits(&s->pb, 16, 0);
2224
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2225
    
2226
    put_bits(&s->pb, 1, 1);
2227
        put_bits(&s->pb, 4, vo_ver_id);
2228
        put_bits(&s->pb, 3, 1); //priority
2229
 
2230
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
2231
    
2232
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2233

    
2234
    ff_mpeg4_stuffing(&s->pb);
2235
}
2236

    
2237
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2238
{
2239
    int vo_ver_id;
2240

    
2241
    if(s->max_b_frames || s->quarter_sample){
2242
        vo_ver_id= 5;
2243
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2244
    }else{
2245
        vo_ver_id= 1;
2246
        s->vo_type= SIMPLE_VO_TYPE;
2247
    }
2248

    
2249
    put_bits(&s->pb, 16, 0);
2250
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2251
    put_bits(&s->pb, 16, 0);
2252
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2253

    
2254
    put_bits(&s->pb, 1, 0);                /* random access vol */
2255
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
2256
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
2257
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
2258
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
2259
    
2260
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2261

    
2262
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2263
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2264
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2265
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2266
    }
2267

    
2268
    if(s->low_delay){
2269
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
2270
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
2271
        put_bits(&s->pb, 1, s->low_delay);
2272
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
2273
    }else{
2274
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
2275
    }
2276

    
2277
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
2278
    put_bits(&s->pb, 1, 1);                /* marker bit */
2279
    
2280
    put_bits(&s->pb, 16, s->time_increment_resolution);
2281
    if (s->time_increment_bits < 1)
2282
        s->time_increment_bits = 1;
2283
    put_bits(&s->pb, 1, 1);                /* marker bit */
2284
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
2285
    put_bits(&s->pb, 1, 1);                /* marker bit */
2286
    put_bits(&s->pb, 13, s->width);        /* vol width */
2287
    put_bits(&s->pb, 1, 1);                /* marker bit */
2288
    put_bits(&s->pb, 13, s->height);        /* vol height */
2289
    put_bits(&s->pb, 1, 1);                /* marker bit */
2290
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2291
    put_bits(&s->pb, 1, 1);                /* obmc disable */
2292
    if (vo_ver_id == 1) {
2293
        put_bits(&s->pb, 1, s->vol_sprite_usage);                /* sprite enable */
2294
    }else{
2295
        put_bits(&s->pb, 2, s->vol_sprite_usage);                /* sprite enable */
2296
    }
2297
    
2298
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
2299
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
2300

    
2301
    if(s->mpeg_quant){
2302
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2303
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2304
    }
2305

    
2306
    if (vo_ver_id != 1)
2307
        put_bits(&s->pb, 1, s->quarter_sample);
2308
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
2309
    s->resync_marker= s->rtp_mode;
2310
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2311
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2312
    if(s->data_partitioning){
2313
        put_bits(&s->pb, 1, 0);                /* no rvlc */
2314
    }
2315

    
2316
    if (vo_ver_id != 1){
2317
        put_bits(&s->pb, 1, 0);                /* newpred */
2318
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
2319
    }
2320
    put_bits(&s->pb, 1, 0);                /* scalability */
2321
    
2322
    ff_mpeg4_stuffing(&s->pb);
2323

    
2324
    /* user data */
2325
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2326
        put_bits(&s->pb, 16, 0);
2327
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
2328
        put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2329
    }
2330
}
2331

    
2332
/* write mpeg4 VOP header */
2333
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2334
{
2335
    int time_incr;
2336
    int time_div, time_mod;
2337
    
2338
    if(s->pict_type==I_TYPE){
2339
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2340
            if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2341
                mpeg4_encode_visual_object_header(s);
2342
            if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2343
                mpeg4_encode_vol_header(s, 0, 0);
2344
        }
2345
        mpeg4_encode_gop_header(s);
2346
    }
2347
    
2348
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2349

    
2350
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2351
    
2352
    put_bits(&s->pb, 16, 0);                /* vop header */
2353
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2354
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
2355

    
2356
    time_div= s->time/s->time_increment_resolution;
2357
    time_mod= s->time%s->time_increment_resolution;
2358
    time_incr= time_div - s->last_time_base;
2359
    while(time_incr--)
2360
        put_bits(&s->pb, 1, 1);
2361
        
2362
    put_bits(&s->pb, 1, 0);
2363

    
2364
    put_bits(&s->pb, 1, 1);        /* marker */
2365
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
2366
    put_bits(&s->pb, 1, 1);        /* marker */
2367
    put_bits(&s->pb, 1, 1);        /* vop coded */
2368
    if (    s->pict_type == P_TYPE 
2369
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2370
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
2371
    }
2372
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
2373
    if(!s->progressive_sequence){
2374
         put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2375
         put_bits(&s->pb, 1, s->alternate_scan);
2376
    }
2377
    //FIXME sprite stuff
2378

    
2379
    put_bits(&s->pb, 5, s->qscale);
2380

    
2381
    if (s->pict_type != I_TYPE)
2382
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
2383
    if (s->pict_type == B_TYPE)
2384
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
2385
    //    printf("****frame %d\n", picture_number);
2386
}
2387

    
2388
#endif //CONFIG_ENCODERS
2389

    
2390
/**
2391
 * set qscale and update qscale dependant variables.
2392
 */
2393
void ff_set_qscale(MpegEncContext * s, int qscale)
2394
{
2395
    if (qscale < 1)
2396
        qscale = 1;
2397
    else if (qscale > 31)
2398
        qscale = 31;
2399
        
2400
    s->qscale = qscale;
2401
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2402

    
2403
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2404
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2405
}
2406

    
2407
/**
2408
 * predicts the dc.
2409
 * @param n block index (0-3 are luma, 4-5 are chroma)
2410
 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
2411
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2412
 * @return the quantized predicted dc
2413
 */
2414
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
2415
{
2416
    int a, b, c, wrap, pred, scale;
2417
    uint16_t *dc_val;
2418

    
2419
    /* find prediction */
2420
    if (n < 4) {
2421
        scale = s->y_dc_scale;
2422
    } else {
2423
        scale = s->c_dc_scale;
2424
    }
2425
    if(IS_3IV1)
2426
        scale= 8;
2427

    
2428
    wrap= s->block_wrap[n];
2429
    dc_val = s->dc_val[0] + s->block_index[n];
2430

    
2431
    /* B C
2432
     * A X 
2433
     */
2434
    a = dc_val[ - 1];
2435
    b = dc_val[ - 1 - wrap];
2436
    c = dc_val[ - wrap];
2437

    
2438
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2439
    if(s->first_slice_line && n!=3){
2440
        if(n!=2) b=c= 1024;
2441
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2442
    }
2443
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2444
        if(n==0 || n==4 || n==5)
2445
            b=1024;
2446
    }
2447

    
2448
    if (abs(a - b) < abs(b - c)) {
2449
        pred = c;
2450
        *dir_ptr = 1; /* top */
2451
    } else {
2452
        pred = a;
2453
        *dir_ptr = 0; /* left */
2454
    }
2455
    /* we assume pred is positive */
2456
    pred = FASTDIV((pred + (scale >> 1)), scale);
2457

    
2458
    /* prepare address for prediction update */
2459
    *dc_val_ptr = &dc_val[0];
2460

    
2461
    return pred;
2462
}
2463

    
2464
/**
2465
 * predicts the ac.
2466
 * @param n block index (0-3 are luma, 4-5 are chroma)
2467
 * @param dir the ac prediction direction
2468
 */
2469
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2470
                   int dir)
2471
{
2472
    int i;
2473
    int16_t *ac_val, *ac_val1;
2474
    int8_t * const qscale_table= s->current_picture.qscale_table;
2475

    
2476
    /* find prediction */
2477
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2478
    ac_val1 = ac_val;
2479
    if (s->ac_pred) {
2480
        if (dir == 0) {
2481
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2482
            /* left prediction */
2483
            ac_val -= 16;
2484
            
2485
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2486
                /* same qscale */
2487
                for(i=1;i<8;i++) {
2488
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2489
                }
2490
            }else{
2491
                /* different qscale, we must rescale */
2492
                for(i=1;i<8;i++) {
2493
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2494
                }
2495
            }
2496
        } else {
2497
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2498
            /* top prediction */
2499
            ac_val -= 16 * s->block_wrap[n];
2500

    
2501
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2502
                /* same qscale */
2503
                for(i=1;i<8;i++) {
2504
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2505
                }
2506
            }else{
2507
                /* different qscale, we must rescale */
2508
                for(i=1;i<8;i++) {
2509
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2510
                }
2511
            }
2512
        }
2513
    }
2514
    /* left copy */
2515
    for(i=1;i<8;i++)
2516
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2517

    
2518
    /* top copy */
2519
    for(i=1;i<8;i++)
2520
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2521

    
2522
}
2523

    
2524
#ifdef CONFIG_ENCODERS
2525

    
2526
/**
2527
 * encodes the dc value.
2528
 * @param n block index (0-3 are luma, 4-5 are chroma)
2529
 */
2530
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2531
{
2532
#if 1
2533
//    if(level<-255 || level>255) printf("dc overflow\n");
2534
    level+=256;
2535
    if (n < 4) {
2536
        /* luminance */
2537
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2538
    } else {
2539
        /* chrominance */
2540
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2541
    }
2542
#else
2543
    int size, v;
2544
    /* find number of bits */
2545
    size = 0;
2546
    v = abs(level);
2547
    while (v) {
2548
        v >>= 1;
2549
        size++;
2550
    }
2551

    
2552
    if (n < 4) {
2553
        /* luminance */
2554
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2555
    } else {
2556
        /* chrominance */
2557
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2558
    }
2559

    
2560
    /* encode remaining bits */
2561
    if (size > 0) {
2562
        if (level < 0)
2563
            level = (-level) ^ ((1 << size) - 1);
2564
        put_bits(&s->pb, size, level);
2565
        if (size > 8)
2566
            put_bits(&s->pb, 1, 1);
2567
    }
2568
#endif
2569
}
2570

    
2571
/**
2572
 * encodes a 8x8 block
2573
 * @param n block index (0-3 are luma, 4-5 are chroma)
2574
 */
2575
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2576
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2577
{
2578
    int i, last_non_zero;
2579
#if 0 //variables for the outcommented version
2580
    int code, sign, last;
2581
#endif
2582
    const RLTable *rl;
2583
    uint32_t *bits_tab;
2584
    uint8_t *len_tab;
2585
    const int last_index = s->block_last_index[n];
2586

    
2587
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2588
        /* mpeg4 based DC predictor */
2589
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2590
        if(last_index<1) return;
2591
        i = 1;
2592
        rl = &rl_intra;
2593
        bits_tab= uni_mpeg4_intra_rl_bits;
2594
        len_tab = uni_mpeg4_intra_rl_len;
2595
    } else {
2596
        if(last_index<0) return;
2597
        i = 0;
2598
        rl = &rl_inter;
2599
        bits_tab= uni_mpeg4_inter_rl_bits;
2600
        len_tab = uni_mpeg4_inter_rl_len;
2601
    }
2602

    
2603
    /* AC coefs */
2604
    last_non_zero = i - 1;
2605
#if 1
2606
    for (; i < last_index; i++) {
2607
        int level = block[ scan_table[i] ];
2608
        if (level) {
2609
            int run = i - last_non_zero - 1;
2610
            level+=64;
2611
            if((level&(~127)) == 0){
2612
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2613
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2614
            }else{ //ESC3
2615
                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);
2616
            }
2617
            last_non_zero = i;
2618
        }
2619
    }
2620
    /*if(i<=last_index)*/{
2621
        int level = block[ scan_table[i] ];
2622
        int run = i - last_non_zero - 1;
2623
        level+=64;
2624
        if((level&(~127)) == 0){
2625
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2626
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2627
        }else{ //ESC3
2628
            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);
2629
        }
2630
    }
2631
#else
2632
    for (; i <= last_index; i++) {
2633
        const int slevel = block[ scan_table[i] ];
2634
        if (slevel) {
2635
            int level;
2636
            int run = i - last_non_zero - 1;
2637
            last = (i == last_index);
2638
            sign = 0;
2639
            level = slevel;
2640
            if (level < 0) {
2641
                sign = 1;
2642
                level = -level;
2643
            }
2644
            code = get_rl_index(rl, last, run, level);
2645
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2646
            if (code == rl->n) {
2647
                int level1, run1;
2648
                level1 = level - rl->max_level[last][run];
2649
                if (level1 < 1) 
2650
                    goto esc2;
2651
                code = get_rl_index(rl, last, run, level1);
2652
                if (code == rl->n) {
2653
                esc2:
2654
                    put_bits(ac_pb, 1, 1);
2655
                    if (level > MAX_LEVEL)
2656
                        goto esc3;
2657
                    run1 = run - rl->max_run[last][level] - 1;
2658
                    if (run1 < 0)
2659
                        goto esc3;
2660
                    code = get_rl_index(rl, last, run1, level);
2661
                    if (code == rl->n) {
2662
                    esc3:
2663
                        /* third escape */
2664
                        put_bits(ac_pb, 1, 1);
2665
                        put_bits(ac_pb, 1, last);
2666
                        put_bits(ac_pb, 6, run);
2667
                        put_bits(ac_pb, 1, 1);
2668
                        put_bits(ac_pb, 12, slevel & 0xfff);
2669
                        put_bits(ac_pb, 1, 1);
2670
                    } else {
2671
                        /* second escape */
2672
                        put_bits(ac_pb, 1, 0);
2673
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2674
                        put_bits(ac_pb, 1, sign);
2675
                    }
2676
                } else {
2677
                    /* first escape */
2678
                    put_bits(ac_pb, 1, 0);
2679
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2680
                    put_bits(ac_pb, 1, sign);
2681
                }
2682
            } else {
2683
                put_bits(ac_pb, 1, sign);
2684
            }
2685
            last_non_zero = i;
2686
        }
2687
    }
2688
#endif
2689
}
2690

    
2691
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2692
                               uint8_t *scan_table)
2693
{
2694
    int i, last_non_zero;
2695
    const RLTable *rl;
2696
    uint8_t *len_tab;
2697
    const int last_index = s->block_last_index[n];
2698
    int len=0;
2699

    
2700
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2701
        /* mpeg4 based DC predictor */
2702
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2703
        if(last_index<1) return len;
2704
        i = 1;
2705
        rl = &rl_intra;
2706
        len_tab = uni_mpeg4_intra_rl_len;
2707
    } else {
2708
        if(last_index<0) return 0;
2709
        i = 0;
2710
        rl = &rl_inter;
2711
        len_tab = uni_mpeg4_inter_rl_len;
2712
    }
2713

    
2714
    /* AC coefs */
2715
    last_non_zero = i - 1;
2716
    for (; i < last_index; i++) {
2717
        int level = block[ scan_table[i] ];
2718
        if (level) {
2719
            int run = i - last_non_zero - 1;
2720
            level+=64;
2721
            if((level&(~127)) == 0){
2722
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2723
                len += len_tab[index];
2724
            }else{ //ESC3
2725
                len += 7+2+1+6+1+12+1;
2726
            }
2727
            last_non_zero = i;
2728
        }
2729
    }
2730
    /*if(i<=last_index)*/{
2731
        int level = block[ scan_table[i] ];
2732
        int run = i - last_non_zero - 1;
2733
        level+=64;
2734
        if((level&(~127)) == 0){
2735
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2736
            len += len_tab[index];
2737
        }else{ //ESC3
2738
            len += 7+2+1+6+1+12+1;
2739
        }
2740
    }
2741
    
2742
    return len;
2743
}
2744

    
2745
#endif
2746

    
2747

    
2748
/***********************************************/
2749
/* decoding */
2750

    
2751
static VLC intra_MCBPC_vlc;
2752
static VLC inter_MCBPC_vlc;
2753
static VLC cbpy_vlc;
2754
static VLC mv_vlc;
2755
static VLC dc_lum, dc_chrom;
2756
static VLC sprite_trajectory;
2757
static VLC mb_type_b_vlc;
2758
static VLC h263_mbtype_b_vlc;
2759
static VLC cbpc_b_vlc;
2760

    
2761
void init_vlc_rl(RLTable *rl)
2762
{
2763
    int i, q;
2764
    
2765
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2766
             &rl->table_vlc[0][1], 4, 2,
2767
             &rl->table_vlc[0][0], 4, 2);
2768

    
2769
    
2770
    for(q=0; q<32; q++){
2771
        int qmul= q*2;
2772
        int qadd= (q-1)|1;
2773
        
2774
        if(q==0){
2775
            qmul=1;
2776
            qadd=0;
2777
        }
2778
        
2779
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2780
        for(i=0; i<rl->vlc.table_size; i++){
2781
            int code= rl->vlc.table[i][0];
2782
            int len = rl->vlc.table[i][1];
2783
            int level, run;
2784
        
2785
            if(len==0){ // illegal code
2786
                run= 66;
2787
                level= MAX_LEVEL;
2788
            }else if(len<0){ //more bits needed
2789
                run= 0;
2790
                level= code;
2791
            }else{
2792
                if(code==rl->n){ //esc
2793
                    run= 66;
2794
                    level= 0;
2795
                }else{
2796
                    run=   rl->table_run  [code] + 1;
2797
                    level= rl->table_level[code] * qmul + qadd;
2798
                    if(code >= rl->last) run+=192;
2799
                }
2800
            }
2801
            rl->rl_vlc[q][i].len= len;
2802
            rl->rl_vlc[q][i].level= level;
2803
            rl->rl_vlc[q][i].run= run;
2804
        }
2805
    }
2806
}
2807

    
2808
/* init vlcs */
2809

    
2810
/* XXX: find a better solution to handle static init */
2811
void h263_decode_init_vlc(MpegEncContext *s)
2812
{
2813
    static int done = 0;
2814

    
2815
    if (!done) {
2816
        done = 1;
2817

    
2818
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, 
2819
                 intra_MCBPC_bits, 1, 1,
2820
                 intra_MCBPC_code, 1, 1);
2821
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, 
2822
                 inter_MCBPC_bits, 1, 1,
2823
                 inter_MCBPC_code, 1, 1);
2824
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2825
                 &cbpy_tab[0][1], 2, 1,
2826
                 &cbpy_tab[0][0], 2, 1);
2827
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2828
                 &mvtab[0][1], 2, 1,
2829
                 &mvtab[0][0], 2, 1);
2830
        init_rl(&rl_inter);
2831
        init_rl(&rl_intra);
2832
        init_rl(&rvlc_rl_inter);
2833
        init_rl(&rvlc_rl_intra);
2834
        init_rl(&rl_intra_aic);
2835
        init_vlc_rl(&rl_inter);
2836
        init_vlc_rl(&rl_intra);
2837
        init_vlc_rl(&rvlc_rl_inter);
2838
        init_vlc_rl(&rvlc_rl_intra);
2839
        init_vlc_rl(&rl_intra_aic);
2840
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2841
                 &DCtab_lum[0][1], 2, 1,
2842
                 &DCtab_lum[0][0], 2, 1);
2843
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2844
                 &DCtab_chrom[0][1], 2, 1,
2845
                 &DCtab_chrom[0][0], 2, 1);
2846
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2847
                 &sprite_trajectory_tab[0][1], 4, 2,
2848
                 &sprite_trajectory_tab[0][0], 4, 2);
2849
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2850
                 &mb_type_b_tab[0][1], 2, 1,
2851
                 &mb_type_b_tab[0][0], 2, 1);
2852
        init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2853
                 &h263_mbtype_b_tab[0][1], 2, 1,
2854
                 &h263_mbtype_b_tab[0][0], 2, 1);
2855
        init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2856
                 &cbpc_b_tab[0][1], 2, 1,
2857
                 &cbpc_b_tab[0][0], 2, 1);
2858
    }
2859
}
2860

    
2861
/**
2862
 * Get the GOB height based on picture height.
2863
 */
2864
int ff_h263_get_gob_height(MpegEncContext *s){
2865
    if (s->height <= 400)
2866
        return 1;
2867
    else if (s->height <= 800)
2868
        return  2;
2869
    else
2870
        return 4;
2871
}
2872

    
2873
int ff_h263_decode_mba(MpegEncContext *s)
2874
{
2875
    int i, mb_pos;
2876

    
2877
    for(i=0; i<6; i++){
2878
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2879
    }
2880
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2881
    s->mb_x= mb_pos % s->mb_width;
2882
    s->mb_y= mb_pos / s->mb_width;
2883

    
2884
    return mb_pos;
2885
}
2886

    
2887
void ff_h263_encode_mba(MpegEncContext *s)
2888
{
2889
    int i, mb_pos;
2890

    
2891
    for(i=0; i<6; i++){
2892
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2893
    }
2894
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
2895
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
2896
}
2897

    
2898
/**
2899
 * decodes the group of blocks header or slice header.
2900
 * @return <0 if an error occured
2901
 */
2902
static int h263_decode_gob_header(MpegEncContext *s)
2903
{
2904
    unsigned int val, gfid, gob_number;
2905
    int left;
2906
    
2907
    /* Check for GOB Start Code */
2908
    val = show_bits(&s->gb, 16);
2909
    if(val)
2910
        return -1;
2911

    
2912
        /* We have a GBSC probably with GSTUFF */
2913
    skip_bits(&s->gb, 16); /* Drop the zeros */
2914
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2915
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2916
    for(;left>13; left--){
2917
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2918
    }
2919
    if(left<=13) 
2920
        return -1;
2921

    
2922
    if(s->h263_slice_structured){
2923
        if(get_bits1(&s->gb)==0)
2924
            return -1;
2925

    
2926
        ff_h263_decode_mba(s);
2927

    
2928
        if(s->mb_num > 1583)
2929
            if(get_bits1(&s->gb)==0)
2930
                return -1;
2931
        
2932
        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
2933
        if(get_bits1(&s->gb)==0)
2934
            return -1;
2935
        gfid = get_bits(&s->gb, 2); /* GFID */
2936
    }else{
2937
        gob_number = get_bits(&s->gb, 5); /* GN */
2938
        s->mb_x= 0;
2939
        s->mb_y= s->gob_index* gob_number;
2940
        gfid = get_bits(&s->gb, 2); /* GFID */
2941
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2942
    }
2943
        
2944
    if(s->mb_y >= s->mb_height) 
2945
        return -1;
2946

    
2947
    if(s->qscale==0) 
2948
        return -1;
2949

    
2950
    return 0;
2951
}
2952

    
2953
static inline void memsetw(short *tab, int val, int n)
2954
{
2955
    int i;
2956
    for(i=0;i<n;i++)
2957
        tab[i] = val;
2958
}
2959

    
2960
#ifdef CONFIG_ENCODERS
2961

    
2962
void ff_mpeg4_init_partitions(MpegEncContext *s)
2963
{
2964
    uint8_t *start= pbBufPtr(&s->pb);
2965
    uint8_t *end= s->pb.buf_end;
2966
    int size= end - start;
2967
    int pb_size = size/3;
2968
    int pb2_size= size/3;
2969
    int tex_size= size - pb_size - pb2_size;
2970
    
2971
    set_put_bits_buffer_size(&s->pb, pb_size);
2972
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
2973
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb2_size);
2974
}
2975

    
2976
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2977
{
2978
    const int pb2_len   = put_bits_count(&s->pb2   );
2979
    const int tex_pb_len= put_bits_count(&s->tex_pb);
2980
    const int bits= put_bits_count(&s->pb);
2981

    
2982
    if(s->pict_type==I_TYPE){
2983
        put_bits(&s->pb, 19, DC_MARKER);
2984
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2985
        s->i_tex_bits+= tex_pb_len;
2986
    }else{
2987
        put_bits(&s->pb, 17, MOTION_MARKER);
2988
        s->misc_bits+=17 + pb2_len;
2989
        s->mv_bits+= bits - s->last_bits;
2990
        s->p_tex_bits+= tex_pb_len;
2991
    }
2992

    
2993
    flush_put_bits(&s->pb2);
2994
    flush_put_bits(&s->tex_pb);
2995

    
2996
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
2997
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
2998
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
2999
    s->last_bits= put_bits_count(&s->pb);
3000
}
3001

    
3002
#endif //CONFIG_ENCODERS
3003

    
3004
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3005
    switch(s->pict_type){
3006
        case I_TYPE:
3007
            return 16;
3008
        case P_TYPE:
3009
        case S_TYPE:
3010
            return s->f_code+15;
3011
        case B_TYPE:
3012
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3013
        default:
3014
            return -1;
3015
    }
3016
}
3017

    
3018
#ifdef CONFIG_ENCODERS
3019

    
3020
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3021
{
3022
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3023

    
3024
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3025
    put_bits(&s->pb, 1, 1);
3026
    
3027
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3028
    put_bits(&s->pb, s->quant_precision, s->qscale);
3029
    put_bits(&s->pb, 1, 0); /* no HEC */
3030
}
3031

    
3032
#endif //CONFIG_ENCODERS
3033

    
3034
/**
3035
 * check if the next stuff is a resync marker or the end.
3036
 * @return 0 if not
3037
 */
3038
static inline int mpeg4_is_resync(MpegEncContext *s){
3039
    const int bits_count= get_bits_count(&s->gb);
3040
    
3041
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3042
        return 0;
3043
    }
3044

    
3045
    if(bits_count + 8 >= s->gb.size_in_bits){
3046
        int v= show_bits(&s->gb, 8);
3047
        v|= 0x7F >> (7-(bits_count&7));
3048
                
3049
        if(v==0x7F)
3050
            return 1;
3051
    }else{
3052
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3053
            int len;
3054
            GetBitContext gb= s->gb;
3055
        
3056
            skip_bits(&s->gb, 1);
3057
            align_get_bits(&s->gb);
3058
        
3059
            for(len=0; len<32; len++){
3060
                if(get_bits1(&s->gb)) break;
3061
            }
3062

    
3063
            s->gb= gb;
3064

    
3065
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3066
                return 1;
3067
        }
3068
    }
3069
    return 0;
3070
}
3071

    
3072
/**
3073
 * decodes the next video packet.
3074
 * @return <0 if something went wrong
3075
 */
3076
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3077
{
3078
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3079
    int header_extension=0, mb_num, len;
3080
    
3081
    /* is there enough space left for a video packet + header */
3082
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3083

    
3084
    for(len=0; len<32; len++){
3085
        if(get_bits1(&s->gb)) break;
3086
    }
3087

    
3088
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3089
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3090
        return -1;
3091
    }
3092
    
3093
    if(s->shape != RECT_SHAPE){
3094
        header_extension= get_bits1(&s->gb);
3095
        //FIXME more stuff here
3096
    }
3097

    
3098
    mb_num= get_bits(&s->gb, mb_num_bits);
3099
    if(mb_num>=s->mb_num){
3100
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3101
        return -1;
3102
    }
3103
    if(s->pict_type == B_TYPE){
3104
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3105
        if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
3106
    }
3107
    
3108
    s->mb_x= mb_num % s->mb_width;
3109
    s->mb_y= mb_num / s->mb_width;
3110

    
3111
    if(s->shape != BIN_ONLY_SHAPE){
3112
        int qscale= get_bits(&s->gb, s->quant_precision); 
3113
        if(qscale)
3114
            s->chroma_qscale=s->qscale= qscale;
3115
    }
3116

    
3117
    if(s->shape == RECT_SHAPE){
3118
        header_extension= get_bits1(&s->gb);
3119
    }
3120
    if(header_extension){
3121
        int time_increment;
3122
        int time_incr=0;
3123

    
3124
        while (get_bits1(&s->gb) != 0) 
3125
            time_incr++;
3126

    
3127
        check_marker(&s->gb, "before time_increment in video packed header");
3128
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3129
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3130
        
3131
        skip_bits(&s->gb, 2); /* vop coding type */
3132
        //FIXME not rect stuff here
3133

    
3134
        if(s->shape != BIN_ONLY_SHAPE){
3135
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3136
//FIXME dont just ignore everything
3137
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3138
                mpeg4_decode_sprite_trajectory(s);
3139
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3140
            }
3141

    
3142
            //FIXME reduced res stuff here
3143
            
3144
            if (s->pict_type != I_TYPE) {
3145
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
3146
                if(f_code==0){
3147
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3148
                }
3149
            }
3150
            if (s->pict_type == B_TYPE) {
3151
                int b_code = get_bits(&s->gb, 3);
3152
                if(b_code==0){
3153
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3154
                }
3155
            }       
3156
        }
3157
    }
3158
    //FIXME new-pred stuff
3159
    
3160
//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));
3161

    
3162
    return 0;
3163
}
3164

    
3165
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3166
{
3167
    int c_wrap, c_xy, l_wrap, l_xy;
3168

    
3169
    l_wrap= s->block_wrap[0];
3170
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
3171
    c_wrap= s->block_wrap[4];
3172
    c_xy= s->mb_y*c_wrap + s->mb_x;
3173

    
3174
#if 0
3175
    /* clean DC */
3176
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3177
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3178
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3179
#endif
3180

    
3181
    /* clean AC */
3182
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3183
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3184
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3185

    
3186
    /* clean MV */
3187
    // we cant clear the MVs as they might be needed by a b frame
3188
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3189
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3190
    s->last_mv[0][0][0]=
3191
    s->last_mv[0][0][1]=
3192
    s->last_mv[1][0][0]=
3193
    s->last_mv[1][0][1]= 0;
3194
}
3195

    
3196
/**
3197
 * decodes the group of blocks / video packet header.
3198
 * @return <0 if no resync found
3199
 */
3200
int ff_h263_resync(MpegEncContext *s){
3201
    int left, ret;
3202
    
3203
    if(s->codec_id==CODEC_ID_MPEG4){
3204
        skip_bits1(&s->gb);
3205
        align_get_bits(&s->gb);
3206
    }
3207

    
3208
    if(show_bits(&s->gb, 16)==0){
3209
        if(s->codec_id==CODEC_ID_MPEG4)
3210
            ret= mpeg4_decode_video_packet_header(s);
3211
        else
3212
            ret= h263_decode_gob_header(s);
3213
        if(ret>=0)
3214
            return 0;
3215
    }
3216
    //ok, its not where its supposed to be ...
3217
    s->gb= s->last_resync_gb;
3218
    align_get_bits(&s->gb);
3219
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3220
    
3221
    for(;left>16+1+5+5; left-=8){ 
3222
        if(show_bits(&s->gb, 16)==0){
3223
            GetBitContext bak= s->gb;
3224

    
3225
            if(s->codec_id==CODEC_ID_MPEG4)
3226
                ret= mpeg4_decode_video_packet_header(s);
3227
            else
3228
                ret= h263_decode_gob_header(s);
3229
            if(ret>=0)
3230
                return 0;
3231

    
3232
            s->gb= bak;
3233
        }
3234
        skip_bits(&s->gb, 8);
3235
    }
3236
    
3237
    return -1;
3238
}
3239

    
3240
/**
3241
 * gets the average motion vector for a GMC MB.
3242
 * @param n either 0 for the x component or 1 for y
3243
 * @returns the average MV for a GMC MB
3244
 */
3245
static inline int get_amv(MpegEncContext *s, int n){
3246
    int x, y, mb_v, sum, dx, dy, shift;
3247
    int len = 1 << (s->f_code + 4);
3248
    const int a= s->sprite_warping_accuracy;
3249

    
3250
    if(s->real_sprite_warping_points==1){
3251
        if(s->divx_version==500 && s->divx_build==413)
3252
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3253
        else
3254
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3255
    }else{
3256
        dx= s->sprite_delta[n][0];
3257
        dy= s->sprite_delta[n][1];
3258
        shift= s->sprite_shift[0];
3259
        if(n) dy -= 1<<(shift + a + 1);
3260
        else  dx -= 1<<(shift + a + 1);
3261
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3262

    
3263
        sum=0;
3264
        for(y=0; y<16; y++){
3265
            int v;
3266
        
3267
            v= mb_v + dy*y;
3268
            //XXX FIXME optimize
3269
            for(x=0; x<16; x++){
3270
                sum+= v>>shift;
3271
                v+= dx;
3272
            }
3273
        }
3274
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3275
    }
3276

    
3277
    if      (sum < -len) sum= -len;
3278
    else if (sum >= len) sum= len-1;
3279

    
3280
    return sum;
3281
}
3282

    
3283
/**
3284
 * decodes first partition.
3285
 * @return number of MBs decoded or <0 if an error occured
3286
 */
3287
static int mpeg4_decode_partition_a(MpegEncContext *s){
3288
    int mb_num;
3289
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3290
    
3291
    /* decode first partition */
3292
    mb_num=0;
3293
    s->first_slice_line=1;
3294
    for(; s->mb_y<s->mb_height; s->mb_y++){
3295
        ff_init_block_index(s);
3296
        for(; s->mb_x<s->mb_width; s->mb_x++){
3297
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3298
            int cbpc;
3299
            int dir=0;
3300
            
3301
            mb_num++;
3302
            ff_update_block_index(s);
3303
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3304
                s->first_slice_line=0;
3305
            
3306
            if(s->pict_type==I_TYPE){
3307
                int i;
3308

    
3309
                if(show_bits_long(&s->gb, 19)==DC_MARKER){
3310
                    return mb_num-1;
3311
                }
3312

    
3313
                do{
3314
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3315
                    if (cbpc < 0){
3316
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3317
                        return -1;
3318
                    }
3319
                }while(cbpc == 8);
3320

    
3321
                s->cbp_table[xy]= cbpc & 3;
3322
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3323
                s->mb_intra = 1;
3324

    
3325
                if(cbpc & 4) {
3326
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3327
                }
3328
                s->current_picture.qscale_table[xy]= s->qscale;
3329

    
3330
                s->mbintra_table[xy]= 1;
3331
                for(i=0; i<6; i++){
3332
                    int dc_pred_dir;
3333
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3334
                    if(dc < 0){
3335
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3336
                        return -1;
3337
                    }
3338
                    dir<<=1;
3339
                    if(dc_pred_dir) dir|=1;
3340
                }
3341
                s->pred_dir_table[xy]= dir;
3342
            }else{ /* P/S_TYPE */
3343
                int mx, my, pred_x, pred_y, bits;
3344
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3345
                const int stride= s->block_wrap[0]*2;
3346

    
3347
//              do{ //FIXME
3348
                bits= show_bits(&s->gb, 17);
3349
                if(bits==MOTION_MARKER){
3350
                    return mb_num-1;
3351
                }
3352
                skip_bits1(&s->gb);
3353
                if(bits&0x10000){
3354
                    /* skip mb */
3355
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3356
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3357
                        mx= get_amv(s, 0);
3358
                        my= get_amv(s, 1);
3359
                    }else{
3360
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3361
                        mx=my=0;
3362
                    }
3363
                    mot_val[0       ]= mot_val[2       ]=
3364
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3365
                    mot_val[1       ]= mot_val[3       ]=
3366
                    mot_val[1+stride]= mot_val[3+stride]= my;
3367

    
3368
                    if(s->mbintra_table[xy])
3369
                        ff_clean_intra_table_entries(s);
3370
                    continue;
3371
                }
3372

    
3373
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3374
                if (cbpc < 0){
3375
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3376
                    return -1;
3377
                }
3378
//              }while(cbpc == 20);
3379

    
3380
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3381
    
3382
                s->mb_intra = ((cbpc & 4) != 0);
3383
        
3384
                if(s->mb_intra){
3385
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3386
                    s->mbintra_table[xy]= 1;
3387
                    mot_val[0       ]= mot_val[2       ]= 
3388
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3389
                    mot_val[1       ]= mot_val[3       ]=
3390
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3391
                }else{
3392
                    if(s->mbintra_table[xy])
3393
                        ff_clean_intra_table_entries(s);
3394

    
3395
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3396
                        s->mcsel= get_bits1(&s->gb);
3397
                    else s->mcsel= 0;
3398
        
3399
                    if ((cbpc & 16) == 0) {
3400
                        /* 16x16 motion prediction */
3401

    
3402
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
3403
                        if(!s->mcsel){
3404
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3405
                            if (mx >= 0xffff)
3406
                                return -1;
3407

    
3408
                            my = h263_decode_motion(s, pred_y, s->f_code);
3409
                            if (my >= 0xffff)
3410
                                return -1;
3411
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3412
                        } else {
3413
                            mx = get_amv(s, 0);
3414
                            my = get_amv(s, 1);
3415
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3416
                        }
3417

    
3418
                        mot_val[0       ]= mot_val[2       ] =
3419
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3420
                        mot_val[1       ]= mot_val[3       ]=
3421
                        mot_val[1+stride]= mot_val[3+stride]= my;
3422
                    } else {
3423
                        int i;
3424
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3425
                        for(i=0;i<4;i++) {
3426
                            int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
3427
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3428
                            if (mx >= 0xffff)
3429
                                return -1;
3430
                
3431
                            my = h263_decode_motion(s, pred_y, s->f_code);
3432
                            if (my >= 0xffff)
3433
                                return -1;
3434
                            mot_val[0] = mx;
3435
                            mot_val[1] = my;
3436
                        }
3437
                    }
3438
                }
3439
            }
3440
        }
3441
        s->mb_x= 0;
3442
    }
3443

    
3444
    return mb_num;
3445
}
3446

    
3447
/**
3448
 * decode second partition.
3449
 * @return <0 if an error occured
3450
 */
3451
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3452
    int mb_num=0;
3453
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3454

    
3455
    s->mb_x= s->resync_mb_x;
3456
    s->first_slice_line=1;
3457
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3458
        ff_init_block_index(s);
3459
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3460
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3461

    
3462
            mb_num++;
3463
            ff_update_block_index(s);
3464
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3465
                s->first_slice_line=0;
3466
            
3467
            if(s->pict_type==I_TYPE){
3468
                int ac_pred= get_bits1(&s->gb);
3469
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3470
                if(cbpy<0){
3471
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3472
                    return -1;
3473
                }
3474
                
3475
                s->cbp_table[xy]|= cbpy<<2;
3476
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3477
            }else{ /* P || S_TYPE */
3478
                if(IS_INTRA(s->current_picture.mb_type[xy])){          
3479
                    int dir=0,i;
3480
                    int ac_pred = get_bits1(&s->gb);
3481
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3482

    
3483
                    if(cbpy<0){
3484
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3485
                        return -1;
3486
                    }
3487
                    
3488
                    if(s->cbp_table[xy] & 8) {
3489
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3490
                    }
3491
                    s->current_picture.qscale_table[xy]= s->qscale;
3492

    
3493
                    for(i=0; i<6; i++){
3494
                        int dc_pred_dir;
3495
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3496
                        if(dc < 0){
3497
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3498
                            return -1;
3499
                        }
3500
                        dir<<=1;
3501
                        if(dc_pred_dir) dir|=1;
3502
                    }
3503
                    s->cbp_table[xy]&= 3; //remove dquant
3504
                    s->cbp_table[xy]|= cbpy<<2;
3505
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3506
                    s->pred_dir_table[xy]= dir;
3507
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3508
                    s->current_picture.qscale_table[xy]= s->qscale;
3509
                    s->cbp_table[xy]= 0;
3510
                }else{
3511
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3512

    
3513
                    if(cbpy<0){
3514
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3515
                        return -1;
3516
                    }
3517
                    
3518
                    if(s->cbp_table[xy] & 8) {
3519
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3520
                    }
3521
                    s->current_picture.qscale_table[xy]= s->qscale;
3522

    
3523
                    s->cbp_table[xy]&= 3; //remove dquant
3524
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3525
                }
3526
            }
3527
        }
3528
        if(mb_num >= mb_count) return 0;
3529
        s->mb_x= 0;
3530
    }
3531
    return 0;
3532
}
3533

    
3534
/**
3535
 * decodes the first & second partition
3536
 * @return <0 if error (and sets error type in the error_status_table)
3537
 */
3538
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3539
{
3540
    int mb_num;
3541
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3542
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3543
    
3544
    mb_num= mpeg4_decode_partition_a(s);    
3545
    if(mb_num<0){
3546
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3547
        return -1;
3548
    }
3549
    
3550
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3551
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3552
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3553
        return -1;
3554
    }
3555

    
3556
    s->mb_num_left= mb_num;
3557
        
3558
    if(s->pict_type==I_TYPE){
3559
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3560
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3561
            return -1;
3562
        }
3563
    }else{
3564
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3565
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3566
            return -1;
3567
        }
3568
    }
3569
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3570
    
3571
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3572
        if(s->pict_type==P_TYPE)
3573
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3574
        return -1;
3575
    }else{
3576
        if(s->pict_type==P_TYPE)
3577
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3578
    }
3579

    
3580
    return 0;        
3581
}
3582

    
3583
/**
3584
 * decode partition C of one MB.
3585
 * @return <0 if an error occured
3586
 */
3587
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3588
{
3589
    int cbp, mb_type;
3590
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3591

    
3592
    mb_type= s->current_picture.mb_type[xy];
3593
    cbp = s->cbp_table[xy];
3594

    
3595
    if(s->current_picture.qscale_table[xy] != s->qscale){
3596
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3597
    }
3598
    
3599
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3600
        int i;
3601
        for(i=0; i<4; i++){
3602
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3603
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3604
        }
3605
        s->mb_intra = IS_INTRA(mb_type);
3606

    
3607
        if (IS_SKIP(mb_type)) {
3608
            /* skip mb */
3609
            for(i=0;i<6;i++)
3610
                s->block_last_index[i] = -1;
3611
            s->mv_dir = MV_DIR_FORWARD;
3612
            s->mv_type = MV_TYPE_16X16;
3613
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3614
                s->mcsel=1;
3615
                s->mb_skiped = 0;
3616
            }else{
3617
                s->mcsel=0;
3618
                s->mb_skiped = 1;
3619
            }
3620
        }else if(s->mb_intra){
3621
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3622
        }else if(!s->mb_intra){
3623
//            s->mcsel= 0; //FIXME do we need to init that
3624
            
3625
            s->mv_dir = MV_DIR_FORWARD;
3626
            if (IS_8X8(mb_type)) {
3627
                s->mv_type = MV_TYPE_8X8;
3628
            } else {
3629
                s->mv_type = MV_TYPE_16X16;
3630
            }
3631
        }
3632
    } else { /* I-Frame */
3633
        s->mb_intra = 1;
3634
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3635
    }
3636

    
3637
    if (!IS_SKIP(mb_type)) {
3638
        int i;
3639
        /* decode each block */
3640
        for (i = 0; i < 6; i++) {
3641
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3642
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3643
                return -1;
3644
            }
3645
            cbp+=cbp;
3646
        }
3647
    }
3648

    
3649
    /* per-MB end of slice check */
3650

    
3651
    if(--s->mb_num_left <= 0){
3652
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3653
        if(mpeg4_is_resync(s))
3654
            return SLICE_END;
3655
        else
3656
            return SLICE_NOEND;     
3657
    }else{
3658
        if(mpeg4_is_resync(s)){
3659
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3660
            if(s->cbp_table[xy+delta])
3661
                return SLICE_END;
3662
        }
3663
        return SLICE_OK;
3664
    }
3665
}
3666

    
3667
/**
3668
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3669
 */
3670
static void preview_obmc(MpegEncContext *s){
3671
    GetBitContext gb= s->gb;
3672
    
3673
    int cbpc, i, pred_x, pred_y, mx, my;
3674
    int16_t *mot_val;
3675
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3676
    const int stride= s->block_wrap[0]*2;
3677
    
3678
    for(i=0; i<4; i++)
3679
        s->block_index[i]+= 2;
3680
    for(i=4; i<6; i++)
3681
        s->block_index[i]+= 1;
3682
    s->mb_x++;
3683
    
3684
    assert(s->pict_type == P_TYPE);
3685

    
3686
    do{
3687
        if (get_bits1(&s->gb)) {
3688
            /* skip mb */
3689
            mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3690
            mot_val[0       ]= mot_val[2       ]= 
3691
            mot_val[0+stride]= mot_val[2+stride]= 0;
3692
            mot_val[1       ]= mot_val[3       ]=
3693
            mot_val[1+stride]= mot_val[3+stride]= 0;
3694
            
3695
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3696
            goto end;
3697
        }
3698
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3699
    }while(cbpc == 20);
3700
    
3701
    if(cbpc & 4){
3702
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3703
    }else{
3704
        get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3705
        if (cbpc & 8) {
3706
            if(s->modified_quant){
3707
                if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3708
                else                  skip_bits(&s->gb, 5);
3709
            }else
3710
                skip_bits(&s->gb, 2);
3711
        }
3712
        
3713
        if ((cbpc & 16) == 0) {
3714
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
3715
                /* 16x16 motion prediction */
3716
                mot_val= h263_pred_motion(s, 0, &pred_x, &pred_y);
3717
                if (s->umvplus)
3718
                   mx = h263p_decode_umotion(s, pred_x);
3719
                else
3720
                   mx = h263_decode_motion(s, pred_x, 1);
3721
            
3722
                if (s->umvplus)
3723
                   my = h263p_decode_umotion(s, pred_y);
3724
                else
3725
                   my = h263_decode_motion(s, pred_y, 1);
3726
            
3727
                mot_val[0       ]= mot_val[2       ]= 
3728
                mot_val[0+stride]= mot_val[2+stride]= mx;
3729
                mot_val[1       ]= mot_val[3       ]=
3730
                mot_val[1+stride]= mot_val[3+stride]= my;
3731
        } else {
3732
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3733
            for(i=0;i<4;i++) {
3734
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3735
                if (s->umvplus)
3736
                  mx = h263p_decode_umotion(s, pred_x);
3737
                else
3738
                  mx = h263_decode_motion(s, pred_x, 1);
3739
                
3740
                if (s->umvplus)
3741
                  my = h263p_decode_umotion(s, pred_y);
3742
                else    
3743
                  my = h263_decode_motion(s, pred_y, 1);
3744
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3745
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3746
                mot_val[0] = mx;
3747
                mot_val[1] = my;
3748
            }
3749
        }
3750
    }
3751
end:
3752
        
3753
    for(i=0; i<4; i++)
3754
        s->block_index[i]-= 2;
3755
    for(i=4; i<6; i++)
3756
        s->block_index[i]-= 1;
3757
    s->mb_x--;
3758

    
3759
    s->gb= gb;
3760
}
3761

    
3762
static void h263_decode_dquant(MpegEncContext *s){
3763
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3764

    
3765
    if(s->modified_quant){
3766
        if(get_bits1(&s->gb))
3767
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3768
        else
3769
            s->qscale= get_bits(&s->gb, 5);
3770
    }else
3771
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3772
    ff_set_qscale(s, s->qscale);
3773
}
3774

    
3775
int ff_h263_decode_mb(MpegEncContext *s,
3776
                      DCTELEM block[6][64])
3777
{
3778
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3779
    int16_t *mot_val;
3780
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3781
    
3782
    assert(!s->h263_pred);
3783
    
3784
    if (s->pict_type == P_TYPE) {
3785
        do{
3786
            if (get_bits1(&s->gb)) {
3787
                /* skip mb */
3788
                s->mb_intra = 0;
3789
                for(i=0;i<6;i++)
3790
                    s->block_last_index[i] = -1;
3791
                s->mv_dir = MV_DIR_FORWARD;
3792
                s->mv_type = MV_TYPE_16X16;
3793
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3794
                s->mv[0][0][0] = 0;
3795
                s->mv[0][0][1] = 0;
3796
                s->mb_skiped = !(s->obmc | s->loop_filter);
3797
                goto end;
3798
            }
3799
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3800
            //fprintf(stderr, "\tCBPC: %d", cbpc);
3801
            if (cbpc < 0){
3802
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3803
                return -1;
3804
            }
3805
        }while(cbpc == 20);
3806
        
3807
        dquant = cbpc & 8;
3808
        s->mb_intra = ((cbpc & 4) != 0);
3809
        if (s->mb_intra) goto intra;
3810
        
3811
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3812
        
3813
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3814
            cbpy ^= 0xF;
3815
        
3816
        cbp = (cbpc & 3) | (cbpy << 2);
3817
        if (dquant) {
3818
            h263_decode_dquant(s);
3819
        }
3820
        
3821
        s->mv_dir = MV_DIR_FORWARD;
3822
        if ((cbpc & 16) == 0) {
3823
            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
3824
            /* 16x16 motion prediction */
3825
            s->mv_type = MV_TYPE_16X16;
3826
            h263_pred_motion(s, 0, &pred_x, &pred_y);
3827
            if (s->umvplus)
3828
               mx = h263p_decode_umotion(s, pred_x);
3829
            else
3830
               mx = h263_decode_motion(s, pred_x, 1);
3831
            
3832
            if (mx >= 0xffff)
3833
                return -1;
3834
            
3835
            if (s->umvplus)
3836
               my = h263p_decode_umotion(s, pred_y);
3837
            else
3838
               my = h263_decode_motion(s, pred_y, 1);
3839
            
3840
            if (my >= 0xffff)
3841
                return -1;
3842
            s->mv[0][0][0] = mx;
3843
            s->mv[0][0][1] = my;
3844

    
3845
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3846
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3847
        } else {
3848
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3849
            s->mv_type = MV_TYPE_8X8;
3850
            for(i=0;i<4;i++) {
3851
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3852
                if (s->umvplus)
3853
                  mx = h263p_decode_umotion(s, pred_x);
3854
                else
3855
                  mx = h263_decode_motion(s, pred_x, 1);
3856
                if (mx >= 0xffff)
3857
                    return -1;
3858
                
3859
                if (s->umvplus)
3860
                  my = h263p_decode_umotion(s, pred_y);
3861
                else    
3862
                  my = h263_decode_motion(s, pred_y, 1);
3863
                if (my >= 0xffff)
3864
                    return -1;
3865
                s->mv[0][i][0] = mx;
3866
                s->mv[0][i][1] = my;
3867
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3868
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3869
                mot_val[0] = mx;
3870
                mot_val[1] = my;
3871
            }
3872
        }
3873

    
3874
        /* decode each block */
3875
        for (i = 0; i < 6; i++) {
3876
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3877
                return -1;
3878
            cbp+=cbp;
3879
        }
3880

    
3881
        if(s->obmc){
3882
            if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
3883
                preview_obmc(s);
3884
        }
3885
    } else if(s->pict_type==B_TYPE) {
3886
        int mb_type;
3887
        const int stride= s->b8_stride;
3888
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
3889
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
3890
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3891

    
3892
        //FIXME ugly 
3893
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= 
3894
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= 
3895
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= 
3896
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
3897

    
3898
        do{
3899
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
3900
            if (mb_type < 0){
3901
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
3902
                return -1;
3903
            }
3904

    
3905
            mb_type= h263_mb_type_b_map[ mb_type ];
3906
        }while(!mb_type);
3907

    
3908
        s->mb_intra = IS_INTRA(mb_type);
3909
        if(HAS_CBP(mb_type)){
3910
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
3911
            if(s->mb_intra){
3912
                dquant = IS_QUANT(mb_type);
3913
                goto intra;
3914
            }
3915

    
3916
            cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3917

    
3918
            if (cbpy < 0){
3919
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3920
                return -1;
3921
            }
3922
        
3923
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3924
                cbpy ^= 0xF;
3925
        
3926
            cbp = (cbpc & 3) | (cbpy << 2);
3927
        }else
3928
            cbp=0;
3929
            
3930
        assert(!s->mb_intra);
3931

    
3932
        if(IS_QUANT(mb_type)){
3933
            h263_decode_dquant(s);
3934
        }
3935

    
3936
        if(IS_DIRECT(mb_type)){
3937
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3938
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
3939
        }else{
3940
            s->mv_dir = 0;
3941
            s->mv_type= MV_TYPE_16X16;
3942
//FIXME UMV
3943

    
3944
            if(USES_LIST(mb_type, 0)){
3945
                int16_t *mot_val= h263_pred_motion2(s, 0, 0, &mx, &my);
3946
                s->mv_dir = MV_DIR_FORWARD;
3947

    
3948
                mx = h263_decode_motion(s, mx, 1);
3949
                my = h263_decode_motion(s, my, 1);
3950
                
3951
                s->mv[0][0][0] = mx;
3952
                s->mv[0][0][1] = my;
3953
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3954
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3955
            }
3956
    
3957
            if(USES_LIST(mb_type, 1)){
3958
                int16_t *mot_val= h263_pred_motion2(s, 0, 1, &mx, &my);
3959
                s->mv_dir |= MV_DIR_BACKWARD;
3960
                
3961
                mx = h263_decode_motion(s, mx, 1);
3962
                my = h263_decode_motion(s, my, 1);
3963

    
3964
                s->mv[1][0][0] = mx;
3965
                s->mv[1][0][1] = my;
3966
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3967
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3968
            }
3969
        }
3970
          
3971
        s->current_picture.mb_type[xy]= mb_type;
3972

    
3973
        /* decode each block */
3974
        for (i = 0; i < 6; i++) {
3975
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3976
                return -1;
3977
            cbp+=cbp;
3978
        }
3979
    } else { /* I-Frame */
3980
        do{
3981
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3982
            if (cbpc < 0){
3983
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3984
                return -1;
3985
            }
3986
        }while(cbpc == 8);
3987

    
3988
        dquant = cbpc & 4;
3989
        s->mb_intra = 1;
3990
intra:
3991
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3992
        if (s->h263_aic) {
3993
            s->ac_pred = get_bits1(&s->gb);
3994
            if(s->ac_pred){
3995
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3996
            
3997
                s->h263_aic_dir = get_bits1(&s->gb);
3998
            }
3999
        }else
4000
            s->ac_pred = 0;
4001
        
4002
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4003
        if(cbpy<0){
4004
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4005
            return -1;
4006
        }
4007
        cbp = (cbpc & 3) | (cbpy << 2);
4008
        if (dquant) {
4009
            h263_decode_dquant(s);
4010
        }
4011

    
4012
        /* decode each block */
4013
        for (i = 0; i < 6; i++) {
4014
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4015
                return -1;
4016
            cbp+=cbp;
4017
        }
4018
    }
4019
end:
4020

    
4021
        /* per-MB end of slice check */
4022
    {
4023
        int v= show_bits(&s->gb, 16);
4024
    
4025
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4026
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4027
        }
4028

    
4029
        if(v==0)
4030
            return SLICE_END;
4031
    }
4032

    
4033
    return SLICE_OK;     
4034
}
4035

    
4036
int ff_mpeg4_decode_mb(MpegEncContext *s,
4037
                      DCTELEM block[6][64])
4038
{
4039
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4040
    int16_t *mot_val;
4041
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4042
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4043
    
4044
    assert(s->h263_pred);
4045
    
4046
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4047
        do{
4048
            if (get_bits1(&s->gb)) {
4049
                /* skip mb */
4050
                s->mb_intra = 0;
4051
                for(i=0;i<6;i++)
4052
                    s->block_last_index[i] = -1;
4053
                s->mv_dir = MV_DIR_FORWARD;
4054
                s->mv_type = MV_TYPE_16X16;
4055
                if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4056
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4057
                    s->mcsel=1;
4058
                    s->mv[0][0][0]= get_amv(s, 0);
4059
                    s->mv[0][0][1]= get_amv(s, 1);
4060

    
4061
                    s->mb_skiped = 0;
4062
                }else{
4063
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4064
                    s->mcsel=0;
4065
                    s->mv[0][0][0] = 0;
4066
                    s->mv[0][0][1] = 0;
4067
                    s->mb_skiped = 1;
4068
                }
4069
                goto end;
4070
            }
4071
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4072
            //fprintf(stderr, "\tCBPC: %d", cbpc);
4073
            if (cbpc < 0){
4074
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4075
                return -1;
4076
            }
4077
        }while(cbpc == 20);
4078
        
4079
        dquant = cbpc & 8;
4080
        s->mb_intra = ((cbpc & 4) != 0);
4081
        if (s->mb_intra) goto intra;
4082
        
4083
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4084
            s->mcsel= get_bits1(&s->gb);
4085
        else s->mcsel= 0;
4086
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4087
        
4088
        cbp = (cbpc & 3) | (cbpy << 2);
4089
        if (dquant) {
4090
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4091
        }
4092
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4093
            s->interlaced_dct= get_bits1(&s->gb);
4094
        
4095
        s->mv_dir = MV_DIR_FORWARD;
4096
        if ((cbpc & 16) == 0) {
4097
            if(s->mcsel){
4098
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4099
                /* 16x16 global motion prediction */
4100
                s->mv_type = MV_TYPE_16X16;
4101
                mx= get_amv(s, 0);
4102
                my= get_amv(s, 1);
4103
                s->mv[0][0][0] = mx;
4104
                s->mv[0][0][1] = my;
4105
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4106
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; 
4107
                /* 16x8 field motion prediction */
4108
                s->mv_type= MV_TYPE_FIELD;
4109

    
4110
                s->field_select[0][0]= get_bits1(&s->gb);
4111
                s->field_select[0][1]= get_bits1(&s->gb);
4112

    
4113
                h263_pred_motion(s, 0, &pred_x, &pred_y);
4114
                
4115
                for(i=0; i<2; i++){
4116
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4117
                    if (mx >= 0xffff)
4118
                        return -1;
4119
            
4120
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4121
                    if (my >= 0xffff)
4122
                        return -1;
4123

    
4124
                    s->mv[0][i][0] = mx;
4125
                    s->mv[0][i][1] = my;
4126
                }
4127
            }else{
4128
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
4129
                /* 16x16 motion prediction */
4130
                s->mv_type = MV_TYPE_16X16;
4131
                h263_pred_motion(s, 0, &pred_x, &pred_y);
4132
                mx = h263_decode_motion(s, pred_x, s->f_code);
4133
            
4134
                if (mx >= 0xffff)
4135
                    return -1;
4136
            
4137
                my = h263_decode_motion(s, pred_y, s->f_code);
4138
            
4139
                if (my >= 0xffff)
4140
                    return -1;
4141
                s->mv[0][0][0] = mx;
4142
                s->mv[0][0][1] = my;
4143
            }
4144
        } else {
4145
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
4146
            s->mv_type = MV_TYPE_8X8;
4147
            for(i=0;i<4;i++) {
4148
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
4149
                mx = h263_decode_motion(s, pred_x, s->f_code);
4150
                if (mx >= 0xffff)
4151
                    return -1;
4152
                
4153
                my = h263_decode_motion(s, pred_y, s->f_code);
4154
                if (my >= 0xffff)
4155
                    return -1;
4156
                s->mv[0][i][0] = mx;
4157
                s->mv[0][i][1] = my;
4158
                mot_val[0] = mx;
4159
                mot_val[1] = my;
4160
            }
4161
        }
4162
    } else if(s->pict_type==B_TYPE) {
4163
        int modb1; // first bit of modb
4164
        int modb2; // second bit of modb
4165
        int mb_type;
4166

    
4167
        s->mb_intra = 0; //B-frames never contain intra blocks
4168
        s->mcsel=0;      //     ...               true gmc blocks
4169

    
4170
        if(s->mb_x==0){
4171
            for(i=0; i<2; i++){
4172
                s->last_mv[i][0][0]= 
4173
                s->last_mv[i][0][1]= 
4174
                s->last_mv[i][1][0]= 
4175
                s->last_mv[i][1][1]= 0;
4176
            }
4177
        }
4178

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

    
4182
        if(s->mb_skiped){
4183
                /* skip mb */
4184
            for(i=0;i<6;i++)
4185
                s->block_last_index[i] = -1;
4186

    
4187
            s->mv_dir = MV_DIR_FORWARD;
4188
            s->mv_type = MV_TYPE_16X16;
4189
            s->mv[0][0][0] = 0;
4190
            s->mv[0][0][1] = 0;
4191
            s->mv[1][0][0] = 0;
4192
            s->mv[1][0][1] = 0;
4193
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 
4194
            goto end;
4195
        }
4196

    
4197
        modb1= get_bits1(&s->gb); 
4198
        if(modb1){
4199
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4200
            cbp=0;
4201
        }else{
4202
            modb2= get_bits1(&s->gb);
4203
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4204
            if(mb_type<0){
4205
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4206
                return -1;
4207
            }
4208
            mb_type= mb_type_b_map[ mb_type ];
4209
            if(modb2) cbp= 0;
4210
            else      cbp= get_bits(&s->gb, 6);
4211

    
4212
            if ((!IS_DIRECT(mb_type)) && cbp) {
4213
                if(get_bits1(&s->gb)){
4214
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4215
                }
4216
            }
4217

    
4218
            if(!s->progressive_sequence){
4219
                if(cbp)
4220
                    s->interlaced_dct= get_bits1(&s->gb);
4221

    
4222
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4223
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4224
                    mb_type &= ~MB_TYPE_16x16;
4225

    
4226
                    if(USES_LIST(mb_type, 0)){
4227
                        s->field_select[0][0]= get_bits1(&s->gb);
4228
                        s->field_select[0][1]= get_bits1(&s->gb);
4229
                    }
4230
                    if(USES_LIST(mb_type, 1)){
4231
                        s->field_select[1][0]= get_bits1(&s->gb);
4232
                        s->field_select[1][1]= get_bits1(&s->gb);
4233
                    }
4234
                }
4235
            }
4236

    
4237
            s->mv_dir = 0;
4238
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4239
                s->mv_type= MV_TYPE_16X16;
4240

    
4241
                if(USES_LIST(mb_type, 0)){
4242
                    s->mv_dir = MV_DIR_FORWARD;
4243

    
4244
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4245
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4246
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4247
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4248
                }
4249
    
4250
                if(USES_LIST(mb_type, 1)){
4251
                    s->mv_dir |= MV_DIR_BACKWARD;
4252

    
4253
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4254
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4255
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4256
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4257
                }
4258
            }else if(!IS_DIRECT(mb_type)){
4259
                s->mv_type= MV_TYPE_FIELD;
4260

    
4261
                if(USES_LIST(mb_type, 0)){
4262
                    s->mv_dir = MV_DIR_FORWARD;
4263
                
4264
                    for(i=0; i<2; i++){
4265
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4266
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4267
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4268
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4269
                    }
4270
                }
4271
    
4272
                if(USES_LIST(mb_type, 1)){
4273
                    s->mv_dir |= MV_DIR_BACKWARD;
4274

    
4275
                    for(i=0; i<2; i++){
4276
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4277
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4278
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4279
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4280
                    }
4281
                }
4282
            }
4283
        }
4284
          
4285
        if(IS_DIRECT(mb_type)){
4286
            if(IS_SKIP(mb_type))
4287
                mx=my=0;
4288
            else{
4289
                mx = h263_decode_motion(s, 0, 1);
4290
                my = h263_decode_motion(s, 0, 1);
4291
            }
4292
 
4293
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4294
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4295
        }
4296
        s->current_picture.mb_type[xy]= mb_type;
4297
    } else { /* I-Frame */
4298
        do{
4299
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4300
            if (cbpc < 0){
4301
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4302
                return -1;
4303
            }
4304
        }while(cbpc == 8);
4305

    
4306
        dquant = cbpc & 4;
4307
        s->mb_intra = 1;
4308
intra:
4309
        s->ac_pred = get_bits1(&s->gb);
4310
        if(s->ac_pred)
4311
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4312
        else
4313
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4314
        
4315
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4316
        if(cbpy<0){
4317
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4318
            return -1;
4319
        }
4320
        cbp = (cbpc & 3) | (cbpy << 2);
4321
        if (dquant) {
4322
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4323
        }
4324
        
4325
        if(!s->progressive_sequence)
4326
            s->interlaced_dct= get_bits1(&s->gb);
4327

    
4328
        /* decode each block */
4329
        for (i = 0; i < 6; i++) {
4330
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4331
                return -1;
4332
            cbp+=cbp;
4333
        }
4334
        goto end;
4335
    }
4336

    
4337
    /* decode each block */
4338
    for (i = 0; i < 6; i++) {
4339
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4340
            return -1;
4341
        cbp+=cbp;
4342
    }
4343
end:
4344

    
4345
        /* per-MB end of slice check */
4346
    if(s->codec_id==CODEC_ID_MPEG4){
4347
        if(mpeg4_is_resync(s)){
4348
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4349
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4350
                return SLICE_OK;
4351
            return SLICE_END;
4352
        }
4353
    }
4354

    
4355
    return SLICE_OK;     
4356
}
4357

    
4358
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4359
{
4360
    int code, val, sign, shift, l;
4361
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4362

    
4363
    if (code == 0)
4364
        return pred;
4365
    if (code < 0)
4366
        return 0xffff;
4367

    
4368
    sign = get_bits1(&s->gb);
4369
    shift = f_code - 1;
4370
    val = code;
4371
    if (shift) {
4372
        val = (val - 1) << shift;
4373
        val |= get_bits(&s->gb, shift);
4374
        val++;
4375
    }
4376
    if (sign)
4377
        val = -val;
4378
    val += pred;
4379

    
4380
    /* modulo decoding */
4381
    if (!s->h263_long_vectors) {
4382
        l = 1 << (f_code + 4);
4383
        val = ((val + l)&(l*2-1)) - l;
4384
    } else {
4385
        /* horrible h263 long vector mode */
4386
        if (pred < -31 && val < -63)
4387
            val += 64;
4388
        if (pred > 32 && val > 63)
4389
            val -= 64;
4390
        
4391
    }
4392
    return val;
4393
}
4394

    
4395
/* Decodes RVLC of H.263+ UMV */
4396
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4397
{
4398
   int code = 0, sign;
4399
   
4400
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4401
      return pred;
4402
   
4403
   code = 2 + get_bits1(&s->gb);
4404
   
4405
   while (get_bits1(&s->gb))
4406
   {
4407
      code <<= 1;
4408
      code += get_bits1(&s->gb);
4409
   }
4410
   sign = code & 1;
4411
   code >>= 1;
4412
   
4413
   code = (sign) ? (pred - code) : (pred + code);
4414
#ifdef DEBUG
4415
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
4416
#endif
4417
   return code;   
4418

    
4419
}
4420

    
4421
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4422
                             int n, int coded)
4423
{
4424
    int code, level, i, j, last, run;
4425
    RLTable *rl = &rl_inter;
4426
    const uint8_t *scan_table;
4427
    GetBitContext gb= s->gb;
4428

    
4429
    scan_table = s->intra_scantable.permutated;
4430
    if (s->h263_aic && s->mb_intra) {
4431
        rl = &rl_intra_aic;
4432
        i = 0;
4433
        if (s->ac_pred) {
4434
            if (s->h263_aic_dir) 
4435
                scan_table = s->intra_v_scantable.permutated; /* left */
4436
            else
4437
                scan_table = s->intra_h_scantable.permutated; /* top */
4438
        }
4439
    } else if (s->mb_intra) {
4440
        /* DC coef */
4441
        if(s->codec_id == CODEC_ID_RV10){
4442
          if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4443
            int component, diff;
4444
            component = (n <= 3 ? 0 : n - 4 + 1);
4445
            level = s->last_dc[component];
4446
            if (s->rv10_first_dc_coded[component]) {
4447
                diff = rv_decode_dc(s, n);
4448
                if (diff == 0xffff)
4449
                    return -1;
4450
                level += diff;
4451
                level = level & 0xff; /* handle wrap round */
4452
                s->last_dc[component] = level;
4453
            } else {
4454
                s->rv10_first_dc_coded[component] = 1;
4455
            }
4456
          } else {
4457
                level = get_bits(&s->gb, 8);
4458
          }
4459
        }else{
4460
            level = get_bits(&s->gb, 8);
4461
            if((level&0x7F) == 0){
4462
                av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4463
                if(s->error_resilience >= FF_ER_COMPLIANT)
4464
                    return -1;
4465
            }
4466
            if (level == 255)
4467
                level = 128;
4468
        }
4469
        block[0] = level;
4470
        i = 1;
4471
    } else {
4472
        i = 0;
4473
    }
4474
    if (!coded) {
4475
        if (s->mb_intra && s->h263_aic)
4476
            goto not_coded;
4477
        s->block_last_index[n] = i - 1;
4478
        return 0;
4479
    }
4480
retry:
4481
    for(;;) {
4482
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4483
        if (code < 0){
4484
            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4485
            return -1;
4486
        }
4487
        if (code == rl->n) {
4488
            /* escape */
4489
            if (s->h263_flv > 1) {
4490
                int is11 = get_bits1(&s->gb);
4491
                last = get_bits1(&s->gb);
4492
                run = get_bits(&s->gb, 6);
4493
                if(is11){
4494
                    level = get_sbits(&s->gb, 11);
4495
                } else {
4496
                    level = get_sbits(&s->gb, 7);
4497
                }
4498
            } else {
4499
                last = get_bits1(&s->gb);
4500
                run = get_bits(&s->gb, 6);
4501
                level = (int8_t)get_bits(&s->gb, 8);
4502
                if(level == -128){
4503
                    if (s->codec_id == CODEC_ID_RV10) {
4504
                        /* XXX: should patch encoder too */
4505
                        level = get_sbits(&s->gb, 12);
4506
                    }else{
4507
                        level = get_bits(&s->gb, 5);
4508
                        level |= get_sbits(&s->gb, 6)<<5;
4509
                    }
4510
                }
4511
            }
4512
        } else {
4513
            run = rl->table_run[code];
4514
            level = rl->table_level[code];
4515
            last = code >= rl->last;
4516
            if (get_bits1(&s->gb))
4517
                level = -level;
4518
        }
4519
        i += run;
4520
        if (i >= 64){
4521
            if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4522
                //looks like a hack but no, its the way its supposed to work ...
4523
                rl = &rl_intra_aic;
4524
                i = 0;
4525
                s->gb= gb;
4526
                memset(block, 0, sizeof(DCTELEM)*64);
4527
                goto retry;
4528
            }
4529
            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
4530
            return -1;
4531
        }
4532
        j = scan_table[i];
4533
        block[j] = level;
4534
        if (last)
4535
            break;
4536
        i++;
4537
    }
4538
not_coded:    
4539
    if (s->mb_intra && s->h263_aic) {
4540
        h263_pred_acdc(s, block, n);
4541
        i = 63;
4542
    }
4543
    s->block_last_index[n] = i;
4544
    return 0;
4545
}
4546

    
4547
/**
4548
 * decodes the dc value.
4549
 * @param n block index (0-3 are luma, 4-5 are chroma)
4550
 * @param dir_ptr the prediction direction will be stored here
4551
 * @return the quantized dc
4552
 */
4553
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4554
{
4555
    int level, pred, code;
4556
    uint16_t *dc_val;
4557

    
4558
    if (n < 4) 
4559
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4560
    else 
4561
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4562
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4563
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4564
        return -1;
4565
    }
4566
    if (code == 0) {
4567
        level = 0;
4568
    } else {
4569
        if(IS_3IV1){
4570
            if(code==1)
4571
                level= 2*get_bits1(&s->gb)-1;
4572
            else{
4573
                if(get_bits1(&s->gb))
4574
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4575
                else
4576
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4577
            }
4578
        }else{
4579
            level = get_xbits(&s->gb, code);
4580
        }
4581

    
4582
        if (code > 8){
4583
            if(get_bits1(&s->gb)==0){ /* marker */
4584
                if(s->error_resilience>=2){
4585
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4586
                    return -1;
4587
                }
4588
            }
4589
        }
4590
    }
4591
    pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
4592
    level += pred;
4593
    if (level < 0){
4594
        if(s->error_resilience>=3){
4595
            av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
4596
            return -1;
4597
        }
4598
        level = 0;
4599
    }
4600
    if (n < 4) {
4601
        *dc_val = level * s->y_dc_scale;
4602
    } else {
4603
        *dc_val = level * s->c_dc_scale;
4604
    }
4605
    if(IS_3IV1)
4606
        *dc_val = level * 8;
4607
    
4608
    if(s->error_resilience>=3){
4609
        if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
4610
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
4611
            return -1;
4612
        }
4613
    }
4614
    return level;
4615
}
4616

    
4617
/**
4618
 * decodes a block.
4619
 * @return <0 if an error occured
4620
 */
4621
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4622
                              int n, int coded, int intra, int rvlc)
4623
{
4624
    int level, i, last, run;
4625
    int dc_pred_dir;
4626
    RLTable * rl;
4627
    RL_VLC_ELEM * rl_vlc;
4628
    const uint8_t * scan_table;
4629
    int qmul, qadd;
4630

    
4631
    //Note intra & rvlc should be optimized away if this is inlined
4632
    
4633
    if(intra) {
4634
      if(s->qscale < s->intra_dc_threshold){
4635
        /* DC coef */
4636
        if(s->partitioned_frame){
4637
            level = s->dc_val[0][ s->block_index[n] ];
4638
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4639
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4640
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4641
        }else{
4642
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4643
            if (level < 0)
4644
                return -1;
4645
        }
4646
        block[0] = level;
4647
        i = 0;
4648
      }else{
4649
            i = -1;
4650
      }  
4651
        if (!coded) 
4652
            goto not_coded;
4653
        
4654
        if(rvlc){        
4655
            rl = &rvlc_rl_intra;
4656
            rl_vlc = rvlc_rl_intra.rl_vlc[0];
4657
        }else{
4658
            rl = &rl_intra;
4659
            rl_vlc = rl_intra.rl_vlc[0];
4660
        }
4661
        if (s->ac_pred) {
4662
            if (dc_pred_dir == 0) 
4663
                scan_table = s->intra_v_scantable.permutated; /* left */
4664
            else
4665
                scan_table = s->intra_h_scantable.permutated; /* top */
4666
        } else {
4667
            scan_table = s->intra_scantable.permutated;
4668
        }
4669
        qmul=1;
4670
        qadd=0;
4671
    } else {
4672
        i = -1;
4673
        if (!coded) {
4674
            s->block_last_index[n] = i;
4675
            return 0;
4676
        }
4677
        if(rvlc) rl = &rvlc_rl_inter;
4678
        else     rl = &rl_inter;
4679
   
4680
        scan_table = s->intra_scantable.permutated;
4681

    
4682
        if(s->mpeg_quant){
4683
            qmul=1;
4684
            qadd=0;
4685
            if(rvlc){        
4686
                rl_vlc = rvlc_rl_inter.rl_vlc[0];        
4687
            }else{
4688
                rl_vlc = rl_inter.rl_vlc[0];        
4689
            }
4690
        }else{
4691
            qmul = s->qscale << 1;
4692
            qadd = (s->qscale - 1) | 1;
4693
            if(rvlc){        
4694
                rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];        
4695
            }else{
4696
                rl_vlc = rl_inter.rl_vlc[s->qscale];        
4697
            }
4698
        }
4699
    }
4700
  {
4701
    OPEN_READER(re, &s->gb);
4702
    for(;;) {
4703
        UPDATE_CACHE(re, &s->gb);
4704
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4705
        if (level==0) {
4706
          /* escape */                
4707
          if(rvlc){
4708
                if(SHOW_UBITS(re, &s->gb, 1)==0){
4709
                    av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4710
                    return -1;
4711
                }; SKIP_CACHE(re, &s->gb, 1);
4712
 
4713
                last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4714
                run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4715
                SKIP_COUNTER(re, &s->gb, 1+1+6);
4716
                UPDATE_CACHE(re, &s->gb);
4717
              
4718
                if(SHOW_UBITS(re, &s->gb, 1)==0){
4719
                    av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4720
                    return -1;
4721
                }; SKIP_CACHE(re, &s->gb, 1);
4722
 
4723
                level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4724
 
4725
                if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4726
                    av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4727
                    return -1;
4728
                }; SKIP_CACHE(re, &s->gb, 5);
4729

    
4730
                level=  level * qmul + qadd;
4731
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4732
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4733

    
4734
                i+= run + 1;
4735
                if(last) i+=192;
4736
          }else{
4737
            int cache;
4738
            cache= GET_CACHE(re, &s->gb);
4739

    
4740
            if(IS_3IV1) 
4741
                cache ^= 0xC0000000;
4742

    
4743
            if (cache&0x80000000) {
4744
                if (cache&0x40000000) {
4745
                    /* third escape */
4746
                    SKIP_CACHE(re, &s->gb, 2);
4747
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4748
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4749
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
4750
                    UPDATE_CACHE(re, &s->gb);
4751

    
4752
                    if(IS_3IV1){
4753
                        level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4754
                    }else{
4755
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
4756
                            av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4757
                            return -1;
4758
                        }; SKIP_CACHE(re, &s->gb, 1);
4759

    
4760
                        level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4761

    
4762
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
4763
                            av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4764
                            return -1;
4765
                        }; LAST_SKIP_CACHE(re, &s->gb, 1);
4766

    
4767
                        SKIP_COUNTER(re, &s->gb, 1+12+1);
4768
                    }
4769
 
4770
                    if(level*s->qscale>1024 || level*s->qscale<-1024){
4771
                        av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4772
                        return -1;
4773
                    }
4774
#if 0
4775
                    if(s->error_resilience >= FF_ER_COMPLIANT){