Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ da9c9637

History | View | Annotate | Download (208 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 h263p_encode_umotion(MpegEncContext * s, int val);
60
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
61
                               int n, int dc, uint8_t *scan_table, 
62
                               PutBitContext *dc_pb, PutBitContext *ac_pb);
63
#endif
64

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

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

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

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

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

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

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

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

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

    
136
#ifdef CONFIG_ENCODERS
137

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

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

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

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

    
157
      align_put_bits(&s->pb);
158

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

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

    
199
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
200
{
201
    int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
202
    int best_clock_code=1;
203
    int best_divisor=60;
204
    int best_error= INT_MAX;
205
   
206
    if(s->h263_plus){
207
        for(i=0; i<2; i++){
208
            int div, error;
209
            div= (s->avctx->frame_rate_base*1800000LL + 500LL*s->avctx->frame_rate) / ((1000LL+i)*s->avctx->frame_rate);
210
            div= clip(1, div, 127);
211
            error= ABS(s->avctx->frame_rate_base*1800000LL - (1000LL+i)*s->avctx->frame_rate*div);
212
            if(error < best_error){
213
                best_error= error;
214
                best_divisor= div;
215
                best_clock_code= i;
216
            }
217
        }
218
    }
219
    s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
220
    coded_frame_rate= 1800000;
221
    coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
222

    
223
    align_put_bits(&s->pb);
224

    
225
    /* Update the pointer to last GOB */
226
    s->ptr_lastgob = pbBufPtr(&s->pb);
227
    put_bits(&s->pb, 22, 0x20); /* PSC */
228
    temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->frame_rate_base / 
229
                         (coded_frame_rate_base * (int64_t)s->avctx->frame_rate);
230
    put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
231

    
232
    put_bits(&s->pb, 1, 1);        /* marker */
233
    put_bits(&s->pb, 1, 0);        /* h263 id */
234
    put_bits(&s->pb, 1, 0);        /* split screen off */
235
    put_bits(&s->pb, 1, 0);        /* camera  off */
236
    put_bits(&s->pb, 1, 0);        /* freeze picture release off */
237
    
238
    format = h263_get_picture_format(s->width, s->height);
239
    if (!s->h263_plus) {
240
        /* H.263v1 */
241
        put_bits(&s->pb, 3, format);
242
        put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
243
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
244
        of H.263v1 UMV implies to check the predicted MV after
245
        calculation of the current MB to see if we're on the limits */
246
        put_bits(&s->pb, 1, 0);        /* unrestricted motion vector: off */
247
        put_bits(&s->pb, 1, 0);        /* SAC: off */
248
        put_bits(&s->pb, 1, s->obmc);        /* advanced prediction mode */
249
        put_bits(&s->pb, 1, 0);        /* not PB frame */
250
        put_bits(&s->pb, 5, s->qscale);
251
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
252
    } else {
253
        int ufep=1;
254
        /* H.263v2 */
255
        /* H.263 Plus PTYPE */
256
        
257
        put_bits(&s->pb, 3, 7);
258
        put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
259
        if (format == 7)
260
            put_bits(&s->pb,3,6); /* Custom Source Format */
261
        else
262
            put_bits(&s->pb, 3, format);
263
            
264
        put_bits(&s->pb,1, s->custom_pcf);
265
        put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
266
        put_bits(&s->pb,1,0); /* SAC: off */
267
        put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
268
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
269
        put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
270
        put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
271
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
272
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
273
        put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
274
        put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
275
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
276
        put_bits(&s->pb,3,0); /* Reserved */
277
                
278
        put_bits(&s->pb, 3, s->pict_type == P_TYPE);
279
                
280
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
281
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
282
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
283
        put_bits(&s->pb,2,0); /* Reserved */
284
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
285
                
286
        /* This should be here if PLUSPTYPE */
287
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
288
                
289
                if (format == 7) {
290
            /* Custom Picture Format (CPFMT) */
291
            aspect_to_info(s, s->avctx->sample_aspect_ratio);
292

    
293
            put_bits(&s->pb,4,s->aspect_ratio_info);
294
            put_bits(&s->pb,9,(s->width >> 2) - 1);
295
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
296
            put_bits(&s->pb,9,(s->height >> 2));
297
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
298
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
299
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
300
            }
301
        }
302
        if(s->custom_pcf){
303
            if(ufep){
304
                put_bits(&s->pb, 1, best_clock_code);
305
                put_bits(&s->pb, 7, best_divisor);
306
            }
307
            put_bits(&s->pb, 2, (temp_ref>>8)&3);
308
        }
309
        
310
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
311
        if (s->umvplus)
312
//            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
313
//FIXME check actual requested range
314
            put_bits(&s->pb,2,1); /* unlimited */
315
        if(s->h263_slice_structured)
316
            put_bits(&s->pb,2,0); /* no weird submodes */
317

    
318
        put_bits(&s->pb, 5, s->qscale);
319
    }
320

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

    
323
    if(s->h263_slice_structured){
324
        put_bits(&s->pb, 1, 1);
325
        
326
        assert(s->mb_x == 0 && s->mb_y == 0);
327
        ff_h263_encode_mba(s);
328

    
329
        put_bits(&s->pb, 1, 1);
330
    }
331

    
332
    if(s->h263_aic){
333
         s->y_dc_scale_table= 
334
         s->c_dc_scale_table= ff_aic_dc_scale_table;
335
    }else{
336
        s->y_dc_scale_table=
337
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
338
    }
339
}
340

    
341
/**
342
 * Encodes a group of blocks header.
343
 */
344
void h263_encode_gob_header(MpegEncContext * s, int mb_line)
345
{
346
    put_bits(&s->pb, 17, 1); /* GBSC */
347

    
348
    if(s->h263_slice_structured){
349
        put_bits(&s->pb, 1, 1);
350

    
351
        ff_h263_encode_mba(s);
352

    
353
        if(s->mb_num > 1583)
354
            put_bits(&s->pb, 1, 1);
355
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
356
        put_bits(&s->pb, 1, 1);
357
        put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
358
    }else{
359
        int gob_number= mb_line / s->gob_index;
360

    
361
        put_bits(&s->pb, 5, gob_number); /* GN */
362
        put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
363
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
364
    }
365
}
366

    
367
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
368
    int last=0;
369
    int j;
370
    int rate=0;
371

    
372
    for(j=1; j<=block_last_index; j++){
373
        const int index= scantable[j];
374
        int level= block[index];
375
        if(level){
376
            level+= 64;
377
            if((level&(~127)) == 0){
378
                if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
379
                else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
380
            }else
381
                rate += s->ac_esc_length;
382
            level-= 64;
383

    
384
            last= j;
385
        }
386
    }
387
    
388
    return rate;
389
}
390

    
391
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
392
{
393
    int score= 0;
394
    int i, n;
395
    int8_t * const qscale_table= s->current_picture.qscale_table;
396

    
397
    memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
398
    
399
    for(n=0; n<6; n++){
400
        int16_t *ac_val, *ac_val1;
401
        
402
        score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
403

    
404
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
405
        ac_val1= ac_val;
406
        if(dir[n]){
407
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
408
            /* top prediction */
409
            ac_val-= s->block_wrap[n]*16;
410
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
411
                /* same qscale */
412
                for(i=1; i<8; i++){
413
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
414
                    block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
415
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
416
                    ac_val1[i+8]= level;
417
                }
418
            }else{
419
                /* different qscale, we must rescale */
420
                for(i=1; i<8; i++){
421
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
422
                    block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
423
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
424
                    ac_val1[i+8]= level;
425
                }
426
            }
427
            st[n]= s->intra_h_scantable.permutated;
428
        }else{
429
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
430
            /* left prediction */
431
            ac_val-= 16;
432
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
433
                /* same qscale */
434
                for(i=1; i<8; i++){
435
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
436
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
437
                    ac_val1[i  ]= level;
438
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
439
                }
440
            }else{
441
                /* different qscale, we must rescale */
442
                for(i=1; i<8; i++){
443
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
444
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
445
                    ac_val1[i  ]= level;
446
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
447
                }
448
            }
449
            st[n]= s->intra_v_scantable.permutated;
450
        }
451

    
452
        for(i=63; i>0; i--) //FIXME optimize
453
            if(block[n][ st[n][i] ]) break;
454
        s->block_last_index[n]= i;
455

    
456
        score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
457
    }
458

    
459
    return score < 0;
460
}
461

    
462
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
463
{
464
    int i, n;
465
    memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
466

    
467
    for(n=0; n<6; n++){
468
        int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
469

    
470
        st[n]= s->intra_scantable.permutated;
471
        if(dir[n]){
472
            /* top prediction */
473
            for(i=1; i<8; i++){
474
                block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
475
            }
476
        }else{
477
            /* left prediction */
478
            for(i=1; i<8; i++){
479
                block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
480
            }
481
        }
482
    }
483
}
484

    
485
/**
486
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
487
 */
488
void ff_clean_h263_qscales(MpegEncContext *s){
489
    int i;
490
    int8_t * const qscale_table= s->current_picture.qscale_table;
491
    
492
    for(i=1; i<s->mb_num; i++){
493
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
494
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
495
    }
496
    for(i=s->mb_num-2; i>=0; i--){
497
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
498
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
499
    }
500

    
501
    if(s->codec_id != CODEC_ID_H263P){
502
        for(i=1; i<s->mb_num; i++){
503
            int mb_xy= s->mb_index2xy[i];
504
        
505
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
506
                s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
507
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
508
            }
509
        }
510
    }
511
}
512

    
513
/**
514
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
515
 */
516
void ff_clean_mpeg4_qscales(MpegEncContext *s){
517
    int i;
518
    int8_t * const qscale_table= s->current_picture.qscale_table;
519

    
520
    ff_clean_h263_qscales(s);
521
    
522
    if(s->pict_type== B_TYPE){
523
        int odd=0;
524
        /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
525
           for the actual adaptive quantization */
526
        
527
        for(i=0; i<s->mb_num; i++){
528
            int mb_xy= s->mb_index2xy[i];
529
            odd += qscale_table[mb_xy]&1;
530
        }
531
        
532
        if(2*odd > s->mb_num) odd=1;
533
        else                  odd=0;
534
        
535
        for(i=0; i<s->mb_num; i++){
536
            int mb_xy= s->mb_index2xy[i];
537
            if((qscale_table[mb_xy]&1) != odd)
538
                qscale_table[mb_xy]++;
539
            if(qscale_table[mb_xy] > 31)
540
                qscale_table[mb_xy]= 31;
541
        }            
542
    
543
        for(i=1; i<s->mb_num; i++){
544
            int mb_xy= s->mb_index2xy[i];
545
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
546
                s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
547
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
548
            }
549
        }
550
    }
551
}
552

    
553
#endif //CONFIG_ENCODERS
554
/**
555
 *
556
 * @return the mb_type
557
 */
558
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
559
    const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
560
    const int colocated_mb_type= s->next_picture.mb_type[mb_index];
561
    int xy= s->block_index[0];
562
    uint16_t time_pp= s->pp_time;
563
    uint16_t time_pb= s->pb_time;
564
    int i;
565
    
566
    //FIXME avoid divides
567
    
568
    if(IS_8X8(colocated_mb_type)){
569
        s->mv_type = MV_TYPE_8X8;
570
        for(i=0; i<4; i++){
571
            xy= s->block_index[i];
572
            s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
573
            s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
574
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0]
575
                                : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
576
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1] 
577
                                : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
578
        }
579
        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
580
    } else if(IS_INTERLACED(colocated_mb_type)){
581
        s->mv_type = MV_TYPE_FIELD;
582
        for(i=0; i<2; i++){
583
            int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
584
            if(s->top_field_first){
585
                time_pp= s->pp_field_time - field_select + i;
586
                time_pb= s->pb_field_time - field_select + i;
587
            }else{
588
                time_pp= s->pp_field_time + field_select - i;
589
                time_pb= s->pb_field_time + field_select - i;
590
            }
591
            s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
592
            s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
593
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
594
                                : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
595
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] 
596
                                : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
597
        }
598
        return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
599
    }else{
600
        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;
601
        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;
602
        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]
603
                            : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
604
        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] 
605
                            : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
606
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
607
            s->mv_type= MV_TYPE_16X16;
608
        else
609
            s->mv_type= MV_TYPE_8X8;
610
        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
611
    }
612
}
613

    
614
void ff_h263_update_motion_val(MpegEncContext * s){
615
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
616
               //FIXME a lot of thet is only needed for !low_delay
617
    const int wrap = s->b8_stride;
618
    const int xy = s->block_index[0];
619
    
620
    s->current_picture.mbskip_table[mb_xy]= s->mb_skiped; 
621

    
622
    if(s->mv_type != MV_TYPE_8X8){
623
        int motion_x, motion_y;
624
        if (s->mb_intra) {
625
            motion_x = 0;
626
            motion_y = 0;
627
        } else if (s->mv_type == MV_TYPE_16X16) {
628
            motion_x = s->mv[0][0][0];
629
            motion_y = s->mv[0][0][1];
630
        } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
631
            int i;
632
            motion_x = s->mv[0][0][0] + s->mv[0][1][0];
633
            motion_y = s->mv[0][0][1] + s->mv[0][1][1];
634
            motion_x = (motion_x>>1) | (motion_x&1);
635
            for(i=0; i<2; i++){
636
                s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
637
                s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
638
            }
639
            s->current_picture.ref_index[0][xy           ]=
640
            s->current_picture.ref_index[0][xy        + 1]= s->field_select[0][0];
641
            s->current_picture.ref_index[0][xy + wrap    ]=
642
            s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
643
        }
644

    
645
        /* no update if 8X8 because it has been done during parsing */
646
        s->current_picture.motion_val[0][xy][0] = motion_x;
647
        s->current_picture.motion_val[0][xy][1] = motion_y;
648
        s->current_picture.motion_val[0][xy + 1][0] = motion_x;
649
        s->current_picture.motion_val[0][xy + 1][1] = motion_y;
650
        s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
651
        s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
652
        s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
653
        s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
654
    }
655

    
656
    if(s->encoding){ //FIXME encoding MUST be cleaned up
657
        if (s->mv_type == MV_TYPE_8X8) 
658
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
659
        else if(s->mb_intra)
660
            s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
661
        else
662
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
663
    }
664
}
665

    
666
#ifdef CONFIG_ENCODERS
667

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

    
673
    if(s->flags & CODEC_FLAG_CBP_RD){
674
        int best_cbpy_score= INT_MAX;
675
        int best_cbpc_score= INT_MAX;
676
        int cbpc = (-1), cbpy= (-1);
677
        const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
678
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
679

    
680
        for(i=0; i<4; i++){
681
            int score= inter_MCBPC_bits[i + offset] * lambda;
682
            if(i&1) score += s->coded_score[5];
683
            if(i&2) score += s->coded_score[4];
684

    
685
            if(score < best_cbpc_score){
686
                best_cbpc_score= score;
687
                cbpc= i;
688
            }
689
        }
690

    
691
        for(i=0; i<16; i++){
692
            int score= cbpy_tab[i ^ 0xF][1] * lambda;
693
            if(i&1) score += s->coded_score[3];
694
            if(i&2) score += s->coded_score[2];
695
            if(i&4) score += s->coded_score[1];
696
            if(i&8) score += s->coded_score[0];
697

    
698
            if(score < best_cbpy_score){
699
                best_cbpy_score= score;
700
                cbpy= i;
701
            }
702
        }
703
        cbp= cbpc + 4*cbpy;
704
        if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
705
            if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
706
                cbp= 0;
707
        }
708

    
709
        for (i = 0; i < 6; i++) {
710
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
711
                s->block_last_index[i]= -1;
712
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
713
            }
714
        }
715
    }else{
716
        cbp= 0;
717
        for (i = 0; i < 6; i++) {
718
            if (s->block_last_index[i] >= 0)
719
                cbp |= 1 << (5 - i);
720
        }
721
    }
722
    return cbp;
723
}
724

    
725
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
726
                            int motion_x, int motion_y, int mb_type){
727
    int cbp=0, i;
728

    
729
    if(s->flags & CODEC_FLAG_CBP_RD){
730
        int score=0;
731
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
732
        
733
        for(i=0; i<6; i++){
734
            if(s->coded_score[i] < 0){
735
                score += s->coded_score[i];
736
                cbp |= 1 << (5 - i);
737
            }
738
        }
739
        
740
        if(cbp){
741
            int zero_score= -6;
742
            if ((motion_x | motion_y | s->dquant | mb_type) == 0){
743
                zero_score-= 4; //2*MV + mb_type + cbp bit
744
            }
745

    
746
            zero_score*= lambda;
747
            if(zero_score <= score){
748
                cbp=0;
749
            }
750
        }
751

    
752
        for (i = 0; i < 6; i++) {
753
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
754
                s->block_last_index[i]= -1;
755
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
756
            }
757
        }
758
    }else{
759
        for (i = 0; i < 6; i++) {
760
            if (s->block_last_index[i] >= 0)
761
                cbp |= 1 << (5 - i);
762
        }
763
    }
764
    return cbp;
