Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 8f2ab833

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1334
    if(s->mb_y){
1335
        int qp_dt, qp_t, qp_tc;
1336

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

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

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

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

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

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

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

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

    
1538
    wrap = s->block_wrap[0];
1539
    xy = s->block_index[block];
1540

    
1541
    mot_val = s->current_picture.motion_val[0][xy];
1542

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

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

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

    
1602
    mot_val = s->current_picture.motion_val[dir] + xy;
1603

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

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

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

    
1680
        assert(val>=-l && val<l);
1681

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

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

    
1699
}
1700

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

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

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

    
1756
                bit_size = s->f_code - 1;
1757
                range = 1 << bit_size;
1758

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

    
1771
            mv_penalty[f_code][mv+MAX_MV]= len;
1772
        }
1773
    }
1774

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

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

    
1787
#ifdef CONFIG_ENCODERS
1788

    
1789
static void init_uni_dc_tab(void)
1790
{
1791
    int level, uni_code, uni_len;
1792

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

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

    
1808
        /* luminance */
1809
        uni_code= DCtab_lum[size][0];
1810
        uni_len = DCtab_lum[size][1];
1811

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

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

    
1838
    }
1839
}
1840

    
1841
#endif //CONFIG_ENCODERS
1842

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

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

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

    
1933
    if (!done) {
1934
        done = 1;
1935

    
1936
        init_uni_dc_tab();
1937

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

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

    
1965
            s->avctx->extradata= av_malloc(1024);
1966
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
1967
            
1968
            mpeg4_encode_visual_object_header(s);
1969
            mpeg4_encode_vol_header(s, 0, 0);
1970

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

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

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

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

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

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

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

    
2138
#ifdef CONFIG_ENCODERS
2139

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

    
2152
/* must be called before writing the header */
2153
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2154
    int time_div, time_mod;
2155

    
2156
    if(s->current_picture_ptr->pts)
2157
        s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
2158
    else
2159
        s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
2160
    time_div= s->time/s->time_increment_resolution;
2161
    time_mod= s->time%s->time_increment_resolution;
2162

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

    
2173
static void mpeg4_encode_gop_header(MpegEncContext * s){
2174
    int hours, minutes, seconds;
2175
    
2176
    put_bits(&s->pb, 16, 0);
2177
    put_bits(&s->pb, 16, GOP_STARTCODE);
2178
    
2179
    seconds= s->time/s->time_increment_resolution;
2180
    minutes= seconds/60; seconds %= 60;
2181
    hours= minutes/60; minutes %= 60;
2182
    hours%=24;
2183

    
2184
    put_bits(&s->pb, 5, hours);
2185
    put_bits(&s->pb, 6, minutes);
2186
    put_bits(&s->pb, 1, 1);
2187
    put_bits(&s->pb, 6, seconds);
2188
    
2189
    put_bits(&s->pb, 1, 0); //closed gov == NO
2190
    put_bits(&s->pb, 1, 0); //broken link == NO
2191

    
2192
    ff_mpeg4_stuffing(&s->pb);
2193
}
2194

    
2195
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2196
    int profile_and_level_indication;
2197
    int vo_ver_id;
2198
    
2199
    if(s->max_b_frames || s->quarter_sample){
2200
        profile_and_level_indication= 0xF1; // adv simple level 1
2201
        vo_ver_id= 5;
2202
    }else{
2203
        profile_and_level_indication= 0x01; // simple level 1
2204
        vo_ver_id= 1;
2205
    }
2206
    //FIXME levels
2207

    
2208
    put_bits(&s->pb, 16, 0);
2209
    put_bits(&s->pb, 16, VOS_STARTCODE);
2210

    
2211
    put_bits(&s->pb, 8, profile_and_level_indication);
2212

    
2213
    put_bits(&s->pb, 16, 0);
2214
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2215
    
2216
    put_bits(&s->pb, 1, 1);
2217
        put_bits(&s->pb, 4, vo_ver_id);
2218
        put_bits(&s->pb, 3, 1); //priority
2219
 
2220
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
2221
    
2222
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2223

    
2224
    ff_mpeg4_stuffing(&s->pb);
2225
}
2226

    
2227
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2228
{
2229
    int vo_ver_id;
2230

    
2231
    if(s->max_b_frames || s->quarter_sample){
2232
        vo_ver_id= 5;
2233
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2234
    }else{
2235
        vo_ver_id= 1;
2236
        s->vo_type= SIMPLE_VO_TYPE;
2237
    }
2238

    
2239
    put_bits(&s->pb, 16, 0);
2240
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2241
    put_bits(&s->pb, 16, 0);
2242
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2243

    
2244
    put_bits(&s->pb, 1, 0);                /* random access vol */
2245
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
2246
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
2247
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
2248
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
2249
    
2250
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2251

    
2252
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2253
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2254
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2255
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2256
    }
2257

    
2258
    if(s->low_delay){
2259
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
2260
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
2261
        put_bits(&s->pb, 1, s->low_delay);
2262
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
2263
    }else{
2264
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
2265
    }
2266

    
2267
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
2268
    put_bits(&s->pb, 1, 1);                /* marker bit */
2269
    
2270
    put_bits(&s->pb, 16, s->time_increment_resolution);
2271
    if (s->time_increment_bits < 1)
2272
        s->time_increment_bits = 1;
2273
    put_bits(&s->pb, 1, 1);                /* marker bit */
2274
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
2275
    put_bits(&s->pb, 1, 1);                /* marker bit */
2276
    put_bits(&s->pb, 13, s->width);        /* vol width */
2277
    put_bits(&s->pb, 1, 1);                /* marker bit */
2278
    put_bits(&s->pb, 13, s->height);        /* vol height */
2279
    put_bits(&s->pb, 1, 1);                /* marker bit */
2280
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2281
    put_bits(&s->pb, 1, 1);                /* obmc disable */
2282
    if (vo_ver_id == 1) {
2283
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
2284
    }else{
2285
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
2286
    }
2287
    
2288
    s->quant_precision=5;
2289
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
2290
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
2291

    
2292
    if(s->mpeg_quant){
2293
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2294
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2295
    }
2296

    
2297
    if (vo_ver_id != 1)
2298
        put_bits(&s->pb, 1, s->quarter_sample);
2299
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
2300
    s->resync_marker= s->rtp_mode;
2301
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2302
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2303
    if(s->data_partitioning){
2304
        put_bits(&s->pb, 1, 0);                /* no rvlc */
2305
    }
2306

    
2307
    if (vo_ver_id != 1){
2308
        put_bits(&s->pb, 1, 0);                /* newpred */
2309
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
2310
    }
2311
    put_bits(&s->pb, 1, 0);                /* scalability */
2312
    
2313
    ff_mpeg4_stuffing(&s->pb);
2314

    
2315
    /* user data */
2316
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2317
        put_bits(&s->pb, 16, 0);
2318
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
2319
        put_string(&s->pb, LIBAVCODEC_IDENT);
2320
        ff_mpeg4_stuffing(&s->pb);
2321
    }
2322
}
2323

    
2324
/* write mpeg4 VOP header */
2325
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2326
{
2327
    int time_incr;
2328
    int time_div, time_mod;
2329
    
2330
    if(s->pict_type==I_TYPE){
2331
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2332
            if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2333
                mpeg4_encode_visual_object_header(s);
2334
            if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2335
                mpeg4_encode_vol_header(s, 0, 0);
2336
        }
2337
        mpeg4_encode_gop_header(s);
2338
    }
2339
    
2340
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2341

    
2342
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2343
    
2344
    put_bits(&s->pb, 16, 0);                /* vop header */
2345
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2346
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
2347

    
2348
    time_div= s->time/s->time_increment_resolution;
2349
    time_mod= s->time%s->time_increment_resolution;
2350
    time_incr= time_div - s->last_time_base;
2351
    while(time_incr--)
2352
        put_bits(&s->pb, 1, 1);
2353
        
2354
    put_bits(&s->pb, 1, 0);
2355

    
2356
    put_bits(&s->pb, 1, 1);        /* marker */
2357
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
2358
    put_bits(&s->pb, 1, 1);        /* marker */
2359
    put_bits(&s->pb, 1, 1);        /* vop coded */
2360
    if (    s->pict_type == P_TYPE 
2361
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2362
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
2363
    }
2364
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
2365
    if(!s->progressive_sequence){
2366
         put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2367
         put_bits(&s->pb, 1, s->alternate_scan);
2368
    }
2369
    //FIXME sprite stuff
2370

    
2371
    put_bits(&s->pb, 5, s->qscale);
2372

    
2373
    if (s->pict_type != I_TYPE)
2374
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
2375
    if (s->pict_type == B_TYPE)
2376
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
2377
    //    printf("****frame %d\n", picture_number);
2378

    
2379
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
2380
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2381
}
2382

    
2383
#endif //CONFIG_ENCODERS
2384

    
2385
/**
2386
 * set qscale and update qscale dependant variables.
2387
 */
2388
void ff_set_qscale(MpegEncContext * s, int qscale)
2389
{
2390
    if (qscale < 1)
2391
        qscale = 1;
2392
    else if (qscale > 31)
2393
        qscale = 31;
2394
        
2395
    s->qscale = qscale;
2396
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2397

    
2398
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2399
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2400
}
2401

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

    
2414
    /* find prediction */
2415
    if (n < 4) {
2416
        scale = s->y_dc_scale;
2417
    } else {
2418
        scale = s->c_dc_scale;
2419
    }
2420
    if(IS_3IV1)
2421
        scale= 8;
2422

    
2423
    wrap= s->block_wrap[n];
2424
    dc_val = s->dc_val[0] + s->block_index[n];
2425

    
2426
    /* B C
2427
     * A X 
2428
     */
2429
    a = dc_val[ - 1];
2430
    b = dc_val[ - 1 - wrap];
2431
    c = dc_val[ - wrap];
2432

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

    
2443
    if (abs(a - b) < abs(b - c)) {
2444
        pred = c;
2445
        *dir_ptr = 1; /* top */
2446
    } else {
2447
        pred = a;
2448
        *dir_ptr = 0; /* left */
2449
    }
2450
    /* we assume pred is positive */
2451
    pred = FASTDIV((pred + (scale >> 1)), scale);
2452

    
2453
    /* prepare address for prediction update */
2454
    *dc_val_ptr = &dc_val[0];
2455

    
2456
    return pred;
2457
}
2458

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

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

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

    
2513
    /* top copy */
2514
    for(i=1;i<8;i++)
2515
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2516

    
2517
}
2518

    
2519
#ifdef CONFIG_ENCODERS
2520

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

    
2547
    if (n < 4) {
2548
        /* luminance */
2549
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2550
    } else {
2551
        /* chrominance */
2552
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2553
    }
2554

    
2555
    /* encode remaining bits */
2556
    if (size > 0) {
2557
        if (level < 0)
2558
            level = (-level) ^ ((1 << size) - 1);
2559
        put_bits(&s->pb, size, level);
2560
        if (size > 8)
2561
            put_bits(&s->pb, 1, 1);
2562
    }
2563
#endif
2564
}
2565

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

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

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

    
2686
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2687
                               uint8_t *scan_table)
2688
{
2689
    int i, last_non_zero;
2690
    const RLTable *rl;
2691
    uint8_t *len_tab;
2692
    const int last_index = s->block_last_index[n];
2693
    int len=0;
2694

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

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

    
2740
#endif
2741

    
2742

    
2743
/***********************************************/
2744
/* decoding */
2745

    
2746
static VLC intra_MCBPC_vlc;
2747
static VLC inter_MCBPC_vlc;
2748
static VLC cbpy_vlc;
2749
static VLC mv_vlc;
2750
static VLC dc_lum, dc_chrom;
2751
static VLC sprite_trajectory;
2752
static VLC mb_type_b_vlc;
2753
static VLC h263_mbtype_b_vlc;
2754
static VLC cbpc_b_vlc;
2755

    
2756
void init_vlc_rl(RLTable *rl)
2757
{
2758
    int i, q;
2759
    
2760
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2761
             &rl->table_vlc[0][1], 4, 2,
2762
             &rl->table_vlc[0][0], 4, 2);
2763

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

    
2803
/* init vlcs */
2804

    
2805
/* XXX: find a better solution to handle static init */
2806
void h263_decode_init_vlc(MpegEncContext *s)
2807
{
2808
    static int done = 0;
2809

    
2810
    if (!done) {
2811
        done = 1;
2812

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

    
2856
/**
2857
 * Get the GOB height based on picture height.
2858
 */
2859
int ff_h263_get_gob_height(MpegEncContext *s){
2860
    if (s->height <= 400)
2861
        return 1;
2862
    else if (s->height <= 800)
2863
        return  2;
2864
    else
2865
        return 4;
2866
}
2867

    
2868
int ff_h263_decode_mba(MpegEncContext *s)
2869
{
2870
    int i, mb_pos;
2871

    
2872
    for(i=0; i<6; i++){
2873
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2874
    }
2875
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2876
    s->mb_x= mb_pos % s->mb_width;
2877
    s->mb_y= mb_pos / s->mb_width;
2878

    
2879
    return mb_pos;
2880
}
2881

    
2882
void ff_h263_encode_mba(MpegEncContext *s)
2883
{
2884
    int i, mb_pos;
2885

    
2886
    for(i=0; i<6; i++){
2887
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2888
    }
2889
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
2890
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
2891
}
2892

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

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

    
2917
    if(s->h263_slice_structured){
2918
        if(get_bits1(&s->gb)==0)
2919
            return -1;
2920

    
2921
        ff_h263_decode_mba(s);
2922

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

    
2942
    if(s->qscale==0) 
2943
        return -1;
2944

    
2945
    return 0;
2946
}
2947

    
2948
static inline void memsetw(short *tab, int val, int n)
2949
{
2950
    int i;
2951
    for(i=0;i<n;i++)
2952
        tab[i] = val;
2953
}
2954

    
2955
#ifdef CONFIG_ENCODERS
2956

    
2957
void ff_mpeg4_init_partitions(MpegEncContext *s)
2958
{
2959
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE);
2960
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE);
2961
}
2962

    
2963
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2964
{
2965
    const int pb2_len   = get_bit_count(&s->pb2   );
2966
    const int tex_pb_len= get_bit_count(&s->tex_pb);
2967
    const int bits= get_bit_count(&s->pb);
2968

    
2969
    if(s->pict_type==I_TYPE){
2970
        put_bits(&s->pb, 19, DC_MARKER);
2971
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2972
        s->i_tex_bits+= tex_pb_len;
2973
    }else{
2974
        put_bits(&s->pb, 17, MOTION_MARKER);
2975
        s->misc_bits+=17 + pb2_len;
2976
        s->mv_bits+= bits - s->last_bits;
2977
        s->p_tex_bits+= tex_pb_len;
2978
    }
2979

    
2980
    flush_put_bits(&s->pb2);
2981
    flush_put_bits(&s->tex_pb);
2982

    
2983
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2984
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2985
    s->last_bits= get_bit_count(&s->pb);
2986
}
2987

    
2988
#endif //CONFIG_ENCODERS
2989

    
2990
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2991
    switch(s->pict_type){
2992
        case I_TYPE:
2993
            return 16;
2994
        case P_TYPE:
2995
        case S_TYPE:
2996
            return s->f_code+15;
2997
        case B_TYPE:
2998
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2999
        default:
3000
            return -1;
3001
    }
3002
}
3003

    
3004
#ifdef CONFIG_ENCODERS
3005

    
3006
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3007
{
3008
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3009

    
3010
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3011
    put_bits(&s->pb, 1, 1);
3012
    
3013
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3014
    put_bits(&s->pb, s->quant_precision, s->qscale);
3015
    put_bits(&s->pb, 1, 0); /* no HEC */
3016
}
3017

    
3018
#endif //CONFIG_ENCODERS
3019

    
3020
/**
3021
 * check if the next stuff is a resync marker or the end.
3022
 * @return 0 if not
3023
 */