765
}
766

    
767
void mpeg4_encode_mb(MpegEncContext * s,
768
                    DCTELEM block[6][64],
769
                    int motion_x, int motion_y)
770
{
771
    int cbpc, cbpy, pred_x, pred_y;
772
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
773
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
774
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
775
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
776
    const int dquant_code[5]= {1,0,9,2,3};
777
    
778
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
779
    if (!s->mb_intra) {
780
        int i, cbp;
781
        
782
        if(s->pict_type==B_TYPE){
783
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
784
            int mb_type=  mb_type_table[s->mv_dir];
785

    
786
            if(s->mb_x==0){
787
                for(i=0; i<2; i++){
788
                    s->last_mv[i][0][0]= 
789
                    s->last_mv[i][0][1]= 
790
                    s->last_mv[i][1][0]= 
791
                    s->last_mv[i][1][1]= 0;
792
                }
793
            }
794
            
795
            assert(s->dquant>=-2 && s->dquant<=2);
796
            assert((s->dquant&1)==0);
797
            assert(mb_type>=0);
798

    
799
            /* nothing to do if this MB was skiped in the next P Frame */
800
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
801
                s->skip_count++;
802
                s->mv[0][0][0]= 
803
                s->mv[0][0][1]= 
804
                s->mv[1][0][0]= 
805
                s->mv[1][0][1]= 0;
806
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
807
                s->qscale -= s->dquant;
808
//                s->mb_skiped=1;
809

    
810
                return;
811
            }
812
            
813
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
814
            
815
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
816
                /* direct MB with MV={0,0} */
817
                assert(s->dquant==0);
818
                
819
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
820

    
821
                if(interleaved_stats){
822
                    s->misc_bits++;
823
                    s->last_bits++;
824
                }
825
                s->skip_count++;
826
                return;
827
            }
828
            
829
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
830
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
831
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
832
            if(cbp) put_bits(&s->pb, 6, cbp);
833
            
834
            if(cbp && mb_type){
835
                if(s->dquant)
836
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
837
                else
838
                    put_bits(&s->pb, 1, 0);
839
            }else
840
                s->qscale -= s->dquant;
841
            
842
            if(!s->progressive_sequence){
843
                if(cbp)
844
                    put_bits(&s->pb, 1, s->interlaced_dct);
845
                if(mb_type) // not diect mode
846
                    put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
847
            }
848

    
849
            if(interleaved_stats){
850
                s->misc_bits+= get_bits_diff(s);
851
            }
852

    
853
            if(mb_type == 0){
854
                assert(s->mv_dir & MV_DIRECT);
855
                ff_h263_encode_motion(s, motion_x, 1);
856
                ff_h263_encode_motion(s, motion_y, 1);                
857
                s->b_count++;
858
                s->f_count++;
859
            }else{
860
                assert(mb_type > 0 && mb_type < 4);
861
                if(s->mv_type != MV_TYPE_FIELD){
862
                    if(s->mv_dir & MV_DIR_FORWARD){
863
                        ff_h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
864
                        ff_h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
865
                        s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
866
                        s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
867
                        s->f_count++;
868
                    }
869
                    if(s->mv_dir & MV_DIR_BACKWARD){
870
                        ff_h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
871
                        ff_h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
872
                        s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
873
                        s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
874
                        s->b_count++;
875
                    }
876
                }else{
877
                    if(s->mv_dir & MV_DIR_FORWARD){
878
                        put_bits(&s->pb, 1, s->field_select[0][0]);
879
                        put_bits(&s->pb, 1, s->field_select[0][1]);
880
                    }
881
                    if(s->mv_dir & MV_DIR_BACKWARD){
882
                        put_bits(&s->pb, 1, s->field_select[1][0]);
883
                        put_bits(&s->pb, 1, s->field_select[1][1]);
884
                    }
885
                    if(s->mv_dir & MV_DIR_FORWARD){
886
                        for(i=0; i<2; i++){
887
                            ff_h263_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0]  , s->f_code);
888
                            ff_h263_encode_motion(s, s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
889
                            s->last_mv[0][i][0]= s->mv[0][i][0];
890
                            s->last_mv[0][i][1]= s->mv[0][i][1]*2;
891
                        }
892
                        s->f_count++;
893
                    }
894
                    if(s->mv_dir & MV_DIR_BACKWARD){
895
                        for(i=0; i<2; i++){
896
                            ff_h263_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0]  , s->b_code);
897
                            ff_h263_encode_motion(s, s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
898
                            s->last_mv[1][i][0]= s->mv[1][i][0];
899
                            s->last_mv[1][i][1]= s->mv[1][i][1]*2;
900
                        }
901
                        s->b_count++;
902
                    }
903
                }
904
            }
905

    
906
            if(interleaved_stats){
907
                s->mv_bits+= get_bits_diff(s);
908
            }
909

    
910
            /* encode each block */
911
            for (i = 0; i < 6; i++) {
912
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
913
            }
914

    
915
            if(interleaved_stats){
916
                s->p_tex_bits+= get_bits_diff(s);
917
            }
918

    
919
        }else{ /* s->pict_type==B_TYPE */
920
            cbp= get_p_cbp(s, block, motion_x, motion_y);
921
        
922
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
923
                /* check if the B frames can skip it too, as we must skip it if we skip here 
924
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
925
                if(s->max_b_frames>0){
926
                    int i;
927
                    int x,y, offset;
928
                    uint8_t *p_pic;
929

    
930
                    x= s->mb_x*16;
931
                    y= s->mb_y*16;
932
                    if(x+16 > s->width)  x= s->width-16;
933
                    if(y+16 > s->height) y= s->height-16;
934

    
935
                    offset= x + y*s->linesize;
936
                    p_pic= s->new_picture.data[0] + offset;
937
                    
938
                    s->mb_skiped=1;
939
                    for(i=0; i<s->max_b_frames; i++){
940
                        uint8_t *b_pic;
941
                        int diff;
942
                        Picture *pic= s->reordered_input_picture[i+1];
943

    
944
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
945

    
946
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
947
                        diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
948
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
949
                            s->mb_skiped=0;
950
                            break;
951
                        }
952
                    }
953
                }else
954
                    s->mb_skiped=1; 
955

    
956
                if(s->mb_skiped==1){
957
                    /* skip macroblock */
958
                    put_bits(&s->pb, 1, 1);
959

    
960
                    if(interleaved_stats){
961
                        s->misc_bits++;
962
                        s->last_bits++;
963
                    }
964
                    s->skip_count++;
965
                    
966
                    return;
967
                }
968
            }
969

    
970
            put_bits(&s->pb, 1, 0);        /* mb coded */
971
            cbpc = cbp & 3;
972
            cbpy = cbp >> 2;
973
            cbpy ^= 0xf;
974
            if(s->mv_type==MV_TYPE_16X16){
975
                if(s->dquant) cbpc+= 8;
976
                put_bits(&s->pb,
977
                        inter_MCBPC_bits[cbpc],
978
                        inter_MCBPC_code[cbpc]);
979

    
980
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
981
                if(s->dquant)
982
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
983

    
984
                if(!s->progressive_sequence){
985
                    if(cbp)
986
                        put_bits(pb2, 1, s->interlaced_dct);
987
                    put_bits(pb2, 1, 0);
988
                }
989
                    
990
                if(interleaved_stats){
991
                    s->misc_bits+= get_bits_diff(s);
992
                }
993

    
994
                /* motion vectors: 16x16 mode */
995
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
996
            
997
                ff_h263_encode_motion(s, motion_x - pred_x, s->f_code);
998
                ff_h263_encode_motion(s, motion_y - pred_y, s->f_code);
999
            }else if(s->mv_type==MV_TYPE_FIELD){
1000
                if(s->dquant) cbpc+= 8;
1001
                put_bits(&s->pb,
1002
                        inter_MCBPC_bits[cbpc],
1003
                        inter_MCBPC_code[cbpc]);
1004

    
1005
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1006
                if(s->dquant)
1007
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
1008

    
1009
                assert(!s->progressive_sequence);
1010
                if(cbp)
1011
                    put_bits(pb2, 1, s->interlaced_dct);
1012
                put_bits(pb2, 1, 1);
1013
                    
1014
                if(interleaved_stats){
1015
                    s->misc_bits+= get_bits_diff(s);
1016
                }
1017

    
1018
                /* motion vectors: 16x8 interlaced mode */
1019
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1020
                pred_y /=2;
1021
                
1022
                put_bits(&s->pb, 1, s->field_select[0][0]);
1023
                put_bits(&s->pb, 1, s->field_select[0][1]);
1024
            
1025
                ff_h263_encode_motion(s, s->mv[0][0][0] - pred_x, s->f_code);
1026
                ff_h263_encode_motion(s, s->mv[0][0][1] - pred_y, s->f_code);
1027
                ff_h263_encode_motion(s, s->mv[0][1][0] - pred_x, s->f_code);
1028
                ff_h263_encode_motion(s, s->mv[0][1][1] - pred_y, s->f_code);
1029
            }else{
1030
                assert(s->mv_type==MV_TYPE_8X8);
1031
                put_bits(&s->pb,
1032
                        inter_MCBPC_bits[cbpc+16],
1033
                        inter_MCBPC_code[cbpc+16]);
1034
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1035

    
1036
                if(!s->progressive_sequence){
1037
                    if(cbp)
1038
                        put_bits(pb2, 1, s->interlaced_dct);
1039
                }
1040
    
1041
                if(interleaved_stats){
1042
                    s->misc_bits+= get_bits_diff(s);
1043
                }
1044

    
1045
                for(i=0; i<4; i++){
1046
                    /* motion vectors: 8x8 mode*/
1047
                    h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1048

    
1049
                    ff_h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, s->f_code);
1050
                    ff_h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1051
                }
1052
            }
1053

    
1054
            if(interleaved_stats){ 
1055
                s->mv_bits+= get_bits_diff(s);
1056
            }
1057

    
1058
            /* encode each block */
1059
            for (i = 0; i < 6; i++) {
1060
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
1061
            }
1062

    
1063
            if(interleaved_stats){
1064
                s->p_tex_bits+= get_bits_diff(s);
1065
            }
1066
            s->f_count++;
1067
        }
1068
    } else {
1069
        int cbp;
1070
        int dc_diff[6];   //dc values with the dc prediction subtracted 
1071
        int dir[6];  //prediction direction
1072
        int zigzag_last_index[6];
1073
        uint8_t *scan_table[6];
1074
        int i;
1075

    
1076
        for(i=0; i<6; i++){
1077
            dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1078
        }
1079

    
1080
        if(s->flags & CODEC_FLAG_AC_PRED){
1081
            s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1082
            if(!s->ac_pred)
1083
                restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1084
        }else{
1085
            for(i=0; i<6; i++)
1086
                scan_table[i]= s->intra_scantable.permutated;
1087
        }
1088

    
1089
        /* compute cbp */
1090
        cbp = 0;
1091
        for (i = 0; i < 6; i++) {
1092
            if (s->block_last_index[i] >= 1)
1093
                cbp |= 1 << (5 - i);
1094
        }
1095

    
1096
        cbpc = cbp & 3;
1097
        if (s->pict_type == I_TYPE) {
1098
            if(s->dquant) cbpc+=4;
1099
            put_bits(&s->pb,
1100
                intra_MCBPC_bits[cbpc],
1101
                intra_MCBPC_code[cbpc]);
1102
        } else {
1103
            if(s->dquant) cbpc+=8;
1104
            put_bits(&s->pb, 1, 0);        /* mb coded */
1105
            put_bits(&s->pb,
1106
                inter_MCBPC_bits[cbpc + 4],
1107
                inter_MCBPC_code[cbpc + 4]);
1108
        }
1109
        put_bits(pb2, 1, s->ac_pred);
1110
        cbpy = cbp >> 2;
1111
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1112
        if(s->dquant)
1113
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1114

    
1115
        if(!s->progressive_sequence){
1116
            put_bits(dc_pb, 1, s->interlaced_dct);
1117
        }
1118

    
1119
        if(interleaved_stats){
1120
            s->misc_bits+= get_bits_diff(s);
1121
        }
1122

    
1123
        /* encode each block */
1124
        for (i = 0; i < 6; i++) {
1125
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
1126
        }
1127

    
1128
        if(interleaved_stats){
1129
            s->i_tex_bits+= get_bits_diff(s);
1130
        }
1131
        s->i_count++;
1132

    
1133
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1134
        if(s->ac_pred)
1135
            restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1136
    }
1137
}
1138

    
1139
void h263_encode_mb(MpegEncContext * s,
1140
                    DCTELEM block[6][64],
1141
                    int motion_x, int motion_y)
1142
{
1143
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
1144
    int16_t pred_dc;
1145
    int16_t rec_intradc[6];
1146
    uint16_t *dc_ptr[6];
1147
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1148
    const int dquant_code[5]= {1,0,9,2,3};
1149
           
1150
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1151
    if (!s->mb_intra) {
1152
        /* compute cbp */
1153
        cbp= get_p_cbp(s, block, motion_x, motion_y);
1154

    
1155
        if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1156
            /* skip macroblock */
1157
            put_bits(&s->pb, 1, 1);
1158
            if(interleaved_stats){
1159
                s->misc_bits++;
1160
                s->last_bits++;
1161
            }
1162
            s->skip_count++;
1163

    
1164
            return;
1165
        }
1166
        put_bits(&s->pb, 1, 0);        /* mb coded */
1167
        
1168
        cbpc = cbp & 3;
1169
        cbpy = cbp >> 2;
1170
        if(s->alt_inter_vlc==0 || cbpc!=3)
1171
            cbpy ^= 0xF;
1172
        if(s->dquant) cbpc+= 8;
1173
        if(s->mv_type==MV_TYPE_16X16){
1174
            put_bits(&s->pb,
1175
                    inter_MCBPC_bits[cbpc],
1176
                    inter_MCBPC_code[cbpc]);
1177

    
1178
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1179
            if(s->dquant)
1180
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1181
                
1182
            if(interleaved_stats){
1183
                s->misc_bits+= get_bits_diff(s);
1184
            }
1185

    
1186
            /* motion vectors: 16x16 mode */
1187
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1188
            
1189
            if (!s->umvplus) {  
1190
                ff_h263_encode_motion(s, motion_x - pred_x, 1);
1191
                ff_h263_encode_motion(s, motion_y - pred_y, 1);
1192
            }
1193
            else {
1194
                h263p_encode_umotion(s, motion_x - pred_x);
1195
                h263p_encode_umotion(s, motion_y - pred_y);
1196
                if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1197
                    /* To prevent Start Code emulation */
1198
                    put_bits(&s->pb,1,1);
1199
            }
1200
        }else{
1201
            put_bits(&s->pb,
1202
                    inter_MCBPC_bits[cbpc+16],
1203
                    inter_MCBPC_code[cbpc+16]);
1204
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1205
            if(s->dquant)
1206
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1207

    
1208
            if(interleaved_stats){
1209
                s->misc_bits+= get_bits_diff(s);
1210
            }
1211

    
1212
            for(i=0; i<4; i++){
1213
                /* motion vectors: 8x8 mode*/
1214
                h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1215

    
1216
                motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1217
                motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1218
                if (!s->umvplus) {  
1219
                    ff_h263_encode_motion(s, motion_x - pred_x, 1);
1220
                    ff_h263_encode_motion(s, motion_y - pred_y, 1);
1221
                }
1222
                else {
1223
                    h263p_encode_umotion(s, motion_x - pred_x);
1224
                    h263p_encode_umotion(s, motion_y - pred_y);
1225
                    if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1226
                        /* To prevent Start Code emulation */
1227
                        put_bits(&s->pb,1,1);
1228
                }
1229
            }
1230
        }
1231

    
1232
        if(interleaved_stats){
1233
            s->mv_bits+= get_bits_diff(s);
1234
        }
1235
    } else {
1236
        assert(s->mb_intra);
1237
        
1238
        cbp = 0;
1239
        if (s->h263_aic) {
1240
            /* Predict DC */
1241
            for(i=0; i<6; i++) {
1242
                int16_t level = block[i][0];
1243
                int scale;
1244
                
1245
                if(i<4) scale= s->y_dc_scale;
1246
                else    scale= s->c_dc_scale;
1247

    
1248
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1249
                level -= pred_dc;
1250
                /* Quant */
1251
                if (level >= 0)
1252
                    level = (level + (scale>>1))/scale;
1253
                else
1254
                    level = (level - (scale>>1))/scale;
1255
                    
1256
                /* AIC can change CBP */
1257
                if (level == 0 && s->block_last_index[i] == 0)
1258
                    s->block_last_index[i] = -1;
1259

    
1260
                if(!s->modified_quant){
1261
                    if (level < -127)
1262
                        level = -127;
1263
                    else if (level > 127)
1264
                        level = 127;
1265
                }
1266

    
1267
                block[i][0] = level;
1268
                /* Reconstruction */ 
1269
                rec_intradc[i] = scale*level + pred_dc;
1270
                /* Oddify */
1271
                rec_intradc[i] |= 1;
1272
                //if ((rec_intradc[i] % 2) == 0)
1273
                //    rec_intradc[i]++;
1274
                /* Clipping */
1275
                if (rec_intradc[i] < 0)
1276
                    rec_intradc[i] = 0;
1277
                else if (rec_intradc[i] > 2047)
1278
                    rec_intradc[i] = 2047;
1279
                                
1280
                /* Update AC/DC tables */
1281
                *dc_ptr[i] = rec_intradc[i];
1282
                if (s->block_last_index[i] >= 0)
1283
                    cbp |= 1 << (5 - i);
1284
            }
1285
        }else{
1286
            for(i=0; i<6; i++) {
1287
                /* compute cbp */
1288
                if (s->block_last_index[i] >= 1)
1289
                    cbp |= 1 << (5 - i);
1290
            }
1291
        }
1292

    
1293
        cbpc = cbp & 3;
1294
        if (s->pict_type == I_TYPE) {
1295
            if(s->dquant) cbpc+=4;
1296
            put_bits(&s->pb,
1297
                intra_MCBPC_bits[cbpc],
1298
                intra_MCBPC_code[cbpc]);
1299
        } else {
1300
            if(s->dquant) cbpc+=8;
1301
            put_bits(&s->pb, 1, 0);        /* mb coded */
1302
            put_bits(&s->pb,
1303
                inter_MCBPC_bits[cbpc + 4],
1304
                inter_MCBPC_code[cbpc + 4]);
1305
        }
1306
        if (s->h263_aic) {
1307
            /* XXX: currently, we do not try to use ac prediction */
1308
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
1309
        }
1310
        cbpy = cbp >> 2;
1311
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1312
        if(s->dquant)
1313
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1314

    
1315
        if(interleaved_stats){
1316
            s->misc_bits+= get_bits_diff(s);
1317
        }
1318
    }