3024
static inline int mpeg4_is_resync(MpegEncContext *s){
3025
    const int bits_count= get_bits_count(&s->gb);
3026
    
3027
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3028
        return 0;
3029
    }
3030

    
3031
    if(bits_count + 8 >= s->gb.size_in_bits){
3032
        int v= show_bits(&s->gb, 8);
3033
        v|= 0x7F >> (7-(bits_count&7));
3034
                
3035
        if(v==0x7F)
3036
            return 1;
3037
    }else{
3038
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3039
            int len;
3040
            GetBitContext gb= s->gb;
3041
        
3042
            skip_bits(&s->gb, 1);
3043
            align_get_bits(&s->gb);
3044
        
3045
            for(len=0; len<32; len++){
3046
                if(get_bits1(&s->gb)) break;
3047
            }
3048

    
3049
            s->gb= gb;
3050

    
3051
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3052
                return 1;
3053
        }
3054
    }
3055
    return 0;
3056
}
3057

    
3058
/**
3059
 * decodes the next video packet.
3060
 * @return <0 if something went wrong
3061
 */
3062
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3063
{
3064
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3065
    int header_extension=0, mb_num, len;
3066
    
3067
    /* is there enough space left for a video packet + header */
3068
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3069

    
3070
    for(len=0; len<32; len++){
3071
        if(get_bits1(&s->gb)) break;
3072
    }
3073

    
3074
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3075
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3076
        return -1;
3077
    }
3078
    
3079
    if(s->shape != RECT_SHAPE){
3080
        header_extension= get_bits1(&s->gb);
3081
        //FIXME more stuff here
3082
    }
3083

    
3084
    mb_num= get_bits(&s->gb, mb_num_bits);
3085
    if(mb_num>=s->mb_num){
3086
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3087
        return -1;
3088
    }
3089
    if(s->pict_type == B_TYPE){
3090
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3091
        if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
3092
    }
3093
    
3094
    s->mb_x= mb_num % s->mb_width;
3095
    s->mb_y= mb_num / s->mb_width;
3096

    
3097
    if(s->shape != BIN_ONLY_SHAPE){
3098
        int qscale= get_bits(&s->gb, s->quant_precision); 
3099
        if(qscale)
3100
            s->chroma_qscale=s->qscale= qscale;
3101
    }
3102

    
3103
    if(s->shape == RECT_SHAPE){
3104
        header_extension= get_bits1(&s->gb);
3105
    }
3106
    if(header_extension){
3107
        int time_increment;
3108
        int time_incr=0;
3109

    
3110
        while (get_bits1(&s->gb) != 0) 
3111
            time_incr++;
3112

    
3113
        check_marker(&s->gb, "before time_increment in video packed header");
3114
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3115
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3116
        
3117
        skip_bits(&s->gb, 2); /* vop coding type */
3118
        //FIXME not rect stuff here
3119

    
3120
        if(s->shape != BIN_ONLY_SHAPE){
3121
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3122
//FIXME dont just ignore everything
3123
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3124
                mpeg4_decode_sprite_trajectory(s);
3125
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3126
            }
3127

    
3128
            //FIXME reduced res stuff here
3129
            
3130
            if (s->pict_type != I_TYPE) {
3131
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
3132
                if(f_code==0){
3133
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3134
                }
3135
            }
3136
            if (s->pict_type == B_TYPE) {
3137
                int b_code = get_bits(&s->gb, 3);
3138
                if(b_code==0){
3139
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3140
                }
3141
            }       
3142
        }
3143
    }
3144
    //FIXME new-pred stuff
3145
    
3146
//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));
3147

    
3148
    return 0;
3149
}
3150

    
3151
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3152
{
3153
    int c_wrap, c_xy, l_wrap, l_xy;
3154

    
3155
    l_wrap= s->block_wrap[0];
3156
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
3157
    c_wrap= s->block_wrap[4];
3158
    c_xy= s->mb_y*c_wrap + s->mb_x;
3159

    
3160
#if 0
3161
    /* clean DC */
3162
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3163
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3164
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3165
#endif
3166

    
3167
    /* clean AC */
3168
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3169
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3170
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3171

    
3172
    /* clean MV */
3173
    // we cant clear the MVs as they might be needed by a b frame
3174
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3175
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3176
    s->last_mv[0][0][0]=
3177
    s->last_mv[0][0][1]=
3178
    s->last_mv[1][0][0]=
3179
    s->last_mv[1][0][1]= 0;
3180
}
3181

    
3182
/**
3183
 * decodes the group of blocks / video packet header.
3184
 * @return <0 if no resync found
3185
 */
3186
int ff_h263_resync(MpegEncContext *s){
3187
    int left, ret;
3188
    
3189
    if(s->codec_id==CODEC_ID_MPEG4){
3190
        skip_bits1(&s->gb);
3191
        align_get_bits(&s->gb);
3192
    }
3193

    
3194
    if(show_bits(&s->gb, 16)==0){
3195
        if(s->codec_id==CODEC_ID_MPEG4)
3196
            ret= mpeg4_decode_video_packet_header(s);
3197
        else
3198
            ret= h263_decode_gob_header(s);
3199
        if(ret>=0)
3200
            return 0;
3201
    }
3202
    //ok, its not where its supposed to be ...
3203
    s->gb= s->last_resync_gb;
3204
    align_get_bits(&s->gb);
3205
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3206
    
3207
    for(;left>16+1+5+5; left-=8){ 
3208
        if(show_bits(&s->gb, 16)==0){
3209
            GetBitContext bak= s->gb;
3210

    
3211
            if(s->codec_id==CODEC_ID_MPEG4)
3212
                ret= mpeg4_decode_video_packet_header(s);
3213
            else
3214
                ret= h263_decode_gob_header(s);
3215
            if(ret>=0)
3216
                return 0;
3217

    
3218
            s->gb= bak;
3219
        }
3220
        skip_bits(&s->gb, 8);
3221
    }
3222
    
3223
    return -1;
3224
}
3225

    
3226
/**
3227
 * gets the average motion vector for a GMC MB.
3228
 * @param n either 0 for the x component or 1 for y
3229
 * @returns the average MV for a GMC MB
3230
 */
3231
static inline int get_amv(MpegEncContext *s, int n){
3232
    int x, y, mb_v, sum, dx, dy, shift;
3233
    int len = 1 << (s->f_code + 4);
3234
    const int a= s->sprite_warping_accuracy;
3235

    
3236
    if(s->real_sprite_warping_points==1){
3237
        if(s->divx_version==500 && s->divx_build==413)
3238
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3239
        else
3240
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3241
    }else{
3242
        dx= s->sprite_delta[n][0];
3243
        dy= s->sprite_delta[n][1];
3244
        shift= s->sprite_shift[0];
3245
        if(n) dy -= 1<<(shift + a + 1);
3246
        else  dx -= 1<<(shift + a + 1);
3247
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3248

    
3249
        sum=0;
3250
        for(y=0; y<16; y++){
3251
            int v;
3252
        
3253
            v= mb_v + dy*y;
3254
            //XXX FIXME optimize
3255
            for(x=0; x<16; x++){
3256
                sum+= v>>shift;
3257
                v+= dx;
3258
            }
3259
        }
3260
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3261
    }
3262

    
3263
    if      (sum < -len) sum= -len;
3264
    else if (sum >= len) sum= len-1;
3265

    
3266
    return sum;
3267
}
3268

    
3269
/**
3270
 * decodes first partition.
3271
 * @return number of MBs decoded or <0 if an error occured
3272
 */
3273
static int mpeg4_decode_partition_a(MpegEncContext *s){
3274
    int mb_num;
3275
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3276
    
3277
    /* decode first partition */
3278
    mb_num=0;
3279
    s->first_slice_line=1;
3280
    for(; s->mb_y<s->mb_height; s->mb_y++){
3281
        ff_init_block_index(s);
3282
        for(; s->mb_x<s->mb_width; s->mb_x++){
3283
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3284
            int cbpc;
3285
            int dir=0;
3286
            
3287
            mb_num++;
3288
            ff_update_block_index(s);
3289
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3290
                s->first_slice_line=0;
3291
            
3292
            if(s->pict_type==I_TYPE){
3293
                int i;
3294

    
3295
                if(show_bits_long(&s->gb, 19)==DC_MARKER){
3296
                    return mb_num-1;
3297
                }
3298

    
3299
                do{
3300
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3301
                    if (cbpc < 0){
3302
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3303
                        return -1;
3304
                    }
3305
                }while(cbpc == 8);
3306

    
3307
                s->cbp_table[xy]= cbpc & 3;
3308
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3309
                s->mb_intra = 1;
3310

    
3311
                if(cbpc & 4) {
3312
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3313
                }
3314
                s->current_picture.qscale_table[xy]= s->qscale;
3315

    
3316
                s->mbintra_table[xy]= 1;
3317
                for(i=0; i<6; i++){
3318
                    int dc_pred_dir;
3319
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3320
                    if(dc < 0){
3321
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3322
                        return -1;
3323
                    }
3324
                    dir<<=1;
3325
                    if(dc_pred_dir) dir|=1;
3326
                }
3327
                s->pred_dir_table[xy]= dir;
3328
            }else{ /* P/S_TYPE */
3329
                int mx, my, pred_x, pred_y, bits;
3330
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3331
                const int stride= s->block_wrap[0]*2;
3332

    
3333
//              do{ //FIXME
3334
                bits= show_bits(&s->gb, 17);
3335
                if(bits==MOTION_MARKER){
3336
                    return mb_num-1;
3337
                }
3338
                skip_bits1(&s->gb);
3339
                if(bits&0x10000){
3340
                    /* skip mb */
3341
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3342
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3343
                        mx= get_amv(s, 0);
3344
                        my= get_amv(s, 1);
3345
                    }else{
3346
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3347
                        mx=my=0;
3348
                    }
3349
                    mot_val[0       ]= mot_val[2       ]=
3350
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3351
                    mot_val[1       ]= mot_val[3       ]=
3352
                    mot_val[1+stride]= mot_val[3+stride]= my;
3353

    
3354
                    if(s->mbintra_table[xy])
3355
                        ff_clean_intra_table_entries(s);
3356
                    continue;
3357
                }
3358

    
3359
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3360
                if (cbpc < 0){
3361
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3362
                    return -1;
3363
                }
3364
//              }while(cbpc == 20);
3365

    
3366
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3367
    
3368
                s->mb_intra = ((cbpc & 4) != 0);
3369
        
3370
                if(s->mb_intra){
3371
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3372
                    s->mbintra_table[xy]= 1;
3373
                    mot_val[0       ]= mot_val[2       ]= 
3374
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3375
                    mot_val[1       ]= mot_val[3       ]=
3376
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3377
                }else{
3378
                    if(s->mbintra_table[xy])
3379
                        ff_clean_intra_table_entries(s);
3380

    
3381
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3382
                        s->mcsel= get_bits1(&s->gb);
3383
                    else s->mcsel= 0;
3384
        
3385
                    if ((cbpc & 16) == 0) {
3386
                        /* 16x16 motion prediction */
3387

    
3388
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
3389
                        if(!s->mcsel){
3390
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3391
                            if (mx >= 0xffff)
3392
                                return -1;
3393

    
3394
                            my = h263_decode_motion(s, pred_y, s->f_code);
3395
                            if (my >= 0xffff)
3396
                                return -1;
3397
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3398
                        } else {
3399
                            mx = get_amv(s, 0);
3400
                            my = get_amv(s, 1);
3401
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3402
                        }
3403

    
3404
                        mot_val[0       ]= mot_val[2       ] =
3405
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3406
                        mot_val[1       ]= mot_val[3       ]=
3407
                        mot_val[1+stride]= mot_val[3+stride]= my;
3408
                    } else {
3409
                        int i;
3410
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3411
                        for(i=0;i<4;i++) {
3412
                            int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
3413
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3414
                            if (mx >= 0xffff)
3415
                                return -1;
3416
                
3417
                            my = h263_decode_motion(s, pred_y, s->f_code);
3418
                            if (my >= 0xffff)
3419
                                return -1;
3420
                            mot_val[0] = mx;
3421
                            mot_val[1] = my;
3422
                        }
3423
                    }
3424
                }
3425
            }
3426
        }
3427
        s->mb_x= 0;
3428
    }
3429

    
3430
    return mb_num;
3431
}
3432

    
3433
/**
3434
 * decode second partition.
3435
 * @return <0 if an error occured
3436
 */
3437
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3438
    int mb_num=0;
3439
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3440

    
3441
    s->mb_x= s->resync_mb_x;
3442
    s->first_slice_line=1;
3443
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3444
        ff_init_block_index(s);
3445
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3446
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3447

    
3448
            mb_num++;
3449
            ff_update_block_index(s);
3450
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3451
                s->first_slice_line=0;
3452
            
3453
            if(s->pict_type==I_TYPE){
3454
                int ac_pred= get_bits1(&s->gb);
3455
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3456
                if(cbpy<0){
3457
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3458
                    return -1;
3459
                }
3460
                
3461
                s->cbp_table[xy]|= cbpy<<2;
3462
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3463
            }else{ /* P || S_TYPE */
3464
                if(IS_INTRA(s->current_picture.mb_type[xy])){          
3465
                    int dir=0,i;
3466
                    int ac_pred = get_bits1(&s->gb);
3467
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3468

    
3469
                    if(cbpy<0){
3470
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3471
                        return -1;
3472
                    }
3473
                    
3474
                    if(s->cbp_table[xy] & 8) {
3475
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3476
                    }
3477
                    s->current_picture.qscale_table[xy]= s->qscale;
3478

    
3479
                    for(i=0; i<6; i++){
3480
                        int dc_pred_dir;
3481
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3482
                        if(dc < 0){
3483
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3484
                            return -1;
3485
                        }
3486
                        dir<<=1;
3487
                        if(dc_pred_dir) dir|=1;
3488
                    }
3489
                    s->cbp_table[xy]&= 3; //remove dquant
3490
                    s->cbp_table[xy]|= cbpy<<2;
3491
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3492
                    s->pred_dir_table[xy]= dir;
3493
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3494
                    s->current_picture.qscale_table[xy]= s->qscale;
3495
                    s->cbp_table[xy]= 0;
3496
                }else{
3497
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3498

    
3499
                    if(cbpy<0){
3500
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3501
                        return -1;
3502
                    }
3503
                    
3504
                    if(s->cbp_table[xy] & 8) {
3505
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3506
                    }
3507
                    s->current_picture.qscale_table[xy]= s->qscale;
3508

    
3509
                    s->cbp_table[xy]&= 3; //remove dquant
3510
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3511
                }
3512
            }
3513
        }
3514
        if(mb_num >= mb_count) return 0;
3515
        s->mb_x= 0;
3516
    }
3517
    return 0;
3518
}
3519

    
3520
/**
3521
 * decodes the first & second partition
3522
 * @return <0 if error (and sets error type in the error_status_table)
3523
 */
3524
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3525
{
3526
    int mb_num;
3527
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3528
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3529
    
3530
    mb_num= mpeg4_decode_partition_a(s);    
3531
    if(mb_num<0){
3532
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3533
        return -1;
3534
    }
3535
    
3536
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3537
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3538
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3539
        return -1;
3540
    }
3541

    
3542
    s->mb_num_left= mb_num;
3543
        
3544
    if(s->pict_type==I_TYPE){
3545
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3546
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3547
            return -1;
3548
        }
3549
    }else{
3550
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3551
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3552
            return -1;
3553
        }
3554
    }
3555
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3556
    
3557
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3558
        if(s->pict_type==P_TYPE)
3559
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3560
        return -1;
3561
    }else{
3562
        if(s->pict_type==P_TYPE)
3563
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3564
    }
3565

    
3566
    return 0;        
3567
}
3568

    
3569
/**
3570
 * decode partition C of one MB.
3571
 * @return <0 if an error occured
3572
 */