1319

    
1320
    for(i=0; i<6; i++) {
1321
        /* encode each block */
1322
        h263_encode_block(s, block[i], i);
1323
    
1324
        /* Update INTRADC for decoding */
1325
        if (s->h263_aic && s->mb_intra) {
1326
            block[i][0] = rec_intradc[i];
1327
            
1328
        }
1329
    }
1330

    
1331
    if(interleaved_stats){
1332
        if (!s->mb_intra) {
1333
            s->p_tex_bits+= get_bits_diff(s);
1334
            s->f_count++;
1335
        }else{
1336
            s->i_tex_bits+= get_bits_diff(s);
1337
            s->i_count++;
1338
        }
1339
    }
1340
}
1341
#endif
1342

    
1343
void ff_h263_loop_filter(MpegEncContext * s){
1344
    int qp_c;
1345
    const int linesize  = s->linesize;
1346
    const int uvlinesize= s->uvlinesize;
1347
    const int xy = s->mb_y * s->mb_stride + s->mb_x;
1348
    uint8_t *dest_y = s->dest[0];
1349
    uint8_t *dest_cb= s->dest[1];
1350
    uint8_t *dest_cr= s->dest[2];
1351
    
1352
//    if(s->pict_type==B_TYPE && !s->readable) return;
1353

    
1354
    /*
1355
       Diag Top
1356
       Left Center
1357
    */
1358
    if(!IS_SKIP(s->current_picture.mb_type[xy])){
1359
        qp_c= s->qscale;
1360
        s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
1361
        s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1362
    }else
1363
        qp_c= 0;
1364

    
1365
    if(s->mb_y){
1366
        int qp_dt, qp_t, qp_tc;
1367

    
1368
        if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1369
            qp_t=0;
1370
        else 
1371
            qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1372

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

    
1405
    if(qp_c){
1406
        s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
1407
        if(s->mb_y + 1 == s->mb_height)
1408
            s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
1409
    }
1410
    
1411
    if(s->mb_x){
1412
        int qp_lc;
1413
        if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1414
            qp_lc= qp_c;
1415
        else
1416
            qp_lc= s->current_picture.qscale_table[xy-1];
1417
        
1418
        if(qp_lc){
1419
            s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
1420
            if(s->mb_y + 1 == s->mb_height){
1421
                const int chroma_qp= s->chroma_qscale_table[qp_lc];
1422
                s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
1423
                s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
1424
                s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
1425
            }
1426
        }
1427
    }
1428
}
1429

    
1430
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1431
{
1432
    int x, y, wrap, a, c, pred_dc, scale;
1433
    int16_t *dc_val, *ac_val;
1434

    
1435
    /* find prediction */
1436
    if (n < 4) {
1437
        x = 2 * s->mb_x + (n & 1);
1438
        y = 2 * s->mb_y + ((n & 2) >> 1);
1439
        wrap = s->b8_stride;
1440
        dc_val = s->dc_val[0];
1441
        ac_val = s->ac_val[0][0];
1442
        scale = s->y_dc_scale;
1443
    } else {
1444
        x = s->mb_x;
1445
        y = s->mb_y;
1446
        wrap = s->mb_stride;
1447
        dc_val = s->dc_val[n - 4 + 1];
1448
        ac_val = s->ac_val[n - 4 + 1][0];
1449
        scale = s->c_dc_scale;
1450
    }
1451
    /* B C
1452
     * A X 
1453
     */
1454
    a = dc_val[(x - 1) + (y) * wrap];
1455
    c = dc_val[(x) + (y - 1) * wrap];
1456
    
1457
    /* No prediction outside GOB boundary */
1458
    if(s->first_slice_line && n!=3){
1459
        if(n!=2) c= 1024;
1460
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1461
    }
1462
    pred_dc = 1024;
1463
    /* just DC prediction */
1464
    if (a != 1024 && c != 1024)
1465
        pred_dc = (a + c) >> 1;
1466
    else if (a != 1024)
1467
        pred_dc = a;
1468
    else
1469
        pred_dc = c;
1470
    
1471
    /* we assume pred is positive */
1472
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1473
    *dc_val_ptr = &dc_val[x + y * wrap];
1474
    return pred_dc;
1475
}
1476

    
1477
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1478
{
1479
    int x, y, wrap, a, c, pred_dc, scale, i;
1480
    int16_t *dc_val, *ac_val, *ac_val1;
1481

    
1482
    /* find prediction */
1483
    if (n < 4) {
1484
        x = 2 * s->mb_x + (n & 1);
1485
        y = 2 * s->mb_y + (n>> 1);
1486
        wrap = s->b8_stride;
1487
        dc_val = s->dc_val[0];
1488
        ac_val = s->ac_val[0][0];
1489
        scale = s->y_dc_scale;
1490
    } else {
1491
        x = s->mb_x;
1492
        y = s->mb_y;
1493
        wrap = s->mb_stride;
1494
        dc_val = s->dc_val[n - 4 + 1];
1495
        ac_val = s->ac_val[n - 4 + 1][0];
1496
        scale = s->c_dc_scale;
1497
    }
1498
    
1499
    ac_val += ((y) * wrap + (x)) * 16;
1500
    ac_val1 = ac_val;
1501
    
1502
    /* B C
1503
     * A X 
1504
     */
1505
    a = dc_val[(x - 1) + (y) * wrap];
1506
    c = dc_val[(x) + (y - 1) * wrap];
1507
    
1508
    /* No prediction outside GOB boundary */
1509
    if(s->first_slice_line && n!=3){
1510
        if(n!=2) c= 1024;
1511
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1512
    }
1513
    
1514
    if (s->ac_pred) {
1515
        pred_dc = 1024;
1516
        if (s->h263_aic_dir) {
1517
            /* left prediction */
1518
            if (a != 1024) {
1519
                ac_val -= 16;
1520
                for(i=1;i<8;i++) {
1521
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1522
                }
1523
                pred_dc = a;
1524
            }
1525
        } else {
1526
            /* top prediction */
1527
            if (c != 1024) {
1528
                ac_val -= 16 * wrap;
1529
                for(i=1;i<8;i++) {
1530
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1531
                }
1532
                pred_dc = c;
1533
            }
1534
        }
1535
    } else {
1536
        /* just DC prediction */
1537
        if (a != 1024 && c != 1024)
1538
            pred_dc = (a + c) >> 1;
1539
        else if (a != 1024)
1540
            pred_dc = a;
1541
        else
1542
            pred_dc = c;
1543
    }
1544
    
1545
    /* we assume pred is positive */
1546
    block[0]=block[0]*scale + pred_dc;
1547
    
1548
    if (block[0] < 0)
1549
        block[0] = 0;
1550
    else 
1551
        block[0] |= 1;
1552
    
1553
    /* Update AC/DC tables */
1554
    dc_val[(x) + (y) * wrap] = block[0];
1555
    
1556
    /* left copy */
1557
    for(i=1;i<8;i++)
1558
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1559
    /* top copy */
1560
    for(i=1;i<8;i++)
1561
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1562
}
1563

    
1564
int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1565
                        int *px, int *py)
1566
{
1567
    int wrap;
1568
    int16_t *A, *B, *C, (*mot_val)[2];
1569
    static const int off[4]= {2, 1, 1, -1};
1570

    
1571
    wrap = s->b8_stride;
1572
    mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1573

    
1574
    A = mot_val[ - 1];
1575
    /* special case for first (slice) line */
1576
    if (s->first_slice_line && block<3) {
1577
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1578
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1579
        if(block==0){ //most common case
1580
            if(s->mb_x  == s->resync_mb_x){ //rare
1581
                *px= *py = 0;
1582
            }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1583
                C = mot_val[off[block] - wrap];
1584
                if(s->mb_x==0){
1585
                    *px = C[0];
1586
                    *py = C[1];
1587
                }else{
1588
                    *px = mid_pred(A[0], 0, C[0]);
1589
                    *py = mid_pred(A[1], 0, C[1]);
1590
                }
1591
            }else{
1592
                *px = A[0];
1593
                *py = A[1];
1594
            }
1595
        }else if(block==1){
1596
            if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1597
                C = mot_val[off[block] - wrap];
1598
                *px = mid_pred(A[0], 0, C[0]);
1599
                *py = mid_pred(A[1], 0, C[1]);
1600
            }else{
1601
                *px = A[0];
1602
                *py = A[1];
1603
            }
1604
        }else{ /* block==2*/
1605
            B = mot_val[ - wrap];
1606
            C = mot_val[off[block] - wrap];
1607
            if(s->mb_x == s->resync_mb_x) //rare
1608
                A[0]=A[1]=0;
1609
    
1610
            *px = mid_pred(A[0], B[0], C[0]);
1611
            *py = mid_pred(A[1], B[1], C[1]);
1612
        }
1613
    } else {
1614
        B = mot_val[ - wrap];
1615
        C = mot_val[off[block] - wrap];
1616
        *px = mid_pred(A[0], B[0], C[0]);
1617
        *py = mid_pred(A[1], B[1], C[1]);
1618
    }
1619
    return *mot_val;
1620
}
1621

    
1622
#ifdef CONFIG_ENCODERS
1623
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1624
{
1625
    int range, l, bit_size, sign, code, bits;
1626

    
1627
    if (val == 0) {
1628
        /* zero vector */
1629
        code = 0;
1630
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1631
    } else {
1632
        bit_size = f_code - 1;
1633
        range = 1 << bit_size;
1634
        /* modulo encoding */
1635
        l= INT_BIT - 6 - bit_size;
1636
        val = (val<<l)>>l;
1637
        sign = val>>31;
1638
        val= (val^sign)-sign;
1639
        sign&=1;
1640

    
1641
        val--;
1642
        code = (val >> bit_size) + 1;
1643
        bits = val & (range - 1);
1644

    
1645
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1646
        if (bit_size > 0) {
1647
            put_bits(&s->pb, bit_size, bits);
1648
        }
1649
    }
1650

    
1651
}
1652

    
1653
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1654
static void h263p_encode_umotion(MpegEncContext * s, int val)
1655
{
1656
    short sval = 0; 
1657
    short i = 0;
1658
    short n_bits = 0;
1659
    short temp_val;
1660
    int code = 0;
1661
    int tcode;
1662
    
1663
    if ( val == 0)
1664
        put_bits(&s->pb, 1, 1);
1665
    else if (val == 1)
1666
        put_bits(&s->pb, 3, 0);
1667
    else if (val == -1)
1668
        put_bits(&s->pb, 3, 2);
1669
    else {
1670
        
1671
        sval = ((val < 0) ? (short)(-val):(short)val);
1672
        temp_val = sval;
1673
        
1674
        while (temp_val != 0) {
1675
            temp_val = temp_val >> 1;
1676
            n_bits++;
1677
        }
1678
        
1679
        i = n_bits - 1;
1680
        while (i > 0) {
1681
            tcode = (sval & (1 << (i-1))) >> (i-1);
1682
            tcode = (tcode << 1) | 1;
1683
            code = (code << 2) | tcode;
1684
            i--;
1685
        }
1686
        code = ((code << 1) | (val < 0)) << 1;
1687
        put_bits(&s->pb, (2*n_bits)+1, code);
1688
        //printf("\nVal = %d\tCode = %d", sval, code);
1689
    }
1690
}
1691

    
1692
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1693
{
1694
    int f_code;
1695
    int mv;
1696
    
1697
    if(mv_penalty==NULL)
1698
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1699
    
1700
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1701
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1702
            int len;
1703

    
1704
            if(mv==0) len= mvtab[0][1];
1705
            else{
1706
                int val, bit_size, range, code;
1707

    
1708
                bit_size = f_code - 1;
1709
                range = 1 << bit_size;
1710

    
1711
                val=mv;
1712
                if (val < 0) 
1713
                    val = -val;
1714
                val--;
1715
                code = (val >> bit_size) + 1;
1716
                if(code<33){
1717
                    len= mvtab[code][1] + 1 + bit_size;
1718
                }else{
1719
                    len= mvtab[32][1] + 2 + bit_size;
1720
                }
1721
            }
1722

    
1723
            mv_penalty[f_code][mv+MAX_MV]= len;
1724
        }
1725
    }
1726

    
1727
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1728
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1729
            fcode_tab[mv+MAX_MV]= f_code;
1730
        }
1731
    }
1732

    
1733
    for(mv=0; mv<MAX_MV*2+1; mv++){
1734
        umv_fcode_tab[mv]= 1;
1735
    }
1736
}
1737
#endif
1738

    
1739
#ifdef CONFIG_ENCODERS
1740

    
1741
static void init_uni_dc_tab(void)
1742
{
1743
    int level, uni_code, uni_len;
1744

    
1745
    for(level=-256; level<256; level++){
1746
        int size, v, l;
1747
        /* find number of bits */
1748
        size = 0;
1749
        v = abs(level);
1750
        while (v) {
1751
            v >>= 1;
1752
            size++;
1753
        }
1754

    
1755
        if (level < 0)
1756
            l= (-level) ^ ((1 << size) - 1);
1757
        else
1758
            l= level;
1759

    
1760
        /* luminance */
1761
        uni_code= DCtab_lum[size][0];
1762
        uni_len = DCtab_lum[size][1];
1763

    
1764
        if (size > 0) {
1765
            uni_code<<=size; uni_code|=l;
1766
            uni_len+=size;
1767
            if (size > 8){
1768
                uni_code<<=1; uni_code|=1;
1769
                uni_len++;
1770
            }
1771
        }
1772
        uni_DCtab_lum_bits[level+256]= uni_code;
1773
        uni_DCtab_lum_len [level+256]= uni_len;
1774

    
1775
        /* chrominance */
1776
        uni_code= DCtab_chrom[size][0];
1777
        uni_len = DCtab_chrom[size][1];
1778
        
1779
        if (size > 0) {
1780
            uni_code<<=size; uni_code|=l;
1781
            uni_len+=size;
1782
            if (size > 8){
1783
                uni_code<<=1; uni_code|=1;
1784
                uni_len++;
1785
            }
1786
        }
1787
        uni_DCtab_chrom_bits[level+256]= uni_code;
1788
        uni_DCtab_chrom_len [level+256]= uni_len;
1789

    
1790
    }
1791
}
1792

    
1793
#endif //CONFIG_ENCODERS
1794

    
1795
#ifdef CONFIG_ENCODERS
1796
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1797
    int slevel, run, last;
1798
    
1799
    assert(MAX_LEVEL >= 64);
1800
    assert(MAX_RUN   >= 63);
1801

    
1802
    for(slevel=-64; slevel<64; slevel++){
1803
        if(slevel==0) continue;
1804
        for(run=0; run<64; run++){
1805
            for(last=0; last<=1; last++){
1806
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1807
                int level= slevel < 0 ? -slevel : slevel;
1808
                int sign= slevel < 0 ? 1 : 0;
1809
                int bits, len, code;
1810
                int level1, run1;
1811
                
1812
                len_tab[index]= 100;
1813
                     
1814
                /* ESC0 */
1815
                code= get_rl_index(rl, last, run, level);
1816
                bits= rl->table_vlc[code][0];
1817
                len=  rl->table_vlc[code][1];
1818
                bits=bits*2+sign; len++;
1819
                
1820
                if(code!=rl->n && len < len_tab[index]){
1821
                    bits_tab[index]= bits;
1822
                    len_tab [index]= len;
1823
                }
1824
#if 1
1825
                /* ESC1 */
1826
                bits= rl->table_vlc[rl->n][0];
1827
                len=  rl->table_vlc[rl->n][1];
1828
                bits=bits*2;    len++; //esc1
1829
                level1= level - rl->max_level[last][run];
1830
                if(level1>0){
1831
                    code= get_rl_index(rl, last, run, level1);
1832
                    bits<<= rl->table_vlc[code][1];
1833
                    len  += rl->table_vlc[code][1];
1834
                    bits += rl->table_vlc[code][0];
1835
                    bits=bits*2+sign; len++;
1836
                
1837
                    if(code!=rl->n && len < len_tab[index]){
1838
                        bits_tab[index]= bits;
1839
                        len_tab [index]= len;
1840
                    }
1841
                }
1842
#endif 
1843
#if 1
1844
                /* ESC2 */
1845
                bits= rl->table_vlc[rl->n][0];
1846
                len=  rl->table_vlc[rl->n][1];
1847
                bits=bits*4+2;    len+=2; //esc2
1848
                run1 = run - rl->max_run[last][level] - 1;
1849
                if(run1>=0){
1850
                    code= get_rl_index(rl, last, run1, level);
1851
                    bits<<= rl->table_vlc[code][1];
1852
                    len  += rl->table_vlc[code][1];
1853
                    bits += rl->table_vlc[code][0];
1854
                    bits=bits*2+sign; len++;
1855
                
1856
                    if(code!=rl->n && len < len_tab[index]){
1857
                        bits_tab[index]= bits;
1858
                        len_tab [index]= len;
1859
                    }
1860
                }
1861
#endif           
1862
                /* ESC3 */        
1863
                bits= rl->table_vlc[rl->n][0];
1864
                len = rl->table_vlc[rl->n][1];
1865
                bits=bits*4+3;    len+=2; //esc3
1866
                bits=bits*2+last; len++;
1867
                bits=bits*64+run; len+=6;
1868
                bits=bits*2+1;    len++;  //marker
1869
                bits=bits*4096+(slevel&0xfff); len+=12;
1870
                bits=bits*2+1;    len++;  //marker
1871
                
1872
                if(len < len_tab[index]){
1873
                    bits_tab[index]= bits;
1874
                    len_tab [index]= len;
1875
                }
1876
            }
1877
        }
1878
    }
1879
}
1880

    
1881
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1882
    int slevel, run, last;
1883
    
1884
    assert(MAX_LEVEL >= 64);
1885
    assert(MAX_RUN   >= 63);
1886

    
1887
    for(slevel=-64; slevel<64; slevel++){
1888
        if(slevel==0) continue;
1889
        for(run=0; run<64; run++){
1890
            for(last=0; last<=1; last++){
1891
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1892
                int level= slevel < 0 ? -slevel : slevel;
1893
                int sign= slevel < 0 ? 1 : 0;
1894
                int bits, len, code;
1895
                int level1, run1;
1896
                
1897
                len_tab[index]= 100;
1898
                     
1899
                /* ESC0 */
1900
                code= get_rl_index(rl, last, run, level);
1901
                bits= rl->table_vlc[code][0];
1902
                len=  rl->table_vlc[code][1];
1903
                bits=bits*2+sign; len++;
1904
                
1905
                if(code!=rl->n && len < len_tab[index]){
1906
                    if(bits_tab) bits_tab[index]= bits;
1907
                    len_tab [index]= len;
1908
                }
1909
                /* ESC */
1910
                bits= rl->table_vlc[rl->n][0];
1911
                len = rl->table_vlc[rl->n][1];
1912
                bits=bits*2+last; len++;
1913
                bits=bits*64+run; len+=6;
1914
                bits=bits*256+(level&0xff); len+=8;
1915
                
1916
                if(len < len_tab[index]){
1917
                    if(bits_tab) bits_tab[index]= bits;
1918
                    len_tab [index]= len;
1919
                }
1920
            }
1921
        }
1922
    }
1923
}
1924

    
1925
void h263_encode_init(MpegEncContext *s)
1926
{
1927
    static int done = 0;
1928

    
1929
    if (!done) {
1930
        done = 1;
1931

    
1932
        init_uni_dc_tab();
1933

    
1934
        init_rl(&rl_inter);
1935
        init_rl(&rl_intra);
1936
        init_rl(&rl_intra_aic);
1937
        
1938
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1939
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1940

    
1941
        init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
1942
        init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
1943

    
1944
        init_mv_penalty_and_fcode(s);
1945
    }
1946
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1947
    
1948
    s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
1949
    s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
1950
    if(s->h263_aic){
1951
        s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
1952
        s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
1953
    }
1954
    s->ac_esc_length= 7+1+6+8;
1955

    
1956
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1957
    switch(s->codec_id){
1958
    case CODEC_ID_MPEG4:
1959
        s->fcode_tab= fcode_tab;
1960
        s->min_qcoeff= -2048;
1961
        s->max_qcoeff=  2047;
1962
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1963
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1964
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1965
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1966
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
1967
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1968
        s->ac_esc_length= 7+2+1+6+1+12+1;
1969
        s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
1970
        s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1971

    
1972
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1973

    
1974
            s->avctx->extradata= av_malloc(1024);
1975
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
1976
            
1977
            mpeg4_encode_visual_object_header(s);
1978
            mpeg4_encode_vol_header(s, 0, 0);
1979

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

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

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

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

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

    
2127
                        put_bits(&s->pb, 7, slevel & 0x7f);
2128
                    } else {
2129
                        /* 11-bit level */
2130
                        put_bits(&s->pb, 1, 1);
2131
                        put_bits(&s->pb, 1, last);
2132
                        put_bits(&s->pb, 6, run);
2133

    
2134
                        put_bits(&s->pb, 11, slevel & 0x7ff);
2135
                    }
2136
              }
2137
            } else {
2138
                put_bits(&s->pb, 1, sign);
2139
            }
2140
            last_non_zero = i;
2141
        }
2142
    }
2143
}
2144
#endif
2145

    
2146
#ifdef CONFIG_ENCODERS
2147

    
2148
/***************************************************/
2149
/**
2150
 * add mpeg4 stuffing bits (01...1)
2151
 */
2152
void ff_mpeg4_stuffing(PutBitContext * pbc)
2153
{
2154
    int length;
2155
    put_bits(pbc, 1, 0);
2156
    length= (-put_bits_count(pbc))&7;
2157
    if(length) put_bits(pbc, length, (1<<length)-1);
2158
}
2159

    
2160
/* must be called before writing the header */
2161
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2162
    int time_div, time_mod;
2163

    
2164
    assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2165
    s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2166

    
2167
    time_div= s->time/s->time_increment_resolution;
2168
    time_mod= s->time%s->time_increment_resolution;
2169

    
2170
    if(s->pict_type==B_TYPE){
2171
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2172
        assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2173
    }else{
2174
        s->last_time_base= s->time_base;
2175
        s->time_base= time_div;
2176
        s->pp_time= s->time - s->last_non_b_time;
2177
        s->last_non_b_time= s->time;
2178
        assert(s->pp_time > 0);
2179
    }
2180
}
2181

    
2182
static void mpeg4_encode_gop_header(MpegEncContext * s){
2183
    int hours, minutes, seconds;
2184
    int64_t time;
2185
    
2186
    put_bits(&s->pb, 16, 0);
2187
    put_bits(&s->pb, 16, GOP_STARTCODE);
2188
    
2189
    time= s->current_picture_ptr->pts;
2190
    if(s->reordered_input_picture[1])
2191
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2192
    time= (time*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2193

    
2194
    seconds= time/s->time_increment_resolution;
2195
    minutes= seconds/60; seconds %= 60;
2196
    hours= minutes/60; minutes %= 60;
2197
    hours%=24;
2198

    
2199
    put_bits(&s->pb, 5, hours);
2200
    put_bits(&s->pb, 6, minutes);
2201
    put_bits(&s->pb, 1, 1);
2202
    put_bits(&s->pb, 6, seconds);
2203
    
2204
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); 
2205
    put_bits(&s->pb, 1, 0); //broken link == NO
2206
    
2207
    s->last_time_base= time / s->time_increment_resolution; 
2208

    
2209
    ff_mpeg4_stuffing(&s->pb);
2210
}
2211

    
2212
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2213
    int profile_and_level_indication;
2214
    int vo_ver_id;
2215
    
2216
    if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2217
        profile_and_level_indication = s->avctx->profile << 4;
2218
    }else if(s->max_b_frames || s->quarter_sample){
2219
        profile_and_level_indication= 0xF0; // adv simple
2220
    }else{
2221
        profile_and_level_indication= 0x00; // simple
2222
    }
2223

    
2224
    if(s->avctx->level != FF_LEVEL_UNKNOWN){
2225
        profile_and_level_indication |= s->avctx->level;
2226
    }else{
2227
        profile_and_level_indication |= 1; //level 1
2228
    }
2229

    
2230
    if(profile_and_level_indication>>4 == 0xF){
2231
        vo_ver_id= 5;
2232
    }else{
2233
        vo_ver_id= 1;
2234
    }
2235

    
2236
    //FIXME levels
2237

    
2238
    put_bits(&s->pb, 16, 0);
2239
    put_bits(&s->pb, 16, VOS_STARTCODE);
2240

    
2241
    put_bits(&s->pb, 8, profile_and_level_indication);
2242

    
2243
    put_bits(&s->pb, 16, 0);
2244
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2245
    
2246
    put_bits(&s->pb, 1, 1);
2247
        put_bits(&s->pb, 4, vo_ver_id);
2248
        put_bits(&s->pb, 3, 1); //priority
2249
 
2250
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
2251
    
2252
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2253

    
2254
    ff_mpeg4_stuffing(&s->pb);
2255
}
2256

    
2257
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2258
{
2259
    int vo_ver_id;
2260

    
2261
    if(s->max_b_frames || s->quarter_sample){
2262
        vo_ver_id= 5;
2263
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2264
    }else{
2265
        vo_ver_id= 1;
2266
        s->vo_type= SIMPLE_VO_TYPE;
2267
    }
2268

    
2269
    put_bits(&s->pb, 16, 0);
2270
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2271
    put_bits(&s->pb, 16, 0);
2272
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2273

    
2274
    put_bits(&s->pb, 1, 0);                /* random access vol */
2275
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
2276
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
2277
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
2278
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
2279
    
2280
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2281

    
2282
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2283
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2284
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2285
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2286
    }
2287

    
2288
    put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
2289
    put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
2290
    put_bits(&s->pb, 1, s->low_delay);
2291
    put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
2292

    
2293
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
2294
    put_bits(&s->pb, 1, 1);                /* marker bit */
2295
    
2296
    put_bits(&s->pb, 16, s->time_increment_resolution);
2297
    if (s->time_increment_bits < 1)
2298
        s->time_increment_bits = 1;
2299
    put_bits(&s->pb, 1, 1);                /* marker bit */
2300
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
2301
    put_bits(&s->pb, 1, 1);                /* marker bit */
2302
    put_bits(&s->pb, 13, s->width);        /* vol width */
2303
    put_bits(&s->pb, 1, 1);                /* marker bit */
2304
    put_bits(&s->pb, 13, s->height);        /* vol height */
2305
    put_bits(&s->pb, 1, 1);                /* marker bit */
2306
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2307
    put_bits(&s->pb, 1, 1);                /* obmc disable */
2308
    if (vo_ver_id == 1) {
2309
        put_bits(&s->pb, 1, s->vol_sprite_usage);                /* sprite enable */
2310
    }else{
2311
        put_bits(&s->pb, 2, s->vol_sprite_usage);                /* sprite enable */
2312
    }
2313
    
2314
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
2315
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
2316

    
2317
    if(s->mpeg_quant){
2318
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2319
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2320
    }
2321

    
2322
    if (vo_ver_id != 1)
2323
        put_bits(&s->pb, 1, s->quarter_sample);
2324
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
2325
    s->resync_marker= s->rtp_mode;
2326
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2327
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2328
    if(s->data_partitioning){
2329
        put_bits(&s->pb, 1, 0);                /* no rvlc */
2330
    }
2331

    
2332
    if (vo_ver_id != 1){
2333
        put_bits(&s->pb, 1, 0);                /* newpred */
2334
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
2335
    }
2336
    put_bits(&s->pb, 1, 0);                /* scalability */
2337
    
2338
    ff_mpeg4_stuffing(&s->pb);
2339

    
2340
    /* user data */
2341
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2342
        put_bits(&s->pb, 16, 0);
2343
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
2344
        put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2345
    }
2346
}
2347

    
2348
/* write mpeg4 VOP header */
2349
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2350
{
2351
    int time_incr;
2352
    int time_div, time_mod;
2353
    
2354
    if(s->pict_type==I_TYPE){
2355
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2356
            if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2357
                mpeg4_encode_visual_object_header(s);
2358
            if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2359
                mpeg4_encode_vol_header(s, 0, 0);
2360
        }
2361
        mpeg4_encode_gop_header(s);
2362
    }
2363
    
2364
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2365

    
2366
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2367
    
2368
    put_bits(&s->pb, 16, 0);                /* vop header */
2369
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2370
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
2371

    
2372
    time_div= s->time/s->time_increment_resolution;
2373
    time_mod= s->time%s->time_increment_resolution;
2374
    time_incr= time_div - s->last_time_base;
2375
    assert(time_incr >= 0);
2376
    while(time_incr--)
2377
        put_bits(&s->pb, 1, 1);
2378
        
2379
    put_bits(&s->pb, 1, 0);
2380

    
2381
    put_bits(&s->pb, 1, 1);        /* marker */
2382
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
2383
    put_bits(&s->pb, 1, 1);        /* marker */
2384
    put_bits(&s->pb, 1, 1);        /* vop coded */
2385
    if (    s->pict_type == P_TYPE 
2386
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2387
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
2388
    }
2389
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
2390
    if(!s->progressive_sequence){
2391
         put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2392
         put_bits(&s->pb, 1, s->alternate_scan);
2393
    }
2394
    //FIXME sprite stuff
2395

    
2396
    put_bits(&s->pb, 5, s->qscale);
2397

    
2398
    if (s->pict_type != I_TYPE)
2399
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
2400
    if (s->pict_type == B_TYPE)
2401
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
2402
    //    printf("****frame %d\n", picture_number);
2403
}
2404

    
2405
#endif //CONFIG_ENCODERS
2406

    
2407
/**
2408
 * set qscale and update qscale dependant variables.
2409
 */
2410
void ff_set_qscale(MpegEncContext * s, int qscale)
2411
{
2412
    if (qscale < 1)
2413
        qscale = 1;
2414
    else if (qscale > 31)
2415
        qscale = 31;
2416
        
2417
    s->qscale = qscale;
2418
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2419

    
2420
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2421
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2422
}
2423

    
2424
/**
2425
 * predicts the dc.
2426
 * encoding quantized level -> quantized diff
2427
 * decoding quantized diff -> quantized level  
2428
 * @param n block index (0-3 are luma, 4-5 are chroma)
2429
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2430
 */
2431
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2432
{
2433
    int a, b, c, wrap, pred, scale, ret;
2434
    uint16_t *dc_val;
2435

    
2436
    /* find prediction */
2437
    if (n < 4) {
2438
        scale = s->y_dc_scale;
2439
    } else {
2440
        scale = s->c_dc_scale;
2441
    }
2442
    if(IS_3IV1)
2443
        scale= 8;
2444

    
2445
    wrap= s->block_wrap[n];
2446
    dc_val = s->dc_val[0] + s->block_index[n];
2447

    
2448
    /* B C
2449
     * A X 
2450
     */
2451
    a = dc_val[ - 1];
2452
    b = dc_val[ - 1 - wrap];
2453
    c = dc_val[ - wrap];
2454

    
2455
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2456
    if(s->first_slice_line && n!=3){
2457
        if(n!=2) b=c= 1024;
2458
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2459
    }
2460
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2461
        if(n==0 || n==4 || n==5)
2462
            b=1024;
2463
    }
2464

    
2465
    if (abs(a - b) < abs(b - c)) {
2466
        pred = c;
2467
        *dir_ptr = 1; /* top */
2468
    } else {
2469
        pred = a;
2470
        *dir_ptr = 0; /* left */
2471
    }
2472
    /* we assume pred is positive */
2473
    pred = FASTDIV((pred + (scale >> 1)), scale);
2474

    
2475
    if(encoding){
2476
        ret = level - pred;
2477
    }else{
2478
        level += pred;
2479
        ret= level;
2480
        if(s->error_resilience>=3){
2481
            if(level<0){
2482
                av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2483
                return -1;
2484
            }
2485
            if(level*scale > 2048 + scale){
2486
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2487
                return -1;
2488
            }
2489
        }
2490
    }
2491
    level *=scale;
2492
    if(level&(~2047)){
2493
        if(level<0) 
2494
            level=0;
2495
        else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2496
            level=2047;
2497
    }
2498
    dc_val[0]= level;
2499

    
2500
    return ret;
2501
}
2502

    
2503
/**
2504
 * predicts the ac.
2505
 * @param n block index (0-3 are luma, 4-5 are chroma)
2506
 * @param dir the ac prediction direction
2507
 */