3573
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3574
{
3575
    int cbp, mb_type;
3576
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3577

    
3578
    mb_type= s->current_picture.mb_type[xy];
3579
    cbp = s->cbp_table[xy];
3580

    
3581
    if(s->current_picture.qscale_table[xy] != s->qscale){
3582
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3583
    }
3584
    
3585
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3586
        int i;
3587
        for(i=0; i<4; i++){
3588
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3589
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3590
        }
3591
        s->mb_intra = IS_INTRA(mb_type);
3592

    
3593
        if (IS_SKIP(mb_type)) {
3594
            /* skip mb */
3595
            for(i=0;i<6;i++)
3596
                s->block_last_index[i] = -1;
3597
            s->mv_dir = MV_DIR_FORWARD;
3598
            s->mv_type = MV_TYPE_16X16;
3599
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3600
                s->mcsel=1;
3601
                s->mb_skiped = 0;
3602
            }else{
3603
                s->mcsel=0;
3604
                s->mb_skiped = 1;
3605
            }
3606
        }else if(s->mb_intra){
3607
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3608
        }else if(!s->mb_intra){
3609
//            s->mcsel= 0; //FIXME do we need to init that
3610
            
3611
            s->mv_dir = MV_DIR_FORWARD;
3612
            if (IS_8X8(mb_type)) {
3613
                s->mv_type = MV_TYPE_8X8;
3614
            } else {
3615
                s->mv_type = MV_TYPE_16X16;
3616
            }
3617
        }
3618
    } else { /* I-Frame */
3619
        s->mb_intra = 1;
3620
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3621
    }
3622

    
3623
    if (!IS_SKIP(mb_type)) {
3624
        int i;
3625
        /* decode each block */
3626
        for (i = 0; i < 6; i++) {
3627
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3628
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3629
                return -1;
3630
            }
3631
            cbp+=cbp;
3632
        }
3633
    }
3634

    
3635
    /* per-MB end of slice check */
3636

    
3637
    if(--s->mb_num_left <= 0){
3638
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3639
        if(mpeg4_is_resync(s))
3640
            return SLICE_END;
3641
        else
3642
            return SLICE_NOEND;     
3643
    }else{
3644
        if(mpeg4_is_resync(s)){
3645
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3646
            if(s->cbp_table[xy+delta])
3647
                return SLICE_END;
3648
        }
3649
        return SLICE_OK;
3650
    }
3651
}
3652

    
3653
/**
3654
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3655
 */
3656
static void preview_obmc(MpegEncContext *s){
3657
    GetBitContext gb= s->gb;
3658
    
3659
    int cbpc, i, pred_x, pred_y, mx, my;
3660
    int16_t *mot_val;
3661
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3662
    const int stride= s->block_wrap[0]*2;
3663
    
3664
    for(i=0; i<4; i++)
3665
        s->block_index[i]+= 2;
3666
    for(i=4; i<6; i++)
3667
        s->block_index[i]+= 1;
3668
    s->mb_x++;
3669
    
3670
    assert(s->pict_type == P_TYPE);
3671

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

    
3745
    s->gb= gb;
3746
}
3747

    
3748
static void h263_decode_dquant(MpegEncContext *s){
3749
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3750

    
3751
    if(s->modified_quant){
3752
        if(get_bits1(&s->gb))
3753
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3754
        else
3755
            s->qscale= get_bits(&s->gb, 5);
3756
    }else
3757
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3758
    ff_set_qscale(s, s->qscale);
3759
}
3760

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

    
3831
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3832
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3833
        } else {
3834
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3835
            s->mv_type = MV_TYPE_8X8;
3836
            for(i=0;i<4;i++) {
3837
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3838
                if (s->umvplus)
3839
                  mx = h263p_decode_umotion(s, pred_x);
3840
                else
3841
                  mx = h263_decode_motion(s, pred_x, 1);
3842
                if (mx >= 0xffff)
3843
                    return -1;
3844
                
3845
                if (s->umvplus)
3846
                  my = h263p_decode_umotion(s, pred_y);
3847
                else    
3848
                  my = h263_decode_motion(s, pred_y, 1);
3849
                if (my >= 0xffff)
3850
                    return -1;
3851
                s->mv[0][i][0] = mx;
3852
                s->mv[0][i][1] = my;
3853
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3854
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3855
                mot_val[0] = mx;
3856
                mot_val[1] = my;
3857
            }
3858
        }
3859

    
3860
        if(s->obmc){
3861
            if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width)
3862
                preview_obmc(s);
3863
        }
3864
    } else if(s->pict_type==B_TYPE) {
3865
        int mb_type;
3866
        const int stride= s->b8_stride;
3867
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
3868
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
3869
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3870

    
3871
        //FIXME ugly 
3872
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= 
3873
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= 
3874
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= 
3875
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
3876

    
3877
        do{
3878
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
3879
            if (mb_type < 0){
3880
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
3881
                return -1;
3882
            }
3883

    
3884
            mb_type= h263_mb_type_b_map[ mb_type ];
3885
        }while(!mb_type);
3886

    
3887
        s->mb_intra = IS_INTRA(mb_type);
3888
        if(HAS_CBP(mb_type)){
3889
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
3890
            if(s->mb_intra){
3891
                dquant = IS_QUANT(mb_type);
3892
                goto intra;
3893
            }
3894

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

    
3897
            if (cbpy < 0){
3898
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3899
                return -1;
3900
            }
3901
        
3902
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3903
                cbpy ^= 0xF;
3904
        
3905
            cbp = (cbpc & 3) | (cbpy << 2);
3906
        }else
3907
            cbp=0;
3908
            
3909
        assert(!s->mb_intra);
3910

    
3911
        if(IS_QUANT(mb_type)){
3912
            h263_decode_dquant(s);
3913
        }
3914

    
3915
        if(IS_DIRECT(mb_type)){
3916
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3917
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
3918
        }else{
3919
            s->mv_dir = 0;
3920
            s->mv_type= MV_TYPE_16X16;
3921
//FIXME UMV
3922

    
3923
            if(USES_LIST(mb_type, 0)){
3924
                int16_t *mot_val= h263_pred_motion2(s, 0, 0, &mx, &my);
3925
                s->mv_dir = MV_DIR_FORWARD;
3926

    
3927
                mx = h263_decode_motion(s, mx, 1);
3928
                my = h263_decode_motion(s, my, 1);
3929
                
3930
                s->mv[0][0][0] = mx;
3931
                s->mv[0][0][1] = my;
3932
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3933
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3934
            }
3935
    
3936
            if(USES_LIST(mb_type, 1)){
3937
                int16_t *mot_val= h263_pred_motion2(s, 0, 1, &mx, &my);
3938
                s->mv_dir |= MV_DIR_BACKWARD;
3939
                
3940
                mx = h263_decode_motion(s, mx, 1);
3941
                my = h263_decode_motion(s, my, 1);
3942

    
3943
                s->mv[1][0][0] = mx;
3944
                s->mv[1][0][1] = my;
3945
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3946
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3947
            }
3948
        }
3949
          
3950
        s->current_picture.mb_type[xy]= mb_type;
3951
    } else { /* I-Frame */
3952
        do{
3953
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3954
            if (cbpc < 0){
3955
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3956
                return -1;
3957
            }
3958
        }while(cbpc == 8);
3959

    
3960
        dquant = cbpc & 4;
3961
        s->mb_intra = 1;
3962
intra:
3963
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3964
        if (s->h263_aic) {
3965
            s->ac_pred = get_bits1(&s->gb);
3966
            if(s->ac_pred){
3967
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3968
            
3969
                s->h263_aic_dir = get_bits1(&s->gb);
3970
            }
3971
        }else
3972
            s->ac_pred = 0;
3973
        
3974
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3975
        if(cbpy<0){
3976
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3977
            return -1;
3978
        }
3979
        cbp = (cbpc & 3) | (cbpy << 2);
3980
        if (dquant) {
3981
            h263_decode_dquant(s);
3982
        }
3983
    }
3984

    
3985
    /* decode each block */
3986
    for (i = 0; i < 6; i++) {
3987
        if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3988
            return -1;
3989
        cbp+=cbp;
3990
    }
3991
end:
3992

    
3993
        /* per-MB end of slice check */
3994
    {
3995
        int v= show_bits(&s->gb, 16);
3996
    
3997
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3998
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3999
        }
4000

    
4001
        if(v==0)
4002
            return SLICE_END;
4003
    }
4004

    
4005
    return SLICE_OK;     
4006
}
4007

    
4008
int ff_mpeg4_decode_mb(MpegEncContext *s,
4009
                      DCTELEM block[6][64])
4010
{
4011
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4012
    int16_t *mot_val;
4013
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4014
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4015
    
4016
    assert(s->h263_pred);
4017
    
4018
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4019
        do{
4020
            if (get_bits1(&s->gb)) {
4021
                /* skip mb */
4022
                s->mb_intra = 0;
4023
                for(i=0;i<6;i++)
4024
                    s->block_last_index[i] = -1;
4025
                s->mv_dir = MV_DIR_FORWARD;
4026
                s->mv_type = MV_TYPE_16X16;
4027
                if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4028
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4029
                    s->mcsel=1;
4030
                    s->mv[0][0][0]= get_amv(s, 0);
4031
                    s->mv[0][0][1]= get_amv(s, 1);
4032

    
4033
                    s->mb_skiped = 0;
4034
                }else{
4035
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4036
                    s->mcsel=0;
4037
                    s->mv[0][0][0] = 0;
4038
                    s->mv[0][0][1] = 0;
4039
                    s->mb_skiped = 1;
4040
                }
4041
                goto end;
4042
            }
4043
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4044
            //fprintf(stderr, "\tCBPC: %d", cbpc);
4045
            if (cbpc < 0){
4046
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4047
                return -1;
4048
            }
4049
        }while(cbpc == 20);
4050
        
4051
        dquant = cbpc & 8;
4052
        s->mb_intra = ((cbpc & 4) != 0);
4053
        if (s->mb_intra) goto intra;
4054
        
4055
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4056
            s->mcsel= get_bits1(&s->gb);
4057
        else s->mcsel= 0;
4058
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4059
        
4060
        cbp = (cbpc & 3) | (cbpy << 2);
4061
        if (dquant) {
4062
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4063
        }
4064
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4065
            s->interlaced_dct= get_bits1(&s->gb);
4066
        
4067
        s->mv_dir = MV_DIR_FORWARD;
4068
        if ((cbpc & 16) == 0) {
4069
            if(s->mcsel){
4070
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4071
                /* 16x16 global motion prediction */
4072
                s->mv_type = MV_TYPE_16X16;
4073
                mx= get_amv(s, 0);
4074
                my= get_amv(s, 1);
4075
                s->mv[0][0][0] = mx;
4076
                s->mv[0][0][1] = my;
4077
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4078
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; 
4079
                /* 16x8 field motion prediction */
4080
                s->mv_type= MV_TYPE_FIELD;
4081

    
4082
                s->field_select[0][0]= get_bits1(&s->gb);
4083
                s->field_select[0][1]= get_bits1(&s->gb);
4084

    
4085
                h263_pred_motion(s, 0, &pred_x, &pred_y);
4086
                
4087
                for(i=0; i<2; i++){
4088
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4089
                    if (mx >= 0xffff)
4090
                        return -1;
4091
            
4092
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4093
                    if (my >= 0xffff)
4094
                        return -1;
4095

    
4096
                    s->mv[0][i][0] = mx;
4097
                    s->mv[0][i][1] = my;
4098
                }
4099
            }else{
4100
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
4101
                /* 16x16 motion prediction */
4102
                s->mv_type = MV_TYPE_16X16;
4103
                h263_pred_motion(s, 0, &pred_x, &pred_y);
4104
                mx = h263_decode_motion(s, pred_x, s->f_code);
4105
            
4106
                if (mx >= 0xffff)
4107
                    return -1;
4108
            
4109
                my = h263_decode_motion(s, pred_y, s->f_code);
4110
            
4111
                if (my >= 0xffff)
4112
                    return -1;
4113
                s->mv[0][0][0] = mx;
4114
                s->mv[0][0][1] = my;
4115
            }
4116
        } else {
4117
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
4118
            s->mv_type = MV_TYPE_8X8;
4119
            for(i=0;i<4;i++) {
4120
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
4121
                mx = h263_decode_motion(s, pred_x, s->f_code);
4122
                if (mx >= 0xffff)
4123
                    return -1;
4124
                
4125
                my = h263_decode_motion(s, pred_y, s->f_code);
4126
                if (my >= 0xffff)
4127
                    return -1;
4128
                s->mv[0][i][0] = mx;
4129
                s->mv[0][i][1] = my;
4130
                mot_val[0] = mx;
4131
                mot_val[1] = my;
4132
            }
4133
        }
4134
    } else if(s->pict_type==B_TYPE) {
4135
        int modb1; // first bit of modb
4136
        int modb2; // second bit of modb
4137
        int mb_type;
4138

    
4139
        s->mb_intra = 0; //B-frames never contain intra blocks
4140
        s->mcsel=0;      //     ...               true gmc blocks
4141

    
4142
        if(s->mb_x==0){
4143
            for(i=0; i<2; i++){
4144
                s->last_mv[i][0][0]= 
4145
                s->last_mv[i][0][1]= 
4146
                s->last_mv[i][1][0]= 
4147
                s->last_mv[i][1][1]= 0;
4148
            }
4149
        }
4150

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

    
4154
        if(s->mb_skiped){
4155
                /* skip mb */
4156
            for(i=0;i<6;i++)
4157
                s->block_last_index[i] = -1;
4158

    
4159
            s->mv_dir = MV_DIR_FORWARD;
4160
            s->mv_type = MV_TYPE_16X16;
4161
            s->mv[0][0][0] = 0;
4162
            s->mv[0][0][1] = 0;
4163
            s->mv[1][0][0] = 0;
4164
            s->mv[1][0][1] = 0;
4165
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 
4166
            goto end;
4167
        }
4168

    
4169
        modb1= get_bits1(&s->gb); 
4170
        if(modb1){
4171
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4172
            cbp=0;
4173
        }else{
4174
            modb2= get_bits1(&s->gb);
4175
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4176
            if(mb_type<0){
4177
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4178
                return -1;
4179
            }
4180
            mb_type= mb_type_b_map[ mb_type ];
4181
            if(modb2) cbp= 0;
4182
            else      cbp= get_bits(&s->gb, 6);
4183

    
4184
            if ((!IS_DIRECT(mb_type)) && cbp) {
4185
                if(get_bits1(&s->gb)){
4186
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4187
                }
4188
            }
4189

    
4190
            if(!s->progressive_sequence){
4191
                if(cbp)
4192
                    s->interlaced_dct= get_bits1(&s->gb);
4193

    
4194
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4195
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4196
                    mb_type &= ~MB_TYPE_16x16;
4197

    
4198
                    if(USES_LIST(mb_type, 0)){
4199
                        s->field_select[0][0]= get_bits1(&s->gb);
4200
                        s->field_select[0][1]= get_bits1(&s->gb);
4201
                    }
4202
                    if(USES_LIST(mb_type, 1)){
4203
                        s->field_select[1][0]= get_bits1(&s->gb);
4204
                        s->field_select[1][1]= get_bits1(&s->gb);
4205
                    }
4206
                }
4207
            }
4208

    
4209
            s->mv_dir = 0;
4210
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4211
                s->mv_type= MV_TYPE_16X16;
4212

    
4213
                if(USES_LIST(mb_type, 0)){
4214
                    s->mv_dir = MV_DIR_FORWARD;
4215

    
4216
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4217
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4218
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4219
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4220
                }
4221
    
4222
                if(USES_LIST(mb_type, 1)){
4223
                    s->mv_dir |= MV_DIR_BACKWARD;
4224

    
4225
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4226
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4227
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4228
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4229
                }
4230
            }else if(!IS_DIRECT(mb_type)){
4231
                s->mv_type= MV_TYPE_FIELD;
4232

    
4233
                if(USES_LIST(mb_type, 0)){
4234
                    s->mv_dir = MV_DIR_FORWARD;
4235
                
4236
                    for(i=0; i<2; i++){
4237
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4238
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4239
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4240
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4241
                    }
4242
                }
4243
    
4244
                if(USES_LIST(mb_type, 1)){
4245
                    s->mv_dir |= MV_DIR_BACKWARD;
4246

    
4247
                    for(i=0; i<2; i++){
4248
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4249
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4250
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4251
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4252
                    }
4253
                }
4254
            }