2508
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2509
                   int dir)
2510
{
2511
    int i;
2512
    int16_t *ac_val, *ac_val1;
2513
    int8_t * const qscale_table= s->current_picture.qscale_table;
2514

    
2515
    /* find prediction */
2516
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2517
    ac_val1 = ac_val;
2518
    if (s->ac_pred) {
2519
        if (dir == 0) {
2520
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2521
            /* left prediction */
2522
            ac_val -= 16;
2523
            
2524
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2525
                /* same qscale */
2526
                for(i=1;i<8;i++) {
2527
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2528
                }
2529
            }else{
2530
                /* different qscale, we must rescale */
2531
                for(i=1;i<8;i++) {
2532
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2533
                }
2534
            }
2535
        } else {
2536
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2537
            /* top prediction */
2538
            ac_val -= 16 * s->block_wrap[n];
2539

    
2540
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2541
                /* same qscale */
2542
                for(i=1;i<8;i++) {
2543
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2544
                }
2545
            }else{
2546
                /* different qscale, we must rescale */
2547
                for(i=1;i<8;i++) {
2548
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2549
                }
2550
            }
2551
        }
2552
    }
2553
    /* left copy */
2554
    for(i=1;i<8;i++)
2555
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2556

    
2557
    /* top copy */
2558
    for(i=1;i<8;i++)
2559
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2560

    
2561
}
2562

    
2563
#ifdef CONFIG_ENCODERS
2564

    
2565
/**
2566
 * encodes the dc value.
2567
 * @param n block index (0-3 are luma, 4-5 are chroma)
2568
 */
2569
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2570
{
2571
#if 1
2572
//    if(level<-255 || level>255) printf("dc overflow\n");
2573
    level+=256;
2574
    if (n < 4) {
2575
        /* luminance */
2576
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2577
    } else {
2578
        /* chrominance */
2579
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2580
    }
2581
#else
2582
    int size, v;
2583
    /* find number of bits */
2584
    size = 0;
2585
    v = abs(level);
2586
    while (v) {
2587
        v >>= 1;
2588
        size++;
2589
    }
2590

    
2591
    if (n < 4) {
2592
        /* luminance */
2593
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2594
    } else {
2595
        /* chrominance */
2596
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2597
    }
2598

    
2599
    /* encode remaining bits */
2600
    if (size > 0) {
2601
        if (level < 0)
2602
            level = (-level) ^ ((1 << size) - 1);
2603
        put_bits(&s->pb, size, level);
2604
        if (size > 8)
2605
            put_bits(&s->pb, 1, 1);
2606
    }
2607
#endif
2608
}
2609

    
2610
/**
2611
 * encodes a 8x8 block
2612
 * @param n block index (0-3 are luma, 4-5 are chroma)
2613
 */
2614
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2615
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2616
{
2617
    int i, last_non_zero;
2618
#if 0 //variables for the outcommented version
2619
    int code, sign, last;
2620
#endif
2621
    const RLTable *rl;
2622
    uint32_t *bits_tab;
2623
    uint8_t *len_tab;
2624
    const int last_index = s->block_last_index[n];
2625

    
2626
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2627
        /* mpeg4 based DC predictor */
2628
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2629
        if(last_index<1) return;
2630
        i = 1;
2631
        rl = &rl_intra;
2632
        bits_tab= uni_mpeg4_intra_rl_bits;
2633
        len_tab = uni_mpeg4_intra_rl_len;
2634
    } else {
2635
        if(last_index<0) return;
2636
        i = 0;
2637
        rl = &rl_inter;
2638
        bits_tab= uni_mpeg4_inter_rl_bits;
2639
        len_tab = uni_mpeg4_inter_rl_len;
2640
    }
2641

    
2642
    /* AC coefs */
2643
    last_non_zero = i - 1;
2644
#if 1
2645
    for (; i < last_index; i++) {
2646
        int level = block[ scan_table[i] ];
2647
        if (level) {
2648
            int run = i - last_non_zero - 1;
2649
            level+=64;
2650
            if((level&(~127)) == 0){
2651
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2652
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2653
            }else{ //ESC3
2654
                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);
2655
            }
2656
            last_non_zero = i;
2657
        }
2658
    }
2659
    /*if(i<=last_index)*/{
2660
        int level = block[ scan_table[i] ];
2661
        int run = i - last_non_zero - 1;
2662
        level+=64;
2663
        if((level&(~127)) == 0){
2664
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2665
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2666
        }else{ //ESC3
2667
            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);
2668
        }
2669
    }
2670
#else
2671
    for (; i <= last_index; i++) {
2672
        const int slevel = block[ scan_table[i] ];
2673
        if (slevel) {
2674
            int level;
2675
            int run = i - last_non_zero - 1;
2676
            last = (i == last_index);
2677
            sign = 0;
2678
            level = slevel;
2679
            if (level < 0) {
2680
                sign = 1;
2681
                level = -level;
2682
            }
2683
            code = get_rl_index(rl, last, run, level);
2684
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2685
            if (code == rl->n) {
2686
                int level1, run1;
2687
                level1 = level - rl->max_level[last][run];
2688
                if (level1 < 1) 
2689
                    goto esc2;
2690
                code = get_rl_index(rl, last, run, level1);
2691
                if (code == rl->n) {
2692
                esc2:
2693
                    put_bits(ac_pb, 1, 1);
2694
                    if (level > MAX_LEVEL)
2695
                        goto esc3;
2696
                    run1 = run - rl->max_run[last][level] - 1;
2697
                    if (run1 < 0)
2698
                        goto esc3;
2699
                    code = get_rl_index(rl, last, run1, level);
2700
                    if (code == rl->n) {
2701
                    esc3:
2702
                        /* third escape */
2703
                        put_bits(ac_pb, 1, 1);
2704
                        put_bits(ac_pb, 1, last);
2705
                        put_bits(ac_pb, 6, run);
2706
                        put_bits(ac_pb, 1, 1);
2707
                        put_bits(ac_pb, 12, slevel & 0xfff);
2708
                        put_bits(ac_pb, 1, 1);
2709
                    } else {
2710
                        /* second escape */
2711
                        put_bits(ac_pb, 1, 0);
2712
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2713
                        put_bits(ac_pb, 1, sign);
2714
                    }
2715
                } else {
2716
                    /* first escape */
2717
                    put_bits(ac_pb, 1, 0);
2718
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2719
                    put_bits(ac_pb, 1, sign);
2720
                }
2721
            } else {
2722
                put_bits(ac_pb, 1, sign);
2723
            }
2724
            last_non_zero = i;
2725
        }
2726
    }
2727
#endif
2728
}
2729

    
2730
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2731
                               uint8_t *scan_table)
2732
{
2733
    int i, last_non_zero;
2734
    const RLTable *rl;
2735
    uint8_t *len_tab;
2736
    const int last_index = s->block_last_index[n];
2737
    int len=0;
2738

    
2739
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2740
        /* mpeg4 based DC predictor */
2741
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2742
        if(last_index<1) return len;
2743
        i = 1;
2744
        rl = &rl_intra;
2745
        len_tab = uni_mpeg4_intra_rl_len;
2746
    } else {
2747
        if(last_index<0) return 0;
2748
        i = 0;
2749
        rl = &rl_inter;
2750
        len_tab = uni_mpeg4_inter_rl_len;
2751
    }
2752

    
2753
    /* AC coefs */
2754
    last_non_zero = i - 1;
2755
    for (; i < last_index; i++) {
2756
        int level = block[ scan_table[i] ];
2757
        if (level) {
2758
            int run = i - last_non_zero - 1;
2759
            level+=64;
2760
            if((level&(~127)) == 0){
2761
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2762
                len += len_tab[index];
2763
            }else{ //ESC3
2764
                len += 7+2+1+6+1+12+1;
2765
            }
2766
            last_non_zero = i;
2767
        }
2768
    }
2769
    /*if(i<=last_index)*/{
2770
        int level = block[ scan_table[i] ];
2771
        int run = i - last_non_zero - 1;
2772
        level+=64;
2773
        if((level&(~127)) == 0){
2774
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2775
            len += len_tab[index];
2776
        }else{ //ESC3
2777
            len += 7+2+1+6+1+12+1;
2778
        }
2779
    }
2780
    
2781
    return len;
2782
}
2783

    
2784
#endif
2785

    
2786

    
2787
/***********************************************/
2788
/* decoding */
2789

    
2790
static VLC intra_MCBPC_vlc;
2791
static VLC inter_MCBPC_vlc;
2792
static VLC cbpy_vlc;
2793
static VLC mv_vlc;
2794
static VLC dc_lum, dc_chrom;
2795
static VLC sprite_trajectory;
2796
static VLC mb_type_b_vlc;
2797
static VLC h263_mbtype_b_vlc;
2798
static VLC cbpc_b_vlc;
2799

    
2800
void init_vlc_rl(RLTable *rl)
2801
{
2802
    int i, q;
2803
    
2804
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2805
             &rl->table_vlc[0][1], 4, 2,
2806
             &rl->table_vlc[0][0], 4, 2);
2807

    
2808
    
2809
    for(q=0; q<32; q++){
2810
        int qmul= q*2;
2811
        int qadd= (q-1)|1;
2812
        
2813
        if(q==0){
2814
            qmul=1;
2815
            qadd=0;
2816
        }
2817
        
2818
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2819
        for(i=0; i<rl->vlc.table_size; i++){
2820
            int code= rl->vlc.table[i][0];
2821
            int len = rl->vlc.table[i][1];
2822
            int level, run;
2823
        
2824
            if(len==0){ // illegal code
2825
                run= 66;
2826
                level= MAX_LEVEL;
2827
            }else if(len<0){ //more bits needed
2828
                run= 0;
2829
                level= code;
2830
            }else{
2831
                if(code==rl->n){ //esc
2832
                    run= 66;
2833
                    level= 0;
2834
                }else{
2835
                    run=   rl->table_run  [code] + 1;
2836
                    level= rl->table_level[code] * qmul + qadd;
2837
                    if(code >= rl->last) run+=192;
2838
                }
2839
            }
2840
            rl->rl_vlc[q][i].len= len;
2841
            rl->rl_vlc[q][i].level= level;
2842
            rl->rl_vlc[q][i].run= run;
2843
        }
2844
    }
2845
}
2846

    
2847
/* init vlcs */
2848

    
2849
/* XXX: find a better solution to handle static init */
2850
void h263_decode_init_vlc(MpegEncContext *s)
2851
{
2852
    static int done = 0;
2853

    
2854
    if (!done) {
2855
        done = 1;
2856

    
2857
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, 
2858
                 intra_MCBPC_bits, 1, 1,
2859
                 intra_MCBPC_code, 1, 1);
2860
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, 
2861
                 inter_MCBPC_bits, 1, 1,
2862
                 inter_MCBPC_code, 1, 1);
2863
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2864
                 &cbpy_tab[0][1], 2, 1,
2865
                 &cbpy_tab[0][0], 2, 1);
2866
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2867
                 &mvtab[0][1], 2, 1,
2868
                 &mvtab[0][0], 2, 1);
2869
        init_rl(&rl_inter);
2870
        init_rl(&rl_intra);
2871
        init_rl(&rvlc_rl_inter);
2872
        init_rl(&rvlc_rl_intra);
2873
        init_rl(&rl_intra_aic);
2874
        init_vlc_rl(&rl_inter);
2875
        init_vlc_rl(&rl_intra);
2876
        init_vlc_rl(&rvlc_rl_inter);
2877
        init_vlc_rl(&rvlc_rl_intra);
2878
        init_vlc_rl(&rl_intra_aic);
2879
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2880
                 &DCtab_lum[0][1], 2, 1,
2881
                 &DCtab_lum[0][0], 2, 1);
2882
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2883
                 &DCtab_chrom[0][1], 2, 1,
2884
                 &DCtab_chrom[0][0], 2, 1);
2885
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2886
                 &sprite_trajectory_tab[0][1], 4, 2,
2887
                 &sprite_trajectory_tab[0][0], 4, 2);
2888
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2889
                 &mb_type_b_tab[0][1], 2, 1,
2890
                 &mb_type_b_tab[0][0], 2, 1);
2891
        init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2892
                 &h263_mbtype_b_tab[0][1], 2, 1,
2893
                 &h263_mbtype_b_tab[0][0], 2, 1);
2894
        init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2895
                 &cbpc_b_tab[0][1], 2, 1,
2896
                 &cbpc_b_tab[0][0], 2, 1);
2897
    }
2898
}
2899

    
2900
/**
2901
 * Get the GOB height based on picture height.
2902
 */
2903
int ff_h263_get_gob_height(MpegEncContext *s){
2904
    if (s->height <= 400)
2905
        return 1;
2906
    else if (s->height <= 800)
2907
        return  2;
2908
    else
2909
        return 4;
2910
}
2911

    
2912
int ff_h263_decode_mba(MpegEncContext *s)
2913
{
2914
    int i, mb_pos;
2915

    
2916
    for(i=0; i<6; i++){
2917
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2918
    }
2919
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2920
    s->mb_x= mb_pos % s->mb_width;
2921
    s->mb_y= mb_pos / s->mb_width;
2922

    
2923
    return mb_pos;
2924
}
2925

    
2926
void ff_h263_encode_mba(MpegEncContext *s)
2927
{
2928
    int i, mb_pos;
2929

    
2930
    for(i=0; i<6; i++){
2931
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2932
    }
2933
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
2934
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
2935
}
2936

    
2937
/**
2938
 * decodes the group of blocks header or slice header.
2939
 * @return <0 if an error occured
2940
 */
2941
static int h263_decode_gob_header(MpegEncContext *s)
2942
{
2943
    unsigned int val, gfid, gob_number;
2944
    int left;
2945
    
2946
    /* Check for GOB Start Code */
2947
    val = show_bits(&s->gb, 16);
2948
    if(val)
2949
        return -1;
2950

    
2951
        /* We have a GBSC probably with GSTUFF */
2952
    skip_bits(&s->gb, 16); /* Drop the zeros */
2953
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2954
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2955
    for(;left>13; left--){
2956
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2957
    }
2958
    if(left<=13) 
2959
        return -1;
2960

    
2961
    if(s->h263_slice_structured){
2962
        if(get_bits1(&s->gb)==0)
2963
            return -1;
2964

    
2965
        ff_h263_decode_mba(s);
2966

    
2967
        if(s->mb_num > 1583)
2968
            if(get_bits1(&s->gb)==0)
2969
                return -1;
2970
        
2971
        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
2972
        if(get_bits1(&s->gb)==0)
2973
            return -1;
2974
        gfid = get_bits(&s->gb, 2); /* GFID */
2975
    }else{
2976
        gob_number = get_bits(&s->gb, 5); /* GN */
2977
        s->mb_x= 0;
2978
        s->mb_y= s->gob_index* gob_number;
2979
        gfid = get_bits(&s->gb, 2); /* GFID */
2980
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2981
    }
2982
        
2983
    if(s->mb_y >= s->mb_height) 
2984
        return -1;
2985

    
2986
    if(s->qscale==0) 
2987
        return -1;
2988

    
2989
    return 0;
2990
}
2991

    
2992
static inline void memsetw(short *tab, int val, int n)
2993
{
2994
    int i;
2995
    for(i=0;i<n;i++)
2996
        tab[i] = val;
2997
}
2998

    
2999
#ifdef CONFIG_ENCODERS
3000

    
3001
void ff_mpeg4_init_partitions(MpegEncContext *s)
3002
{
3003
    uint8_t *start= pbBufPtr(&s->pb);
3004
    uint8_t *end= s->pb.buf_end;
3005
    int size= end - start;
3006
    int pb_size = (((int)start + size/3)&(~3)) - (int)start;
3007
    int tex_size= (size - 2*pb_size)&(~3);
3008
    
3009
    set_put_bits_buffer_size(&s->pb, pb_size);
3010
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3011
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3012
}
3013

    
3014
void ff_mpeg4_merge_partitions(MpegEncContext *s)
3015
{
3016
    const int pb2_len   = put_bits_count(&s->pb2   );
3017
    const int tex_pb_len= put_bits_count(&s->tex_pb);
3018
    const int bits= put_bits_count(&s->pb);
3019

    
3020
    if(s->pict_type==I_TYPE){
3021
        put_bits(&s->pb, 19, DC_MARKER);
3022
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3023
        s->i_tex_bits+= tex_pb_len;
3024
    }else{
3025
        put_bits(&s->pb, 17, MOTION_MARKER);
3026
        s->misc_bits+=17 + pb2_len;
3027
        s->mv_bits+= bits - s->last_bits;
3028
        s->p_tex_bits+= tex_pb_len;
3029
    }
3030

    
3031
    flush_put_bits(&s->pb2);
3032
    flush_put_bits(&s->tex_pb);
3033

    
3034
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3035
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3036
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3037
    s->last_bits= put_bits_count(&s->pb);
3038
}
3039

    
3040
#endif //CONFIG_ENCODERS
3041

    
3042
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3043
    switch(s->pict_type){
3044
        case I_TYPE:
3045
            return 16;
3046
        case P_TYPE:
3047
        case S_TYPE:
3048
            return s->f_code+15;
3049
        case B_TYPE:
3050
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3051
        default:
3052
            return -1;
3053
    }