4255
        }
4256
          
4257
        if(IS_DIRECT(mb_type)){
4258
            if(IS_SKIP(mb_type))
4259
                mx=my=0;
4260
            else{
4261
                mx = h263_decode_motion(s, 0, 1);
4262
                my = h263_decode_motion(s, 0, 1);
4263
            }
4264
 
4265
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4266
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4267
        }
4268
        s->current_picture.mb_type[xy]= mb_type;
4269
    } else { /* I-Frame */
4270
        do{
4271
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4272
            if (cbpc < 0){
4273
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4274
                return -1;
4275
            }
4276
        }while(cbpc == 8);
4277

    
4278
        dquant = cbpc & 4;
4279
        s->mb_intra = 1;
4280
intra:
4281
        s->ac_pred = get_bits1(&s->gb);
4282
        if(s->ac_pred)
4283
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4284
        else
4285
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4286
        
4287
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4288
        if(cbpy<0){
4289
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4290
            return -1;
4291
        }
4292
        cbp = (cbpc & 3) | (cbpy << 2);
4293
        if (dquant) {
4294
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4295
        }
4296
        
4297
        if(!s->progressive_sequence)
4298
            s->interlaced_dct= get_bits1(&s->gb);
4299

    
4300
        /* decode each block */
4301
        for (i = 0; i < 6; i++) {
4302
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4303
                return -1;
4304
            cbp+=cbp;
4305
        }
4306
        goto end;
4307
    }
4308

    
4309
    /* decode each block */
4310
    for (i = 0; i < 6; i++) {
4311
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4312
            return -1;
4313
        cbp+=cbp;
4314
    }
4315
end:
4316

    
4317
        /* per-MB end of slice check */
4318
    if(s->codec_id==CODEC_ID_MPEG4){
4319
        if(mpeg4_is_resync(s)){
4320
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4321
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4322
                return SLICE_OK;
4323
            return SLICE_END;
4324
        }
4325
    }
4326

    
4327
    return SLICE_OK;     
4328
}
4329

    
4330
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4331
{
4332
    int code, val, sign, shift, l;
4333
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4334

    
4335
    if (code == 0)
4336
        return pred;
4337
    if (code < 0)
4338
        return 0xffff;
4339

    
4340
    sign = get_bits1(&s->gb);
4341
    shift = f_code - 1;
4342
    val = code;
4343
    if (shift) {
4344
        val = (val - 1) << shift;
4345
        val |= get_bits(&s->gb, shift);
4346
        val++;
4347
    }
4348
    if (sign)
4349
        val = -val;
4350
    val += pred;
4351

    
4352
    /* modulo decoding */
4353
    if (!s->h263_long_vectors) {
4354
        l = 1 << (f_code + 4);
4355
        val = ((val + l)&(l*2-1)) - l;
4356
    } else {
4357
        /* horrible h263 long vector mode */
4358
        if (pred < -31 && val < -63)
4359
            val += 64;
4360
        if (pred > 32 && val > 63)
4361
            val -= 64;
4362
        
4363
    }
4364
    return val;
4365
}
4366

    
4367
/* Decodes RVLC of H.263+ UMV */
4368
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4369
{
4370
   int code = 0, sign;
4371
   
4372
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4373
      return pred;
4374
   
4375
   code = 2 + get_bits1(&s->gb);
4376
   
4377
   while (get_bits1(&s->gb))
4378
   {
4379
      code <<= 1;
4380
      code += get_bits1(&s->gb);
4381
   }
4382
   sign = code & 1;
4383
   code >>= 1;
4384
   
4385
   code = (sign) ? (pred - code) : (pred + code);
4386
#ifdef DEBUG
4387
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
4388
#endif
4389
   return code;   
4390

    
4391
}
4392

    
4393
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4394
                             int n, int coded)
4395
{
4396
    int code, level, i, j, last, run;
4397
    RLTable *rl = &rl_inter;
4398
    const uint8_t *scan_table;
4399
    GetBitContext gb= s->gb;
4400

    
4401
    scan_table = s->intra_scantable.permutated;
4402
    if (s->h263_aic && s->mb_intra) {
4403
        rl = &rl_intra_aic;
4404
        i = 0;
4405
        if (s->ac_pred) {
4406
            if (s->h263_aic_dir) 
4407
                scan_table = s->intra_v_scantable.permutated; /* left */
4408
            else
4409
                scan_table = s->intra_h_scantable.permutated; /* top */
4410
        }
4411
    } else if (s->mb_intra) {
4412
        /* DC coef */
4413
        if(s->codec_id == CODEC_ID_RV10){
4414
          if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4415
            int component, diff;
4416
            component = (n <= 3 ? 0 : n - 4 + 1);
4417
            level = s->last_dc[component];
4418
            if (s->rv10_first_dc_coded[component]) {
4419
                diff = rv_decode_dc(s, n);
4420
                if (diff == 0xffff)
4421
                    return -1;
4422
                level += diff;
4423
                level = level & 0xff; /* handle wrap round */
4424
                s->last_dc[component] = level;
4425
            } else {
4426
                s->rv10_first_dc_coded[component] = 1;
4427
            }
4428
          } else {
4429
                level = get_bits(&s->gb, 8);
4430
          }
4431
        }else{
4432
            level = get_bits(&s->gb, 8);
4433
            if((level&0x7F) == 0){
4434
                av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4435
                return -1;
4436
            }
4437
            if (level == 255)
4438
                level = 128;
4439
        }
4440
        block[0] = level;
4441
        i = 1;
4442
    } else {
4443
        i = 0;
4444
    }
4445
    if (!coded) {
4446
        if (s->mb_intra && s->h263_aic)
4447
            goto not_coded;
4448
        s->block_last_index[n] = i - 1;
4449
        return 0;
4450
    }
4451
retry:
4452
    for(;;) {
4453
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4454
        if (code < 0){
4455
            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4456
            return -1;
4457
        }
4458
        if (code == rl->n) {
4459
            /* escape */
4460
            if (s->h263_flv > 1) {
4461
                int is11 = get_bits1(&s->gb);
4462
                last = get_bits1(&s->gb);
4463
                run = get_bits(&s->gb, 6);
4464
                if(is11){
4465
                    level = get_sbits(&s->gb, 11);
4466
                } else {
4467
                    level = get_sbits(&s->gb, 7);
4468
                }
4469
            } else {
4470
                last = get_bits1(&s->gb);
4471
                run = get_bits(&s->gb, 6);
4472
                level = (int8_t)get_bits(&s->gb, 8);
4473
                if(level == -128){
4474
                    if (s->codec_id == CODEC_ID_RV10) {
4475
                        /* XXX: should patch encoder too */
4476
                        level = get_sbits(&s->gb, 12);
4477
                    }else{
4478
                        level = get_bits(&s->gb, 5);
4479
                        level |= get_sbits(&s->gb, 6)<<5;
4480
                    }
4481
                }
4482
            }
4483
        } else {
4484
            run = rl->table_run[code];
4485
            level = rl->table_level[code];
4486
            last = code >= rl->last;
4487
            if (get_bits1(&s->gb))
4488
                level = -level;
4489
        }
4490
        i += run;
4491
        if (i >= 64){
4492
            if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4493
                //looks like a hack but no, its the way its supposed to work ...
4494
                rl = &rl_intra_aic;
4495
                i = 0;
4496
                s->gb= gb;
4497
                memset(block, 0, sizeof(DCTELEM)*64);
4498
                goto retry;
4499
            }
4500
            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
4501
            return -1;
4502
        }
4503
        j = scan_table[i];