3054
}
3055

    
3056
#ifdef CONFIG_ENCODERS
3057

    
3058
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3059
{
3060
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3061

    
3062
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3063
    put_bits(&s->pb, 1, 1);
3064
    
3065
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3066
    put_bits(&s->pb, s->quant_precision, s->qscale);
3067
    put_bits(&s->pb, 1, 0); /* no HEC */
3068
}
3069

    
3070
#endif //CONFIG_ENCODERS
3071

    
3072
/**
3073
 * check if the next stuff is a resync marker or the end.
3074
 * @return 0 if not
3075
 */
3076
static inline int mpeg4_is_resync(MpegEncContext *s){
3077
    const int bits_count= get_bits_count(&s->gb);
3078
    
3079
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3080
        return 0;
3081
    }
3082

    
3083
    if(bits_count + 8 >= s->gb.size_in_bits){
3084
        int v= show_bits(&s->gb, 8);
3085
        v|= 0x7F >> (7-(bits_count&7));
3086
                
3087
        if(v==0x7F)
3088
            return 1;
3089
    }else{
3090
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3091
            int len;
3092
            GetBitContext gb= s->gb;
3093
        
3094
            skip_bits(&s->gb, 1);
3095
            align_get_bits(&s->gb);
3096
        
3097
            for(len=0; len<32; len++){
3098
                if(get_bits1(&s->gb)) break;
3099
            }
3100

    
3101
            s->gb= gb;
3102

    
3103
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3104
                return 1;
3105
        }
3106
    }
3107
    return 0;
3108
}
3109

    
3110
/**
3111
 * decodes the next video packet.
3112
 * @return <0 if something went wrong
3113
 */
3114
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3115
{
3116
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3117
    int header_extension=0, mb_num, len;
3118
    
3119
    /* is there enough space left for a video packet + header */
3120
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3121

    
3122
    for(len=0; len<32; len++){
3123
        if(get_bits1(&s->gb)) break;
3124
    }
3125

    
3126
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3127
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3128
        return -1;
3129
    }
3130
    
3131
    if(s->shape != RECT_SHAPE){
3132
        header_extension= get_bits1(&s->gb);
3133
        //FIXME more stuff here
3134
    }
3135

    
3136
    mb_num= get_bits(&s->gb, mb_num_bits);
3137
    if(mb_num>=s->mb_num){
3138
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3139
        return -1;
3140
    }
3141
    if(s->pict_type == B_TYPE){
3142
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3143
        if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
3144
    }
3145
    
3146
    s->mb_x= mb_num % s->mb_width;
3147
    s->mb_y= mb_num / s->mb_width;
3148

    
3149
    if(s->shape != BIN_ONLY_SHAPE){
3150
        int qscale= get_bits(&s->gb, s->quant_precision); 
3151
        if(qscale)
3152
            s->chroma_qscale=s->qscale= qscale;
3153
    }
3154

    
3155
    if(s->shape == RECT_SHAPE){
3156
        header_extension= get_bits1(&s->gb);
3157
    }
3158
    if(header_extension){
3159
        int time_increment;
3160
        int time_incr=0;
3161

    
3162
        while (get_bits1(&s->gb) != 0) 
3163
            time_incr++;
3164

    
3165
        check_marker(&s->gb, "before time_increment in video packed header");
3166
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3167
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3168
        
3169
        skip_bits(&s->gb, 2); /* vop coding type */
3170
        //FIXME not rect stuff here
3171

    
3172
        if(s->shape != BIN_ONLY_SHAPE){
3173
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3174
//FIXME dont just ignore everything
3175
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3176
                mpeg4_decode_sprite_trajectory(s, &s->gb);
3177
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3178
            }
3179

    
3180
            //FIXME reduced res stuff here
3181
            
3182
            if (s->pict_type != I_TYPE) {
3183
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
3184
                if(f_code==0){
3185
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3186
                }
3187
            }
3188
            if (s->pict_type == B_TYPE) {
3189
                int b_code = get_bits(&s->gb, 3);
3190
                if(b_code==0){
3191
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3192
                }
3193
            }       
3194
        }
3195
    }
3196
    //FIXME new-pred stuff
3197
    
3198
//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));
3199

    
3200
    return 0;
3201
}
3202

    
3203
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3204
{
3205
    int c_wrap, c_xy, l_wrap, l_xy;
3206

    
3207
    l_wrap= s->b8_stride;
3208
    l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3209
    c_wrap= s->mb_stride;
3210
    c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3211

    
3212
#if 0
3213
    /* clean DC */
3214
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3215
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3216
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3217
#endif
3218

    
3219
    /* clean AC */
3220
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3221
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3222
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3223

    
3224
    /* clean MV */
3225
    // we cant clear the MVs as they might be needed by a b frame
3226
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3227
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3228
    s->last_mv[0][0][0]=
3229
    s->last_mv[0][0][1]=
3230
    s->last_mv[1][0][0]=
3231
    s->last_mv[1][0][1]= 0;
3232
}
3233

    
3234
/**
3235
 * decodes the group of blocks / video packet header.
3236
 * @return <0 if no resync found
3237
 */
3238
int ff_h263_resync(MpegEncContext *s){
3239
    int left, ret;
3240
    
3241
    if(s->codec_id==CODEC_ID_MPEG4){
3242
        skip_bits1(&s->gb);
3243
        align_get_bits(&s->gb);
3244
    }
3245

    
3246
    if(show_bits(&s->gb, 16)==0){
3247
        if(s->codec_id==CODEC_ID_MPEG4)
3248
            ret= mpeg4_decode_video_packet_header(s);
3249
        else
3250
            ret= h263_decode_gob_header(s);
3251
        if(ret>=0)
3252
            return 0;
3253
    }
3254
    //ok, its not where its supposed to be ...
3255
    s->gb= s->last_resync_gb;
3256
    align_get_bits(&s->gb);
3257
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3258
    
3259
    for(;left>16+1+5+5; left-=8){ 
3260
        if(show_bits(&s->gb, 16)==0){
3261
            GetBitContext bak= s->gb;
3262

    
3263
            if(s->codec_id==CODEC_ID_MPEG4)
3264
                ret= mpeg4_decode_video_packet_header(s);
3265
            else
3266
                ret= h263_decode_gob_header(s);
3267
            if(ret>=0)
3268
                return 0;
3269

    
3270
            s->gb= bak;
3271
        }
3272
        skip_bits(&s->gb, 8);
3273
    }
3274
    
3275
    return -1;
3276
}
3277

    
3278
/**
3279
 * gets the average motion vector for a GMC MB.
3280
 * @param n either 0 for the x component or 1 for y
3281
 * @returns the average MV for a GMC MB
3282
 */
3283
static inline int get_amv(MpegEncContext *s, int n){
3284
    int x, y, mb_v, sum, dx, dy, shift;
3285
    int len = 1 << (s->f_code + 4);
3286
    const int a= s->sprite_warping_accuracy;
3287
    
3288
    if(s->workaround_bugs & FF_BUG_AMV)
3289
        len >>= s->quarter_sample;
3290

    
3291
    if(s->real_sprite_warping_points==1){
3292
        if(s->divx_version==500 && s->divx_build==413)
3293
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3294
        else
3295
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3296
    }else{
3297
        dx= s->sprite_delta[n][0];
3298
        dy= s->sprite_delta[n][1];
3299
        shift= s->sprite_shift[0];
3300
        if(n) dy -= 1<<(shift + a + 1);
3301
        else  dx -= 1<<(shift + a + 1);
3302
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3303

    
3304
        sum=0;
3305
        for(y=0; y<16; y++){
3306
            int v;
3307
        
3308
            v= mb_v + dy*y;
3309
            //XXX FIXME optimize
3310
            for(x=0; x<16; x++){
3311
                sum+= v>>shift;
3312
                v+= dx;
3313
            }
3314
        }
3315
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3316
    }
3317

    
3318
    if      (sum < -len) sum= -len;
3319
    else if (sum >= len) sum= len-1;
3320

    
3321
    return sum;
3322
}
3323

    
3324
/**
3325
 * decodes first partition.
3326
 * @return number of MBs decoded or <0 if an error occured
3327
 */
3328
static int mpeg4_decode_partition_a(MpegEncContext *s){
3329
    int mb_num;
3330
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3331
    
3332
    /* decode first partition */
3333
    mb_num=0;
3334
    s->first_slice_line=1;
3335
    for(; s->mb_y<s->mb_height; s->mb_y++){
3336
        ff_init_block_index(s);
3337
        for(; s->mb_x<s->mb_width; s->mb_x++){
3338
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3339
            int cbpc;
3340
            int dir=0;
3341
            
3342
            mb_num++;
3343
            ff_update_block_index(s);
3344
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3345
                s->first_slice_line=0;
3346
            
3347
            if(s->pict_type==I_TYPE){
3348
                int i;
3349

    
3350
                do{
3351
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
3352
                        return mb_num-1;
3353
                    }
3354

    
3355
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3356
                    if (cbpc < 0){
3357
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3358
                        return -1;
3359
                    }
3360
                }while(cbpc == 8);
3361
                
3362
                s->cbp_table[xy]= cbpc & 3;
3363
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3364
                s->mb_intra = 1;
3365

    
3366
                if(cbpc & 4) {
3367
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3368
                }
3369
                s->current_picture.qscale_table[xy]= s->qscale;
3370

    
3371
                s->mbintra_table[xy]= 1;
3372
                for(i=0; i<6; i++){
3373
                    int dc_pred_dir;
3374
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3375
                    if(dc < 0){
3376
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3377
                        return -1;
3378
                    }
3379
                    dir<<=1;
3380
                    if(dc_pred_dir) dir|=1;
3381
                }
3382
                s->pred_dir_table[xy]= dir;
3383
            }else{ /* P/S_TYPE */
3384
                int mx, my, pred_x, pred_y, bits;
3385
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3386
                const int stride= s->b8_stride*2;
3387

    
3388
try_again:
3389
                bits= show_bits(&s->gb, 17);
3390
                if(bits==MOTION_MARKER){
3391
                    return mb_num-1;
3392
                }
3393
                skip_bits1(&s->gb);
3394
                if(bits&0x10000){
3395
                    /* skip mb */
3396
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3397
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3398
                        mx= get_amv(s, 0);
3399
                        my= get_amv(s, 1);
3400
                    }else{
3401
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3402
                        mx=my=0;
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

    
3409
                    if(s->mbintra_table[xy])
3410
                        ff_clean_intra_table_entries(s);
3411
                    continue;
3412
                }
3413

    
3414
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3415
                if (cbpc < 0){
3416
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3417
                    return -1;
3418
                }
3419
                if(cbpc == 20)
3420
                    goto try_again;
3421

    
3422
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3423
    
3424
                s->mb_intra = ((cbpc & 4) != 0);
3425
        
3426
                if(s->mb_intra){
3427
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3428
                    s->mbintra_table[xy]= 1;
3429
                    mot_val[0       ]= mot_val[2       ]= 
3430
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3431
                    mot_val[1       ]= mot_val[3       ]=
3432
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3433
                }else{
3434
                    if(s->mbintra_table[xy])
3435
                        ff_clean_intra_table_entries(s);
3436

    
3437
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3438
                        s->mcsel= get_bits1(&s->gb);
3439
                    else s->mcsel= 0;
3440
        
3441
                    if ((cbpc & 16) == 0) {
3442
                        /* 16x16 motion prediction */
3443

    
3444
                        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3445
                        if(!s->mcsel){
3446
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3447
                            if (mx >= 0xffff)
3448
                                return -1;
3449

    
3450
                            my = h263_decode_motion(s, pred_y, s->f_code);
3451
                            if (my >= 0xffff)
3452
                                return -1;
3453
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3454
                        } else {
3455
                            mx = get_amv(s, 0);
3456
                            my = get_amv(s, 1);
3457
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3458
                        }
3459

    
3460
                        mot_val[0       ]= mot_val[2       ] =
3461
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3462
                        mot_val[1       ]= mot_val[3       ]=
3463
                        mot_val[1+stride]= mot_val[3+stride]= my;
3464
                    } else {
3465
                        int i;
3466
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3467
                        for(i=0;i<4;i++) {
3468
                            int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3469
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3470
                            if (mx >= 0xffff)
3471
                                return -1;
3472
                
3473
                            my = h263_decode_motion(s, pred_y, s->f_code);
3474
                            if (my >= 0xffff)
3475
                                return -1;
3476
                            mot_val[0] = mx;
3477
                            mot_val[1] = my;
3478
                        }
3479
                    }
3480
                }
3481
            }
3482
        }
3483
        s->mb_x= 0;
3484
    }
3485

    
3486
    return mb_num;
3487
}
3488

    
3489
/**
3490
 * decode second partition.
3491
 * @return <0 if an error occured
3492
 */
3493
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3494
    int mb_num=0;
3495
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3496

    
3497
    s->mb_x= s->resync_mb_x;
3498
    s->first_slice_line=1;
3499
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3500
        ff_init_block_index(s);
3501
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3502
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3503

    
3504
            mb_num++;
3505
            ff_update_block_index(s);
3506
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3507
                s->first_slice_line=0;
3508
            
3509
            if(s->pict_type==I_TYPE){
3510
                int ac_pred= get_bits1(&s->gb);
3511
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3512
                if(cbpy<0){
3513
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3514
                    return -1;
3515
                }
3516
                
3517
                s->cbp_table[xy]|= cbpy<<2;
3518
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3519
            }else{ /* P || S_TYPE */
3520
                if(IS_INTRA(s->current_picture.mb_type[xy])){          
3521
                    int dir=0,i;
3522
                    int ac_pred = get_bits1(&s->gb);
3523
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3524

    
3525
                    if(cbpy<0){
3526
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3527
                        return -1;
3528
                    }
3529
                    
3530
                    if(s->cbp_table[xy] & 8) {
3531
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3532
                    }
3533
                    s->current_picture.qscale_table[xy]= s->qscale;
3534

    
3535
                    for(i=0; i<6; i++){
3536
                        int dc_pred_dir;
3537
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3538
                        if(dc < 0){
3539
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3540
                            return -1;
3541
                        }
3542
                        dir<<=1;
3543
                        if(dc_pred_dir) dir|=1;
3544
                    }
3545
                    s->cbp_table[xy]&= 3; //remove dquant
3546
                    s->cbp_table[xy]|= cbpy<<2;
3547
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3548
                    s->pred_dir_table[xy]= dir;
3549
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3550
                    s->current_picture.qscale_table[xy]= s->qscale;
3551
                    s->cbp_table[xy]= 0;
3552
                }else{
3553
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3554

    
3555
                    if(cbpy<0){
3556
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3557
                        return -1;
3558
                    }
3559
                    
3560
                    if(s->cbp_table[xy] & 8) {
3561
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3562
                    }
3563
                    s->current_picture.qscale_table[xy]= s->qscale;
3564

    
3565
                    s->cbp_table[xy]&= 3; //remove dquant
3566
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3567
                }
3568
            }
3569
        }
3570
        if(mb_num >= mb_count) return 0;
3571
        s->mb_x= 0;
3572
    }
3573
    return 0;
3574
}
3575

    
3576
/**
3577
 * decodes the first & second partition
3578
 * @return <0 if error (and sets error type in the error_status_table)
3579
 */
3580
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3581
{
3582
    int mb_num;
3583
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3584
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3585
    
3586
    mb_num= mpeg4_decode_partition_a(s);    
3587
    if(mb_num<0){
3588
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3589
        return -1;
3590
    }
3591
    
3592
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3593
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3594
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3595
        return -1;
3596
    }
3597

    
3598
    s->mb_num_left= mb_num;
3599
        
3600
    if(s->pict_type==I_TYPE){
3601
        while(show_bits(&s->gb, 9) == 1)
3602
            skip_bits(&s->gb, 9);
3603
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3604
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3605
            return -1;
3606
        }
3607
    }else{
3608
        while(show_bits(&s->gb, 10) == 1)
3609
            skip_bits(&s->gb, 10);
3610
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3611
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3612
            return -1;
3613
        }
3614
    }
3615
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3616
    
3617
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3618
        if(s->pict_type==P_TYPE)
3619
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3620
        return -1;
3621
    }else{
3622
        if(s->pict_type==P_TYPE)
3623
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3624
    }
3625

    
3626
    return 0;        
3627
}
3628

    
3629
/**
3630
 * decode partition C of one MB.
3631
 * @return <0 if an error occured
3632
 */
3633
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3634
{
3635
    int cbp, mb_type;
3636
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3637

    
3638
    mb_type= s->current_picture.mb_type[xy];
3639
    cbp = s->cbp_table[xy];
3640

    
3641
    if(s->current_picture.qscale_table[xy] != s->qscale){
3642
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3643
    }
3644
    
3645
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3646
        int i;
3647
        for(i=0; i<4; i++){
3648
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3649
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3650
        }
3651
        s->mb_intra = IS_INTRA(mb_type);
3652

    
3653
        if (IS_SKIP(mb_type)) {
3654
            /* skip mb */
3655
            for(i=0;i<6;i++)
3656
                s->block_last_index[i] = -1;
3657
            s->mv_dir = MV_DIR_FORWARD;
3658
            s->mv_type = MV_TYPE_16X16;
3659
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3660
                s->mcsel=1;
3661
                s->mb_skiped = 0;
3662
            }else{
3663
                s->mcsel=0;
3664
                s->mb_skiped = 1;
3665
            }
3666
        }else if(s->mb_intra){
3667
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3668
        }else if(!s->mb_intra){
3669
//            s->mcsel= 0; //FIXME do we need to init that
3670
            
3671
            s->mv_dir = MV_DIR_FORWARD;
3672
            if (IS_8X8(mb_type)) {
3673
                s->mv_type = MV_TYPE_8X8;
3674
            } else {
3675
                s->mv_type = MV_TYPE_16X16;
3676
            }
3677
        }
3678
    } else { /* I-Frame */
3679
        s->mb_intra = 1;
3680
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3681
    }
3682

    
3683
    if (!IS_SKIP(mb_type)) {
3684
        int i;
3685
        /* decode each block */
3686
        for (i = 0; i < 6; i++) {
3687
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3688
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3689
                return -1;
3690
            }
3691
            cbp+=cbp;
3692
        }
3693
    }
3694

    
3695
    /* per-MB end of slice check */
3696

    
3697
    if(--s->mb_num_left <= 0){
3698
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3699
        if(mpeg4_is_resync(s))
3700
            return SLICE_END;
3701
        else
3702
            return SLICE_NOEND;     
3703
    }else{
3704
        if(mpeg4_is_resync(s)){
3705
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3706
            if(s->cbp_table[xy+delta])
3707
                return SLICE_END;
3708
        }
3709
        return SLICE_OK;
3710
    }
3711
}
3712

    
3713
/**
3714
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3715
 */
3716
static void preview_obmc(MpegEncContext *s){
3717
    GetBitContext gb= s->gb;
3718
    
3719
    int cbpc, i, pred_x, pred_y, mx, my;
3720
    int16_t *mot_val;
3721
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3722
    const int stride= s->b8_stride*2;
3723
    
3724
    for(i=0; i<4; i++)
3725
        s->block_index[i]+= 2;
3726
    for(i=4; i<6; i++)
3727
        s->block_index[i]+= 1;
3728
    s->mb_x++;
3729
    
3730
    assert(s->pict_type == P_TYPE);
3731

    
3732
    do{
3733
        if (get_bits1(&s->gb)) {
3734
            /* skip mb */
3735
            mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3736
            mot_val[0       ]= mot_val[2       ]= 
3737
            mot_val[0+stride]= mot_val[2+stride]= 0;
3738
            mot_val[1       ]= mot_val[3       ]=
3739
            mot_val[1+stride]= mot_val[3+stride]= 0;
3740
            
3741
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3742
            goto end;
3743
        }
3744
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3745
    }while(cbpc == 20);
3746
    
3747
    if(cbpc & 4){
3748
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3749
    }else{
3750
        get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3751
        if (cbpc & 8) {
3752
            if(s->modified_quant){
3753
                if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3754
                else                  skip_bits(&s->gb, 5);
3755
            }else
3756
                skip_bits(&s->gb, 2);
3757
        }
3758
        
3759
        if ((cbpc & 16) == 0) {
3760
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
3761
                /* 16x16 motion prediction */
3762
                mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3763
                if (s->umvplus)
3764
                   mx = h263p_decode_umotion(s, pred_x);
3765
                else
3766
                   mx = h263_decode_motion(s, pred_x, 1);
3767
            
3768
                if (s->umvplus)
3769
                   my = h263p_decode_umotion(s, pred_y);
3770
                else
3771
                   my = h263_decode_motion(s, pred_y, 1);
3772
            
3773
                mot_val[0       ]= mot_val[2       ]= 
3774
                mot_val[0+stride]= mot_val[2+stride]= mx;
3775
                mot_val[1       ]= mot_val[3       ]=
3776
                mot_val[1+stride]= mot_val[3+stride]= my;
3777
        } else {
3778
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3779
            for(i=0;i<4;i++) {
3780
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3781
                if (s->umvplus)
3782
                  mx = h263p_decode_umotion(s, pred_x);
3783
                else
3784
                  mx = h263_decode_motion(s, pred_x, 1);
3785
                
3786
                if (s->umvplus)
3787
                  my = h263p_decode_umotion(s, pred_y);
3788
                else    
3789
                  my = h263_decode_motion(s, pred_y, 1);
3790
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3791
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3792
                mot_val[0] = mx;
3793
                mot_val[1] = my;
3794
            }
3795
        }
3796
    }
3797
end:
3798
        
3799
    for(i=0; i<4; i++)
3800
        s->block_index[i]-= 2;
3801
    for(i=4; i<6; i++)
3802
        s->block_index[i]-= 1;
3803
    s->mb_x--;
3804

    
3805
    s->gb= gb;
3806
}
3807

    
3808
static void h263_decode_dquant(MpegEncContext *s){
3809
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3810

    
3811
    if(s->modified_quant){
3812
        if(get_bits1(&s->gb))
3813
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3814
        else
3815
            s->qscale= get_bits(&s->gb, 5);
3816
    }else
3817
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3818
    ff_set_qscale(s, s->qscale);
3819
}
3820

    
3821
int ff_h263_decode_mb(MpegEncContext *s,
3822
                      DCTELEM block[6][64])
3823
{
3824
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3825
    int16_t *mot_val;
3826
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3827
    
3828
    assert(!s->h263_pred);
3829
    
3830
    if (s->pict_type == P_TYPE) {
3831
        do{
3832
            if (get_bits1(&s->gb)) {
3833
                /* skip mb */
3834
                s->mb_intra = 0;
3835
                for(i=0;i<6;i++)
3836
                    s->block_last_index[i] = -1;
3837
                s->mv_dir = MV_DIR_FORWARD;
3838
                s->mv_type = MV_TYPE_16X16;
3839
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3840
                s->mv[0][0][0] = 0;
3841
                s->mv[0][0][1] = 0;
3842
                s->mb_skiped = !(s->obmc | s->loop_filter);
3843
                goto end;
3844
            }
3845
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3846
            //fprintf(stderr, "\tCBPC: %d", cbpc);
3847
            if (cbpc < 0){
3848
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3849
                return -1;
3850
            }
3851
        }while(cbpc == 20);
3852
        
3853
        dquant = cbpc & 8;
3854
        s->mb_intra = ((cbpc & 4) != 0);
3855
        if (s->mb_intra) goto intra;
3856
        
3857
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3858
        
3859
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3860
            cbpy ^= 0xF;
3861
        
3862
        cbp = (cbpc & 3) | (cbpy << 2);
3863
        if (dquant) {
3864
            h263_decode_dquant(s);
3865
        }
3866
        
3867
        s->mv_dir = MV_DIR_FORWARD;
3868
        if ((cbpc & 16) == 0) {
3869
            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
3870
            /* 16x16 motion prediction */
3871
            s->mv_type = MV_TYPE_16X16;
3872
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3873
            if (s->umvplus)
3874
               mx = h263p_decode_umotion(s, pred_x);
3875
            else
3876
               mx = h263_decode_motion(s, pred_x, 1);
3877
            
3878
            if (mx >= 0xffff)
3879
                return -1;
3880
            
3881
            if (s->umvplus)
3882
               my = h263p_decode_umotion(s, pred_y);
3883
            else
3884
               my = h263_decode_motion(s, pred_y, 1);
3885
            
3886
            if (my >= 0xffff)
3887
                return -1;
3888
            s->mv[0][0][0] = mx;
3889
            s->mv[0][0][1] = my;
3890

    
3891
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3892
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3893
        } else {
3894
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3895
            s->mv_type = MV_TYPE_8X8;
3896
            for(i=0;i<4;i++) {
3897
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3898
                if (s->umvplus)
3899
                  mx = h263p_decode_umotion(s, pred_x);
3900
                else
3901
                  mx = h263_decode_motion(s, pred_x, 1);
3902
                if (mx >= 0xffff)
3903
                    return -1;
3904
                
3905
                if (s->umvplus)
3906
                  my = h263p_decode_umotion(s, pred_y);
3907
                else    
3908
                  my = h263_decode_motion(s, pred_y, 1);
3909
                if (my >= 0xffff)
3910
                    return -1;
3911
                s->mv[0][i][0] = mx;
3912
                s->mv[0][i][1] = my;
3913
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3914
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3915
                mot_val[0] = mx;
3916
                mot_val[1] = my;
3917
            }
3918
        }
3919

    
3920
        /* decode each block */
3921
        for (i = 0; i < 6; i++) {
3922
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3923
                return -1;
3924
            cbp+=cbp;
3925
        }
3926

    
3927
        if(s->obmc){
3928
            if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
3929
                preview_obmc(s);
3930
        }
3931
    } else if(s->pict_type==B_TYPE) {
3932
        int mb_type;
3933
        const int stride= s->b8_stride;
3934
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
3935
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
3936
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3937

    
3938
        //FIXME ugly 
3939
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= 
3940
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= 
3941
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= 
3942
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
3943

    
3944
        do{
3945
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
3946
            if (mb_type < 0){
3947
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
3948
                return -1;
3949
            }
3950

    
3951
            mb_type= h263_mb_type_b_map[ mb_type ];
3952
        }while(!mb_type);
3953

    
3954
        s->mb_intra = IS_INTRA(mb_type);
3955
        if(HAS_CBP(mb_type)){
3956
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
3957
            if(s->mb_intra){
3958
                dquant = IS_QUANT(mb_type);
3959
                goto intra;
3960
            }
3961

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

    
3964
            if (cbpy < 0){
3965
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3966
                return -1;
3967
            }
3968
        
3969
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3970
                cbpy ^= 0xF;
3971
        
3972
            cbp = (cbpc & 3) | (cbpy << 2);
3973
        }else
3974
            cbp=0;
3975
            
3976
        assert(!s->mb_intra);
3977

    
3978
        if(IS_QUANT(mb_type)){
3979
            h263_decode_dquant(s);
3980
        }
3981

    
3982
        if(IS_DIRECT(mb_type)){
3983
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3984
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
3985
        }else{
3986
            s->mv_dir = 0;
3987
            s->mv_type= MV_TYPE_16X16;
3988
//FIXME UMV
3989

    
3990
            if(USES_LIST(mb_type, 0)){
3991
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
3992
                s->mv_dir = MV_DIR_FORWARD;
3993

    
3994
                mx = h263_decode_motion(s, mx, 1);
3995
                my = h263_decode_motion(s, my, 1);
3996
                
3997
                s->mv[0][0][0] = mx;
3998
                s->mv[0][0][1] = my;
3999
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4000
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4001
            }
4002
    
4003
            if(USES_LIST(mb_type, 1)){
4004
                int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4005
                s->mv_dir |= MV_DIR_BACKWARD;
4006
                
4007
                mx = h263_decode_motion(s, mx, 1);
4008
                my = h263_decode_motion(s, my, 1);
4009

    
4010
                s->mv[1][0][0] = mx;
4011
                s->mv[1][0][1] = my;
4012
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4013
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4014
            }
4015
        }
4016
          
4017
        s->current_picture.mb_type[xy]= mb_type;
4018

    
4019
        /* decode each block */
4020
        for (i = 0; i < 6; i++) {
4021
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4022
                return -1;
4023
            cbp+=cbp;
4024
        }
4025
    } else { /* I-Frame */
4026
        do{
4027
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4028
            if (cbpc < 0){
4029
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4030
                return -1;
4031
            }
4032
        }while(cbpc == 8);
4033

    
4034
        dquant = cbpc & 4;
4035
        s->mb_intra = 1;
4036
intra:
4037
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4038
        if (s->h263_aic) {
4039
            s->ac_pred = get_bits1(&s->gb);
4040
            if(s->ac_pred){
4041
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4042
            
4043
                s->h263_aic_dir = get_bits1(&s->gb);
4044
            }
4045
        }else
4046
            s->ac_pred = 0;
4047
        
4048
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4049
        if(cbpy<0){
4050
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4051
            return -1;
4052
        }
4053
        cbp = (cbpc & 3) | (cbpy << 2);
4054
        if (dquant) {
4055
            h263_decode_dquant(s);
4056
        }
4057

    
4058
        /* decode each block */
4059
        for (i = 0; i < 6; i++) {
4060
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4061
                return -1;
4062
            cbp+=cbp;
4063
        }
4064
    }
4065
end:
4066

    
4067
        /* per-MB end of slice check */
4068
    {
4069
        int v= show_bits(&s->gb, 16);
4070
    
4071
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4072
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4073
        }
4074

    
4075
        if(v==0)
4076
            return SLICE_END;
4077
    }
4078

    
4079
    return SLICE_OK;     
4080
}
4081

    
4082
int ff_mpeg4_decode_mb(MpegEncContext *s,
4083
                      DCTELEM block[6][64])
4084
{
4085
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4086
    int16_t *mot_val;
4087
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4088
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4089
    
4090
    assert(s->h263_pred);
4091
    
4092
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4093
        do{
4094
            if (get_bits1(&s->gb)) {
4095
                /* skip mb */
4096
                s->mb_intra = 0;
4097
                for(i=0;i<6;i++)
4098
                    s->block_last_index[i] = -1;
4099
                s->mv_dir = MV_DIR_FORWARD;
4100
                s->mv_type = MV_TYPE_16X16;
4101
                if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4102
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4103
                    s->mcsel=1;
4104
                    s->mv[0][0][0]= get_amv(s, 0);
4105
                    s->mv[0][0][1]= get_amv(s, 1);
4106

    
4107
                    s->mb_skiped = 0;
4108
                }else{
4109
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4110
                    s->mcsel=0;
4111
                    s->mv[0][0][0] = 0;
4112
                    s->mv[0][0][1] = 0;
4113
                    s->mb_skiped = 1;
4114
                }
4115
                goto end;
4116
            }
4117
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4118
            //fprintf(stderr, "\tCBPC: %d", cbpc);
4119
            if (cbpc < 0){
4120
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4121
                return -1;
4122
            }
4123
        }while(cbpc == 20);
4124
        
4125
        dquant = cbpc & 8;
4126
        s->mb_intra = ((cbpc & 4) != 0);
4127
        if (s->mb_intra) goto intra;
4128
        
4129
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4130
            s->mcsel= get_bits1(&s->gb);
4131
        else s->mcsel= 0;
4132
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4133
        
4134
        cbp = (cbpc & 3) | (cbpy << 2);
4135
        if (dquant) {
4136
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4137
        }
4138
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4139
            s->interlaced_dct= get_bits1(&s->gb);
4140
        
4141
        s->mv_dir = MV_DIR_FORWARD;
4142
        if ((cbpc & 16) == 0) {
4143
            if(s->mcsel){
4144
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4145
                /* 16x16 global motion prediction */
4146
                s->mv_type = MV_TYPE_16X16;
4147
                mx= get_amv(s, 0);
4148
                my= get_amv(s, 1);
4149
                s->mv[0][0][0] = mx;
4150
                s->mv[0][0][1] = my;
4151
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4152
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; 
4153
                /* 16x8 field motion prediction */
4154
                s->mv_type= MV_TYPE_FIELD;
4155

    
4156
                s->field_select[0][0]= get_bits1(&s->gb);
4157
                s->field_select[0][1]= get_bits1(&s->gb);
4158

    
4159
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4160
                
4161
                for(i=0; i<2; i++){
4162
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4163
                    if (mx >= 0xffff)
4164
                        return -1;
4165
            
4166
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4167
                    if (my >= 0xffff)
4168
                        return -1;
4169

    
4170
                    s->mv[0][i][0] = mx;
4171
                    s->mv[0][i][1] = my;
4172
                }
4173
            }else{
4174
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
4175
                /* 16x16 motion prediction */
4176
                s->mv_type = MV_TYPE_16X16;
4177
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4178
                mx = h263_decode_motion(s, pred_x, s->f_code);
4179
            
4180
                if (mx >= 0xffff)
4181
                    return -1;
4182
            
4183
                my = h263_decode_motion(s, pred_y, s->f_code);
4184
            
4185
                if (my >= 0xffff)
4186
                    return -1;
4187
                s->mv[0][0][0] = mx;
4188
                s->mv[0][0][1] = my;
4189
            }
4190
        } else {
4191
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
4192
            s->mv_type = MV_TYPE_8X8;
4193
            for(i=0;i<4;i++) {
4194
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4195
                mx = h263_decode_motion(s, pred_x, s->f_code);
4196
                if (mx >= 0xffff)
4197
                    return -1;
4198
                
4199
                my = h263_decode_motion(s, pred_y, s->f_code);
4200
                if (my >= 0xffff)
4201
                    return -1;
4202
                s->mv[0][i][0] = mx;
4203
                s->mv[0][i][1] = my;
4204
                mot_val[0] = mx;
4205
                mot_val[1] = my;
4206
            }
4207
        }