4504
        block[j] = level;
4505
        if (last)
4506
            break;
4507
        i++;
4508
    }
4509
not_coded:    
4510
    if (s->mb_intra && s->h263_aic) {
4511
        h263_pred_acdc(s, block, n);
4512
        i = 63;
4513
    }
4514
    s->block_last_index[n] = i;
4515
    return 0;
4516
}
4517

    
4518
/**
4519
 * decodes the dc value.
4520
 * @param n block index (0-3 are luma, 4-5 are chroma)
4521
 * @param dir_ptr the prediction direction will be stored here
4522
 * @return the quantized dc
4523
 */
4524
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4525
{
4526
    int level, pred, code;
4527
    uint16_t *dc_val;
4528

    
4529
    if (n < 4) 
4530
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4531
    else 
4532
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4533
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4534
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4535
        return -1;
4536
    }
4537
    if (code == 0) {
4538
        level = 0;
4539
    } else {
4540
        if(IS_3IV1){
4541
            if(code==1)
4542
                level= 2*get_bits1(&s->gb)-1;
4543
            else{
4544
                if(get_bits1(&s->gb))
4545
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4546
                else
4547
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4548
            }
4549
        }else{
4550
            level = get_xbits(&s->gb, code);
4551
        }
4552

    
4553
        if (code > 8){
4554
            if(get_bits1(&s->gb)==0){ /* marker */
4555
                if(s->error_resilience>=2){
4556
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4557
                    return -1;
4558
                }
4559
            }
4560
        }
4561
    }
4562
    pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
4563
    level += pred;
4564
    if (level < 0){
4565
        if(s->error_resilience>=3){
4566
            av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
4567
            return -1;
4568
        }
4569
        level = 0;
4570
    }
4571
    if (n < 4) {
4572
        *dc_val = level * s->y_dc_scale;
4573
    } else {
4574
        *dc_val = level * s->c_dc_scale;
4575
    }
4576
    if(IS_3IV1)
4577
        *dc_val = level * 8;
4578
    
4579
    if(s->error_resilience>=3){
4580
        if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
4581
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
4582
            return -1;
4583
        }
4584
    }
4585
    return level;
4586
}
4587

    
4588
/**
4589
 * decodes a block.
4590
 * @return <0 if an error occured
4591
 */
4592
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4593
                              int n, int coded, int intra, int rvlc)
4594
{
4595
    int level, i, last, run;
4596
    int dc_pred_dir;
4597
    RLTable * rl;
4598
    RL_VLC_ELEM * rl_vlc;
4599
    const uint8_t * scan_table;
4600
    int qmul, qadd;
4601

    
4602
    //Note intra & rvlc should be optimized away if this is inlined
4603
    
4604
    if(intra) {
4605
      if(s->qscale < s->intra_dc_threshold){
4606
        /* DC coef */
4607
        if(s->partitioned_frame){
4608
            level = s->dc_val[0][ s->block_index[n] ];
4609
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4610
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4611
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4612
        }else{
4613
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4614
            if (level < 0)
4615
                return -1;
4616
        }
4617
        block[0] = level;
4618
        i = 0;
4619
      }else{
4620
            i = -1;
4621
      }  
4622
        if (!coded) 
4623
            goto not_coded;
4624
        
4625
        if(rvlc){        
4626
            rl = &rvlc_rl_intra;
4627
            rl_vlc = rvlc_rl_intra.rl_vlc[0];
4628
        }else{
4629
            rl = &rl_intra;
4630
            rl_vlc = rl_intra.rl_vlc[0];
4631
        }
4632
        if (s->ac_pred) {
4633
            if (dc_pred_dir == 0) 
4634
                scan_table = s->intra_v_scantable.permutated; /* left */
4635
            else
4636
                scan_table = s->intra_h_scantable.permutated; /* top */
4637
        } else {
4638
            scan_table = s->intra_scantable.permutated;
4639
        }
4640
        qmul=1;
4641
        qadd=0;
4642
    } else {
4643
        i = -1;
4644
        if (!coded) {
4645
            s->block_last_index[n] = i;
4646
            return 0;
4647
        }
4648
        if(rvlc) rl = &rvlc_rl_inter;
4649
        else     rl = &rl_inter;
4650
   
4651
        scan_table = s->intra_scantable.permutated;
4652

    
4653
        if(s->mpeg_quant){
4654
            qmul=1;
4655
            qadd=0;
4656
            if(rvlc){        
4657
                rl_vlc = rvlc_rl_inter.rl_vlc[0];        
4658
            }else{
4659
                rl_vlc = rl_inter.rl_vlc[0];        
4660
            }
4661
        }else{
4662
            qmul = s->qscale << 1;
4663
            qadd = (s->qscale - 1) | 1;
4664
            if(rvlc){        
4665
                rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];        
4666
            }else{
4667
                rl_vlc = rl_inter.rl_vlc[s->qscale];        
4668
            }
4669
        }
4670
    }
4671
  {
4672
    OPEN_READER(re, &s->gb);
4673
    for(;;) {
4674
        UPDATE_CACHE(re, &s->gb);
4675
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4676
        if (level==0) {
4677
          /* escape */                
4678
          if(rvlc){
4679
                if(SHOW_UBITS(re, &s->gb, 1)==0){
4680
                    av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4681
                    return -1;
4682
                }; SKIP_CACHE(re, &s->gb, 1);
4683
 
4684
                last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4685
                run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4686
                SKIP_COUNTER(re, &s->gb, 1+1+6);
4687
                UPDATE_CACHE(re, &s->gb);
4688
              
4689
                if(SHOW_UBITS(re, &s->gb, 1)==0){
4690
                    av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4691
                    return -1;
4692
                }; SKIP_CACHE(re, &s->gb, 1);
4693
 
4694
                level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4695
 
4696
                if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4697
                    av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4698
                    return -1;
4699
                }; SKIP_CACHE(re, &s->gb, 5);
4700

    
4701
                level=  level * qmul + qadd;
4702
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4703
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4704

    
4705
                i+= run + 1;
4706
                if(last) i+=192;
4707
          }else{
4708
            int cache;
4709
            cache= GET_CACHE(re, &s->gb);
4710

    
4711
            if(IS_3IV1) 
4712
                cache ^= 0xC0000000;
4713

    
4714
            if (cache&0x80000000) {
4715
                if (cache&0x40000000) {
4716
                    /* third escape */
4717
                    SKIP_CACHE(re, &s->gb, 2);
4718
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4719
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4720
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
4721
                    UPDATE_CACHE(re, &s->gb);
4722

    
4723
                    if(IS_3IV1){
4724
                        level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4725
                    }else{
4726
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
4727
                            av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4728
                            return -1;
4729
                        }; SKIP_CACHE(re, &s->gb, 1);
4730

    
4731
                        level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4732

    
4733
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
4734
                            av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4735
                            return -1;
4736
                        }; LAST_SKIP_CACHE(re, &s->gb, 1);
4737

    
4738
                        SKIP_COUNTER(re, &s->gb, 1+12+1);
4739
                    }
4740
 
4741
                    if(level*s->qscale>1024 || level*s->qscale<-1024){
4742
                        av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4743
                        return -1;
4744
                    }
4745
#if 0
4746
                    if(s->error_resilience >= FF_ER_COMPLIANT){
4747
                        const int abs_level= ABS(level);
4748
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4749
                            const int run1= run - rl->max_run[last][abs_level] - 1;
4750
                            if(abs_level <= rl->max_level[last][run]){
4751
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4752
                                return -1;
4753
                            }
4754
                            if(s->error_resilience > FF_ER_COMPLIANT){
4755
                                if(abs_level <= rl->max_level[last][run]*2){
4756
                                    fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
4757
                                    return -1;
4758
                                }
4759
                                if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4760
                                    fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
4761
                                    return -1;
4762
                                }
4763
                            }
4764
                        }
4765
                    }
4766
#endif
4767
                    if (level>0) level= level * qmul + qadd;
4768
                    else         level= level * qmul - qadd;
4769

    
4770
                    i+= run + 1;
4771
                    if(last) i+=