4208
    } else if(s->pict_type==B_TYPE) {
4209
        int modb1; // first bit of modb
4210
        int modb2; // second bit of modb
4211
        int mb_type;
4212

    
4213
        s->mb_intra = 0; //B-frames never contain intra blocks
4214
        s->mcsel=0;      //     ...               true gmc blocks
4215

    
4216
        if(s->mb_x==0){
4217
            for(i=0; i<2; i++){
4218
                s->last_mv[i][0][0]= 
4219
                s->last_mv[i][0][1]= 
4220
                s->last_mv[i][1][0]= 
4221
                s->last_mv[i][1][1]= 0;
4222
            }
4223
        }
4224

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

    
4228
        if(s->mb_skiped){
4229
                /* skip mb */
4230
            for(i=0;i<6;i++)
4231
                s->block_last_index[i] = -1;
4232

    
4233
            s->mv_dir = MV_DIR_FORWARD;
4234
            s->mv_type = MV_TYPE_16X16;
4235
            s->mv[0][0][0] = 0;
4236
            s->mv[0][0][1] = 0;
4237
            s->mv[1][0][0] = 0;
4238
            s->mv[1][0][1] = 0;
4239
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 
4240
            goto end;
4241
        }
4242

    
4243
        modb1= get_bits1(&s->gb); 
4244
        if(modb1){
4245
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4246
            cbp=0;
4247
        }else{
4248
            modb2= get_bits1(&s->gb);
4249
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4250
            if(mb_type<0){
4251
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4252
                return -1;
4253
            }
4254
            mb_type= mb_type_b_map[ mb_type ];
4255
            if(modb2) cbp= 0;
4256
            else      cbp= get_bits(&s->gb, 6);
4257

    
4258
            if ((!IS_DIRECT(mb_type)) && cbp) {
4259
                if(get_bits1(&s->gb)){
4260
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4261
                }
4262
            }
4263

    
4264
            if(!s->progressive_sequence){
4265
                if(cbp)
4266
                    s->interlaced_dct= get_bits1(&s->gb);
4267

    
4268
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4269
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4270
                    mb_type &= ~MB_TYPE_16x16;
4271

    
4272
                    if(USES_LIST(mb_type, 0)){
4273
                        s->field_select[0][0]= get_bits1(&s->gb);
4274
                        s->field_select[0][1]= get_bits1(&s->gb);
4275
                    }
4276
                    if(USES_LIST(mb_type, 1)){
4277
                        s->field_select[1][0]= get_bits1(&s->gb);
4278
                        s->field_select[1][1]= get_bits1(&s->gb);
4279
                    }
4280
                }
4281
            }
4282

    
4283
            s->mv_dir = 0;
4284
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4285
                s->mv_type= MV_TYPE_16X16;
4286

    
4287
                if(USES_LIST(mb_type, 0)){
4288
                    s->mv_dir = MV_DIR_FORWARD;
4289

    
4290
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4291
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4292
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4293
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4294
                }
4295
    
4296
                if(USES_LIST(mb_type, 1)){
4297
                    s->mv_dir |= MV_DIR_BACKWARD;
4298

    
4299
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4300
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4301
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4302
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4303
                }
4304
            }else if(!IS_DIRECT(mb_type)){
4305
                s->mv_type= MV_TYPE_FIELD;
4306

    
4307
                if(USES_LIST(mb_type, 0)){
4308
                    s->mv_dir = MV_DIR_FORWARD;
4309
                
4310
                    for(i=0; i<2; i++){
4311
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4312
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4313
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4314
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4315
                    }
4316
                }
4317
    
4318
                if(USES_LIST(mb_type, 1)){
4319
                    s->mv_dir |= MV_DIR_BACKWARD;
4320

    
4321
                    for(i=0; i<2; i++){
4322
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4323
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4324
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4325
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4326
                    }
4327
                }
4328
            }
4329
        }
4330
          
4331
        if(IS_DIRECT(mb_type)){
4332
            if(IS_SKIP(mb_type))
4333
                mx=my=0;
4334
            else{
4335
                mx = h263_decode_motion(s, 0, 1);
4336
                my = h263_decode_motion(s, 0, 1);
4337
            }
4338
 
4339
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4340
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4341
        }
4342
        s->current_picture.mb_type[xy]= mb_type;
4343
    } else { /* I-Frame */
4344
        do{
4345
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4346
            if (cbpc < 0){
4347
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4348
                return -1;
4349
            }
4350
        }while(cbpc == 8);
4351

    
4352
        dquant = cbpc & 4;
4353
        s->mb_intra = 1;
4354
intra:
4355
        s->ac_pred = get_bits1(&s->gb);
4356
        if(s->ac_pred)
4357
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4358
        else
4359
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4360
        
4361
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4362
        if(cbpy<0){
4363
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4364
            return -1;
4365
        }
4366
        cbp = (cbpc & 3) | (cbpy << 2);
4367
        if (dquant) {
4368
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4369
        }
4370
        
4371
        if(!s->progressive_sequence)
4372
            s->interlaced_dct= get_bits1(&s->gb);
4373

    
4374
        /* decode each block */
4375
        for (i = 0; i < 6; i++) {
4376
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4377
                return -1;
4378
            cbp+=cbp;
4379
        }
4380
        goto end;
4381
    }
4382

    
4383
    /* decode each block */
4384
    for (i = 0; i < 6; i++) {
4385
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4386
            return -1;
4387
        cbp+=cbp;
4388
    }
4389
end:
4390

    
4391
        /* per-MB end of slice check */
4392
    if(s->codec_id==CODEC_ID_MPEG4){
4393
        if(mpeg4_is_resync(s)){
4394
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4395
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4396
                return SLICE_OK;
4397
            return SLICE_END;
4398
        }
4399
    }
4400

    
4401
    return SLICE_OK;     
4402
}
4403

    
4404
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4405
{
4406
    int code, val, sign, shift, l;
4407
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4408

    
4409
    if (code == 0)
4410
        return pred;
4411
    if (code < 0)
4412
        return 0xffff;
4413

    
4414
    sign = get_bits1(&s->gb);
4415
    shift = f_code - 1;
4416
    val = code;
4417
    if (shift) {
4418
        val = (val - 1) << shift;
4419
        val |= get_bits(&s->gb, shift);
4420
        val++;
4421
    }
4422
    if (sign)
4423
        val = -val;
4424
    val += pred;
4425

    
4426
    /* modulo decoding */
4427
    if (!s->h263_long_vectors) {
4428
        l = INT_BIT - 5 - f_code;
4429
        val = (val<<l)>>l;
4430
    } else {
4431
        /* horrible h263 long vector mode */
4432
        if (pred < -31 && val < -63)
4433
            val += 64;
4434
        if (pred > 32 && val > 63)
4435
            val -= 64;
4436
        
4437
    }
4438
    return val;
4439
}
4440

    
4441
/* Decodes RVLC of H.263+ UMV */
4442
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4443
{
4444
   int code = 0, sign;
4445
   
4446
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4447
      return pred;
4448
   
4449
   code = 2 + get_bits1(&s->gb);
4450
   
4451
   while (get_bits1(&s->gb))
4452
   {
4453
      code <<= 1;
4454
      code += get_bits1(&s->gb);
4455
   }
4456
   sign = code & 1;
4457
   code >>= 1;
4458
   
4459
   code = (sign) ? (pred - code) : (pred + code);
4460
#ifdef DEBUG
4461
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
4462
#endif
4463
   return code;   
4464

    
4465
}
4466

    
4467
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4468
                             int n, int coded)
4469
{
4470
    int code, level, i, j, last, run;
4471
    RLTable *rl = &rl_inter;
4472
    const uint8_t *scan_table;
4473
    GetBitContext gb= s->gb;
4474

    
4475
    scan_table = s->intra_scantable.permutated;
4476
    if (s->h263_aic && s->mb_intra) {
4477
        rl = &rl_intra_aic;
4478
        i = 0;
4479
        if (s->ac_pred) {
4480
            if (s->h263_aic_dir) 
4481
                scan_table = s->intra_v_scantable.permutated; /* left */
4482
            else
4483
                scan_table = s->intra_h_scantable.permutated; /* top */
4484
        }
4485
    } else if (s->mb_intra) {
4486
        /* DC coef */
4487
        if(s->codec_id == CODEC_ID_RV10){
4488
          if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4489
            int component, diff;
4490
            component = (n <= 3 ? 0 : n - 4 + 1);
4491
            level = s->last_dc[component];
4492
            if (s->rv10_first_dc_coded[component]) {
4493
                diff = rv_decode_dc(s, n);
4494
                if (diff == 0xffff)
4495
                    return -1;
4496
                level += diff;
4497
                level = level & 0xff; /* handle wrap round */
4498
                s->last_dc[component] = level;
4499
            } else {
4500
                s->rv10_first_dc_coded[component] = 1;
4501
            }
4502
          } else {
4503
                level = get_bits(&s->gb, 8);
4504
                if (level == 255)
4505
                    level = 128;
4506
          }
4507
        }else{
4508
            level = get_bits(&s->gb, 8);
4509
            if((level&0x7F) == 0){
4510
                av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4511
                if(s->error_resilience >= FF_ER_COMPLIANT)
4512
                    return -1;
4513
            }
4514
            if (level == 255)
4515
                level = 128;
4516
        }
4517
        block[0] = level;
4518
        i = 1;
4519
    } else {
4520
        i = 0;
4521
    }
4522
    if (!coded) {
4523
        if (s->mb_intra && s->h263_aic)
4524
            goto not_coded;
4525
        s->block_last_index[n] = i - 1;
4526
        return 0;
4527
    }
4528
retry:
4529
    for(;;) {
4530
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4531
        if (code < 0){
4532
            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4533
            return -1;
4534
        }
4535
        if (code == rl->n) {
4536
            /* escape */
4537
            if (s->h263_flv > 1) {
4538
                int is11 = get_bits1(&s->gb);
4539
                last = get_bits1(&s->gb);
4540
                run = get_bits(&s->gb, 6);
4541
                if(is11){
4542
                    level = get_sbits(&s->gb, 11);
4543
                } else {
4544
                    level = get_sbits(&s->gb, 7);
4545
                }
4546
            } else {
4547
                last = get_bits1(&s->gb);
4548
                run = get_bits(&s->gb, 6);
4549
                level = (int8_t)get_bits(&s->gb, 8);
4550
                if(level == -128){
4551
                    if (s->codec_id == CODEC_ID_RV10) {
4552
                        /* XXX: should patch encoder too */
4553
                        level = get_sbits(&s->gb, 12);
4554
                    }else{
4555
                        level = get_bits(&s->gb, 5);
4556
                        level |= get_sbits(&s->gb, 6)<<5;
4557
                    }
4558
                }
4559
            }
4560
        } else {
4561
            run = rl->table_run[code];
4562
            level = rl->table_level[code];
4563
            last = code >= rl->last;
4564
            if (get_bits1(&s->gb))
4565
                level = -level;
4566
        }
4567
        i += run;
4568
        if (i >= 64){
4569
            if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4570
                //looks like a hack but no, its the way its supposed to work ...
4571
                rl = &rl_intra_aic;
4572
                i = 0;
4573
                s->gb= gb;
4574
                memset(block, 0, sizeof(DCTELEM)*64);
4575
                goto retry;
4576
            }
4577
            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
4578
            return -1;
4579
        }
4580
        j = scan_table[i];
4581
        block[j] = level;
4582
        if (last)
4583
            break;
4584
        i++;
4585
    }
4586
not_coded:    
4587
    if (s->mb_intra && s->h263_aic) {
4588
        h263_pred_acdc(s, block, n);
4589
        i = 63;
4590
    }
4591
    s->block_last_index[n] = i;
4592
    return 0;
4593
}
4594

    
4595
/**
4596
 * decodes the dc value.
4597
 * @param n block index (0-3 are luma, 4-5 are chroma)
4598
 * @param dir_ptr the prediction direction will be stored here
4599
 * @return the quantized dc
4600
 */
4601
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4602
{
4603
    int level, code;
4604

    
4605
    if (n < 4) 
4606
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4607
    else 
4608
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4609
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4610
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4611
        return -1;
4612
    }
4613
    if (code == 0) {
4614
        level = 0;
4615
    } else {
4616
        if(IS_3IV1){
4617
            if(code==1)
4618
                level= 2*get_bits1(&s->gb)-1;
4619
            else{
4620
                if(get_bits1(&s->gb))
4621
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4622
                else
4623
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4624
            }
4625
        }else{
4626
            level = get_xbits(&s->gb, code);
4627
        }
4628

    
4629
        if (code > 8){
4630
            if(get_bits1(&s->gb)==0){ /* marker */
4631
                if(s->error_resilience>=2){
4632
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4633
                    return -1;
4634
                }
4635
            }
4636
        }
4637
    }
4638

    
4639
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4640
}
4641

    
4642
/**
4643
 * decodes a block.
4644
 * @return <0 if an error occured
4645
 */
4646
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4647
                              int n, int coded, int intra, int rvlc)
4648
{
4649
    int level, i, last, run;
4650
    int dc_pred_dir;
4651
    RLTable * rl;
4652
    RL_VLC_ELEM * rl_vlc;
4653
    const uint8_t * scan_table;
4654
    int qmul, qadd;
4655

    
4656
    //Note intra & rvlc should be optimized away if this is inlined
4657
    
4658
    if(intra) {
4659
      if(s->qscale < s->intra_dc_threshold){
4660
        /* DC coef */
4661
        if(s->partitioned_frame){
4662
            level = s->dc_val[0][ s->block_index[n] ];
4663
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4664
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4665
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4666
        }else{
4667
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4668
            if (level < 0)
4669
                return -1;
4670
        }
4671
        block[0] = level;
4672
        i = 0;
4673
      }else{
4674
            i = -1;
4675
      }  
4676
        if (!coded) 
4677
            goto not_coded;
4678
        
4679
        if(rvlc){        
4680
            rl = &rvlc_rl_intra;
4681
            rl_vlc = rvlc_rl_intra.rl_vlc[0];
4682
        }else{
4683
            rl = &rl_intra;
4684
            rl_vlc = rl_intra.rl_vlc[0];
4685
        }
4686
        if (s->ac_pred) {
4687
            if (dc_pred_dir == 0) 
4688
                scan_table = s->intra_v_scantable.permutated; /* left */
4689
            else
4690
                scan_table = s->intra_h_scantable.permutated; /* top */
4691
        } else {
4692
            scan_table = s->intra_scantable.permutated;
4693
        }
4694
        qmul=1;
4695
        qadd=0;
4696
    } else {
4697
        i = -1;
4698
        if (!coded) {
4699
            s->block_last_index[n] = i;
4700
            return 0;
4701
        }
4702
        if(rvlc) rl = &rvlc_rl_inter;
4703
        else     rl = &rl_inter;
4704
   
4705
        scan_table = s->intra_scantable.permutated;
4706

    
4707
        if(s->mpeg_quant){
4708
            qmul=1;
4709
            qadd=0;
4710
            if(rvlc){        
4711
                rl_vlc = rvlc_rl_inter.rl_vlc[0];        
4712
            }else{
4713
                rl_vlc = rl_inter.rl_vlc[0];        
4714
            }
4715
        }else{
4716
            qmul = s->qscale << 1;
4717
            qadd = (s->qscale - 1) | 1;
4718
            if(rvlc){        
4719
                rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];        
4720
            }else{
4721
                rl_vlc = rl_inter.rl_vlc[s->qscale];        
4722
            }
4723
        }
4724
    }
4725
  {
4726
    OPEN_READER(re, &s->gb);
4727
    for(;;) {
4728
        UPDATE_CACHE(re, &s->gb);
4729
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4730
        if (level==0) {
4731
          /* escape */                
4732
          if(rvlc){
4733
                if(SHOW_UBITS(re, &s->gb, 1)==0){
4734
                    av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4735
                    return -1;
4736
                }; SKIP_CACHE(re, &s->gb, 1);
4737
 
4738
                last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4739
                run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4740
                SKIP_COUNTER(re, &s->gb, 1+1+6);
4741
                UPDATE_CACHE(re, &s->gb);
4742
              
4743
                if(SHOW_UBITS(re, &s->gb, 1)==0){
4744
                    av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4745
                    return -1;
4746
                }; SKIP_CACHE(re, &s->gb, 1);
4747
 
4748
                level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4749
 
4750
                if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4751
                    av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4752
                    return -1;
4753
                }; SKIP_CACHE(re, &s->gb, 5);
4754

    
4755
                level=  level * qmul + qadd;
4756
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4757
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4758

    
4759
                i+= run + 1;
4760
                if(last) i+=192;
4761
          }else{
4762
            int cache;
4763
            cache= GET_CACHE(re, &s->gb);
4764

    
4765
            if(IS_3IV1) 
4766
                cache ^= 0xC0000000;
4767

    
4768
            if (cache&0x80000000) {
4769
                if (cache&0x40000000) {
4770
                    /* third escape */
4771
                    SKIP_CACHE(re, &s->gb, 2);
4772
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4773
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4774
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
4775
                    UPDATE_CACHE(re, &s->gb);
4776

    
4777