Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 137c8468

History | View | Annotate | Download (206 KB)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
135
#ifdef CONFIG_ENCODERS
136

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

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

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

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

    
156
      align_put_bits(&s->pb);
157

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

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

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

    
222
    align_put_bits(&s->pb);
223

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

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

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

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

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

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

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

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

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

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

    
350
        ff_h263_encode_mba(s);
351

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

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

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

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

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

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

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

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

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

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

    
458
    return score < 0;
459
}
460

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

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

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

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

    
501
/**
502
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
503
 */
504
void ff_clean_mpeg4_qscales(MpegEncContext *s){
505
    int i;
506
    int8_t * const qscale_table= s->current_picture.qscale_table;
507

    
508
    ff_clean_h263_qscales(s);
509
    
510
    for(i=1; i<s->mb_num; i++){
511
        int mb_xy= s->mb_index2xy[i];
512
    
513
        if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
514
            s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
515
            s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
516
        }
517
    }
518

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

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

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

    
618
    if(s->mv_type != MV_TYPE_8X8){
619
        int motion_x, motion_y;
620
        if (s->mb_intra) {
621
            motion_x = 0;
622
            motion_y = 0;
623
        } else if (s->mv_type == MV_TYPE_16X16) {
624
            motion_x = s->mv[0][0][0];
625
            motion_y = s->mv[0][0][1];
626
        } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
627
            int i;
628
            motion_x = s->mv[0][0][0] + s->mv[0][1][0];
629
            motion_y = s->mv[0][0][1] + s->mv[0][1][1];
630
            motion_x = (motion_x>>1) | (motion_x&1);
631
            for(i=0; i<2; i++){
632
                s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
633
                s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
634
                s->p_field_select_table[i][mb_xy]= s->field_select[0][i];
635
            }
636
        }
637
        
638
        /* no update if 8X8 because it has been done during parsing */
639
        s->current_picture.motion_val[0][xy][0] = motion_x;
640
        s->current_picture.motion_val[0][xy][1] = motion_y;
641
        s->current_picture.motion_val[0][xy + 1][0] = motion_x;
642
        s->current_picture.motion_val[0][xy + 1][1] = motion_y;
643
        s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
644
        s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
645
        s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
646
        s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
647
    }
648

    
649
    if(s->encoding){ //FIXME encoding MUST be cleaned up
650
        if (s->mv_type == MV_TYPE_8X8) 
651
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
652
        else if(s->mb_intra)
653
            s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
654
        else
655
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
656
    }
657
}
658

    
659
#ifdef CONFIG_ENCODERS
660

    
661
static inline int get_p_cbp(MpegEncContext * s,
662
                      DCTELEM block[6][64],
663
                      int motion_x, int motion_y){
664
    int cbp, i;
665

    
666
    if(s->flags & CODEC_FLAG_CBP_RD){
667
        int best_cbpy_score= INT_MAX;
668
        int best_cbpc_score= INT_MAX;
669
        int cbpc = (-1), cbpy= (-1);
670
        const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
671
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
672

    
673
        for(i=0; i<4; i++){
674
            int score= inter_MCBPC_bits[i + offset] * lambda;
675
            if(i&1) score += s->coded_score[5];
676
            if(i&2) score += s->coded_score[4];
677

    
678
            if(score < best_cbpc_score){
679
                best_cbpc_score= score;
680
                cbpc= i;
681
            }
682
        }
683

    
684
        for(i=0; i<16; i++){
685
            int score= cbpy_tab[i ^ 0xF][1] * lambda;
686
            if(i&1) score += s->coded_score[3];
687
            if(i&2) score += s->coded_score[2];
688
            if(i&4) score += s->coded_score[1];
689
            if(i&8) score += s->coded_score[0];
690

    
691
            if(score < best_cbpy_score){
692
                best_cbpy_score= score;
693
                cbpy= i;
694
            }
695
        }
696
        cbp= cbpc + 4*cbpy;
697
        if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
698
            if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
699
                cbp= 0;
700
        }
701

    
702
        for (i = 0; i < 6; i++) {
703
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
704
                s->block_last_index[i]= -1;
705
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
706
            }
707
        }
708
    }else{
709
        cbp= 0;
710
        for (i = 0; i < 6; i++) {
711
            if (s->block_last_index[i] >= 0)
712
                cbp |= 1 << (5 - i);
713
        }
714
    }
715
    return cbp;
716
}
717

    
718
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
719
                            int motion_x, int motion_y, int mb_type){
720
    int cbp=0, i;
721

    
722
    if(s->flags & CODEC_FLAG_CBP_RD){
723
        int score=0;
724
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
725
        
726
        for(i=0; i<6; i++){
727
            if(s->coded_score[i] < 0){
728
                score += s->coded_score[i];
729
                cbp |= 1 << (5 - i);
730
            }
731
        }
732
        
733
        if(cbp){
734
            int zero_score= -6;
735
            if ((motion_x | motion_y | s->dquant | mb_type) == 0){
736
                zero_score-= 4; //2*MV + mb_type + cbp bit
737
            }
738

    
739
            zero_score*= lambda;
740
            if(zero_score <= score){
741
                cbp=0;
742
            }
743
        }
744

    
745
        for (i = 0; i < 6; i++) {
746
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
747
                s->block_last_index[i]= -1;
748
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
749
            }
750
        }
751
    }else{
752
        for (i = 0; i < 6; i++) {
753
            if (s->block_last_index[i] >= 0)
754
                cbp |= 1 << (5 - i);
755
        }
756
    }
757
    return cbp;
758
}
759

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

    
779
            if(s->mb_x==0){
780
                for(i=0; i<2; i++){
781
                    s->last_mv[i][0][0]= 
782
                    s->last_mv[i][0][1]= 
783
                    s->last_mv[i][1][0]= 
784
                    s->last_mv[i][1][1]= 0;
785
                }
786
            }
787
            
788
            assert(s->dquant>=-2 && s->dquant<=2);
789
            assert((s->dquant&1)==0);
790
            assert(mb_type>=0);
791

    
792
            /* nothing to do if this MB was skiped in the next P Frame */
793
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
794
                s->skip_count++;
795
                s->mv[0][0][0]= 
796
                s->mv[0][0][1]= 
797
                s->mv[1][0][0]= 
798
                s->mv[1][0][1]= 0;
799
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
800
                s->qscale -= s->dquant;
801
//                s->mb_skiped=1;
802

    
803
                return;
804
            }
805
            
806
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
807
            
808
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
809
                /* direct MB with MV={0,0} */
810
                assert(s->dquant==0);
811
                
812
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
813

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

    
842
            if(interleaved_stats){
843
                s->misc_bits+= get_bits_diff(s);
844
            }
845

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

    
899
            if(interleaved_stats){
900
                s->mv_bits+= get_bits_diff(s);
901
            }
902

    
903
            /* encode each block */
904
            for (i = 0; i < 6; i++) {
905
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
906
            }
907

    
908
            if(interleaved_stats){
909
                s->p_tex_bits+= get_bits_diff(s);
910
            }
911

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

    
923
                    x= s->mb_x*16;
924
                    y= s->mb_y*16;
925
                    if(x+16 > s->width)  x= s->width-16;
926
                    if(y+16 > s->height) y= s->height-16;
927

    
928
                    offset= x + y*s->linesize;
929
                    p_pic= s->new_picture.data[0] + offset;
930
                    
931
                    s->mb_skiped=1;
932
                    for(i=0; i<s->max_b_frames; i++){
933
                        uint8_t *b_pic;
934
                        int diff;
935
                        Picture *pic= s->reordered_input_picture[i+1];
936

    
937
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
938

    
939
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
940
                        diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
941
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
942
                            s->mb_skiped=0;
943
                            break;
944
                        }
945
                    }
946
                }else
947
                    s->mb_skiped=1; 
948

    
949
                if(s->mb_skiped==1){
950
                    /* skip macroblock */
951
                    put_bits(&s->pb, 1, 1);
952

    
953
                    if(interleaved_stats){
954
                        s->misc_bits++;
955
                        s->last_bits++;
956
                    }
957
                    s->skip_count++;
958
                    
959
                    return;
960
                }
961
            }
962

    
963
            put_bits(&s->pb, 1, 0);        /* mb coded */
964
            cbpc = cbp & 3;
965
            cbpy = cbp >> 2;
966
            cbpy ^= 0xf;
967
            if(s->mv_type==MV_TYPE_16X16){
968
                if(s->dquant) cbpc+= 8;
969
                put_bits(&s->pb,
970
                        inter_MCBPC_bits[cbpc],
971
                        inter_MCBPC_code[cbpc]);
972

    
973
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
974
                if(s->dquant)
975
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
976

    
977
                if(!s->progressive_sequence){
978
                    if(cbp)
979
                        put_bits(pb2, 1, s->interlaced_dct);
980
                    put_bits(pb2, 1, 0);
981
                }
982
                    
983
                if(interleaved_stats){
984
                    s->misc_bits+= get_bits_diff(s);
985
                }
986

    
987
                /* motion vectors: 16x16 mode */
988
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
989
            
990
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
991
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
992
            }else if(s->mv_type==MV_TYPE_FIELD){
993
                if(s->dquant) cbpc+= 8;
994
                put_bits(&s->pb,
995
                        inter_MCBPC_bits[cbpc],
996
                        inter_MCBPC_code[cbpc]);
997

    
998
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
999
                if(s->dquant)
1000
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
1001

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

    
1011
                /* motion vectors: 16x8 interlaced mode */
1012
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1013
                pred_y /=2;
1014
                
1015
                put_bits(&s->pb, 1, s->field_select[0][0]);
1016
                put_bits(&s->pb, 1, s->field_select[0][1]);
1017
            
1018
                h263_encode_motion(s, s->mv[0][0][0] - pred_x, s->f_code);
1019
                h263_encode_motion(s, s->mv[0][0][1] - pred_y, s->f_code);
1020
                h263_encode_motion(s, s->mv[0][1][0] - pred_x, s->f_code);
1021
                h263_encode_motion(s, s->mv[0][1][1] - pred_y, s->f_code);
1022
            }else{
1023
                assert(s->mv_type==MV_TYPE_8X8);
1024
                put_bits(&s->pb,
1025
                        inter_MCBPC_bits[cbpc+16],
1026
                        inter_MCBPC_code[cbpc+16]);
1027
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1028

    
1029
                if(!s->progressive_sequence){
1030
                    if(cbp)
1031
                        put_bits(pb2, 1, s->interlaced_dct);
1032
                }
1033
    
1034
                if(interleaved_stats){
1035
                    s->misc_bits+= get_bits_diff(s);
1036
                }
1037

    
1038
                for(i=0; i<4; i++){
1039
                    /* motion vectors: 8x8 mode*/
1040
                    h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1041

    
1042
                    h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, s->f_code);
1043
                    h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1044
                }
1045
            }
1046

    
1047
            if(interleaved_stats){ 
1048
                s->mv_bits+= get_bits_diff(s);
1049
            }
1050

    
1051
            /* encode each block */
1052
            for (i = 0; i < 6; i++) {
1053
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
1054
            }
1055

    
1056
            if(interleaved_stats){
1057
                s->p_tex_bits+= get_bits_diff(s);
1058
            }
1059
            s->f_count++;
1060
        }
1061
    } else {
1062
        int cbp;
1063
        int dc_diff[6];   //dc values with the dc prediction subtracted 
1064
        int dir[6];  //prediction direction
1065
        int zigzag_last_index[6];
1066
        uint8_t *scan_table[6];
1067
        int i;
1068

    
1069
        for(i=0; i<6; i++){
1070
            const int level= block[i][0];
1071
            uint16_t *dc_ptr;
1072

    
1073
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
1074
            if (i < 4) {
1075
                *dc_ptr = level * s->y_dc_scale;
1076
            } else {
1077
                *dc_ptr = level * s->c_dc_scale;
1078
            }
1079
        }
1080

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1628
    if (val == 0) {
1629
        /* zero vector */
1630
        code = 0;
1631
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1632
    } else {
1633
        bit_size = f_code - 1;
1634
        range = 1 << bit_size;
1635
        /* modulo encoding */
1636
        l = range * 32;
1637
#if 1
1638
        val+= l;
1639
        val&= 2*l-1;
1640
        val-= l;
1641
        sign = val>>31;
1642
        val= (val^sign)-sign;
1643
        sign&=1;
1644
#else
1645
        if (val < -l) {
1646
            val += 2*l;
1647
        } else if (val >= l) {
1648
            val -= 2*l;
1649
        }
1650

    
1651
        assert(val>=-l && val<l);
1652

    
1653
        if (val >= 0) {
1654
            sign = 0;
1655
        } else {
1656
            val = -val;
1657
            sign = 1;
1658
        }
1659
#endif
1660
        val--;
1661
        code = (val >> bit_size) + 1;
1662
        bits = val & (range - 1);
1663

    
1664
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1665
        if (bit_size > 0) {
1666
            put_bits(&s->pb, bit_size, bits);
1667
        }
1668
    }
1669

    
1670
}
1671

    
1672
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1673
static void h263p_encode_umotion(MpegEncContext * s, int val)
1674
{
1675
    short sval = 0; 
1676
    short i = 0;
1677
    short n_bits = 0;
1678
    short temp_val;
1679
    int code = 0;
1680
    int tcode;
1681
    
1682
    if ( val == 0)
1683
        put_bits(&s->pb, 1, 1);
1684
    else if (val == 1)
1685
        put_bits(&s->pb, 3, 0);
1686
    else if (val == -1)
1687
        put_bits(&s->pb, 3, 2);
1688
    else {
1689
        
1690
        sval = ((val < 0) ? (short)(-val):(short)val);
1691
        temp_val = sval;
1692
        
1693
        while (temp_val != 0) {
1694
            temp_val = temp_val >> 1;
1695
            n_bits++;
1696
        }
1697
        
1698
        i = n_bits - 1;
1699
        while (i > 0) {
1700
            tcode = (sval & (1 << (i-1))) >> (i-1);
1701
            tcode = (tcode << 1) | 1;
1702
            code = (code << 2) | tcode;
1703
            i--;
1704
        }
1705
        code = ((code << 1) | (val < 0)) << 1;
1706
        put_bits(&s->pb, (2*n_bits)+1, code);
1707
        //printf("\nVal = %d\tCode = %d", sval, code);
1708
    }
1709
}
1710

    
1711
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1712
{
1713
    int f_code;
1714
    int mv;
1715
    
1716
    if(mv_penalty==NULL)
1717
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1718
    
1719
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1720
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1721
            int len;
1722

    
1723
            if(mv==0) len= mvtab[0][1];
1724
            else{
1725
                int val, bit_size, range, code;
1726

    
1727
                bit_size = f_code - 1;
1728
                range = 1 << bit_size;
1729

    
1730
                val=mv;
1731
                if (val < 0) 
1732
                    val = -val;
1733
                val--;
1734
                code = (val >> bit_size) + 1;
1735
                if(code<33){
1736
                    len= mvtab[code][1] + 1 + bit_size;
1737
                }else{
1738
                    len= mvtab[32][1] + 2 + bit_size;
1739
                }
1740
            }
1741

    
1742
            mv_penalty[f_code][mv+MAX_MV]= len;
1743
        }
1744
    }
1745

    
1746
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1747
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1748
            fcode_tab[mv+MAX_MV]= f_code;
1749
        }
1750
    }
1751

    
1752
    for(mv=0; mv<MAX_MV*2+1; mv++){
1753
        umv_fcode_tab[mv]= 1;
1754
    }
1755
}
1756
#endif
1757

    
1758
#ifdef CONFIG_ENCODERS
1759

    
1760
static void init_uni_dc_tab(void)
1761
{
1762
    int level, uni_code, uni_len;
1763

    
1764
    for(level=-256; level<256; level++){
1765
        int size, v, l;
1766
        /* find number of bits */
1767
        size = 0;
1768
        v = abs(level);
1769
        while (v) {
1770
            v >>= 1;
1771
            size++;
1772
        }
1773

    
1774
        if (level < 0)
1775
            l= (-level) ^ ((1 << size) - 1);
1776
        else
1777
            l= level;
1778

    
1779
        /* luminance */
1780
        uni_code= DCtab_lum[size][0];
1781
        uni_len = DCtab_lum[size][1];
1782

    
1783
        if (size > 0) {
1784
            uni_code<<=size; uni_code|=l;
1785
            uni_len+=size;
1786
            if (size > 8){
1787
                uni_code<<=1; uni_code|=1;
1788
                uni_len++;
1789
            }
1790
        }
1791
        uni_DCtab_lum_bits[level+256]= uni_code;
1792
        uni_DCtab_lum_len [level+256]= uni_len;
1793

    
1794
        /* chrominance */
1795
        uni_code= DCtab_chrom[size][0];
1796
        uni_len = DCtab_chrom[size][1];
1797
        
1798
        if (size > 0) {
1799
            uni_code<<=size; uni_code|=l;
1800
            uni_len+=size;
1801
            if (size > 8){
1802
                uni_code<<=1; uni_code|=1;
1803
                uni_len++;
1804
            }
1805
        }
1806
        uni_DCtab_chrom_bits[level+256]= uni_code;
1807
        uni_DCtab_chrom_len [level+256]= uni_len;
1808

    
1809
    }
1810
}
1811

    
1812
#endif //CONFIG_ENCODERS
1813

    
1814
#ifdef CONFIG_ENCODERS
1815
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1816
    int slevel, run, last;
1817
    
1818
    assert(MAX_LEVEL >= 64);
1819
    assert(MAX_RUN   >= 63);
1820

    
1821
    for(slevel=-64; slevel<64; slevel++){
1822
        if(slevel==0) continue;
1823
        for(run=0; run<64; run++){
1824
            for(last=0; last<=1; last++){
1825
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1826
                int level= slevel < 0 ? -slevel : slevel;
1827
                int sign= slevel < 0 ? 1 : 0;
1828
                int bits, len, code;
1829
                int level1, run1;
1830
                
1831
                len_tab[index]= 100;
1832
                     
1833
                /* ESC0 */
1834
                code= get_rl_index(rl, last, run, level);
1835
                bits= rl->table_vlc[code][0];
1836
                len=  rl->table_vlc[code][1];
1837
                bits=bits*2+sign; len++;
1838
                
1839
                if(code!=rl->n && len < len_tab[index]){
1840
                    bits_tab[index]= bits;
1841
                    len_tab [index]= len;
1842
                }
1843
#if 1
1844
                /* ESC1 */
1845
                bits= rl->table_vlc[rl->n][0];
1846
                len=  rl->table_vlc[rl->n][1];
1847
                bits=bits*2;    len++; //esc1
1848
                level1= level - rl->max_level[last][run];
1849
                if(level1>0){
1850
                    code= get_rl_index(rl, last, run, level1);
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
#if 1
1863
                /* ESC2 */
1864
                bits= rl->table_vlc[rl->n][0];
1865
                len=  rl->table_vlc[rl->n][1];
1866
                bits=bits*4+2;    len+=2; //esc2
1867
                run1 = run - rl->max_run[last][level] - 1;
1868
                if(run1>=0){
1869
                    code= get_rl_index(rl, last, run1, level);
1870
                    bits<<= rl->table_vlc[code][1];
1871
                    len  += rl->table_vlc[code][1];
1872
                    bits += rl->table_vlc[code][0];
1873
                    bits=bits*2+sign; len++;
1874
                
1875
                    if(code!=rl->n && len < len_tab[index]){
1876
                        bits_tab[index]= bits;
1877
                        len_tab [index]= len;
1878
                    }
1879
                }
1880
#endif           
1881
                /* ESC3 */        
1882
                bits= rl->table_vlc[rl->n][0];
1883
                len = rl->table_vlc[rl->n][1];
1884
                bits=bits*4+3;    len+=2; //esc3
1885
                bits=bits*2+last; len++;
1886
                bits=bits*64+run; len+=6;
1887
                bits=bits*2+1;    len++;  //marker
1888
                bits=bits*4096+(slevel&0xfff); len+=12;
1889
                bits=bits*2+1;    len++;  //marker
1890
                
1891
                if(len < len_tab[index]){
1892
                    bits_tab[index]= bits;
1893
                    len_tab [index]= len;
1894
                }
1895
            }
1896
        }
1897
    }
1898
}
1899

    
1900
void h263_encode_init(MpegEncContext *s)
1901
{
1902
    static int done = 0;
1903

    
1904
    if (!done) {
1905
        done = 1;
1906

    
1907
        init_uni_dc_tab();
1908

    
1909
        init_rl(&rl_inter);
1910
        init_rl(&rl_intra);
1911
        init_rl(&rl_intra_aic);
1912
        
1913
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1914
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1915

    
1916
        init_mv_penalty_and_fcode(s);
1917
    }
1918
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1919
    
1920
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1921
    switch(s->codec_id){
1922
    case CODEC_ID_MPEG4:
1923
        s->fcode_tab= fcode_tab;
1924
        s->min_qcoeff= -2048;
1925
        s->max_qcoeff=  2047;
1926
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1927
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1928
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1929
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1930
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
1931
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1932
        s->ac_esc_length= 7+2+1+6+1+12+1;
1933
        s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
1934
        s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1935

    
1936
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1937

    
1938
            s->avctx->extradata= av_malloc(1024);
1939
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
1940
            
1941
            mpeg4_encode_visual_object_header(s);
1942
            mpeg4_encode_vol_header(s, 0, 0);
1943

    
1944
//            ff_mpeg4_stuffing(&s->pb); ?
1945
            flush_put_bits(&s->pb);
1946
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
1947
        }
1948
        
1949
        break;
1950
    case CODEC_ID_H263P:
1951
        if(s->umvplus)
1952
            s->fcode_tab= umv_fcode_tab;
1953
        if(s->modified_quant){
1954
            s->min_qcoeff= -2047;
1955
            s->max_qcoeff=  2047;
1956
        }else{
1957
            s->min_qcoeff= -127;
1958
            s->max_qcoeff=  127;
1959
        }
1960
        break;
1961
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1962
    case CODEC_ID_FLV1:
1963
        if (s->h263_flv > 1) {
1964
            s->min_qcoeff= -1023;
1965
            s->max_qcoeff=  1023;
1966
        } else {
1967
            s->min_qcoeff= -127;
1968
            s->max_qcoeff=  127;
1969
        }
1970
        s->y_dc_scale_table=
1971
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1972
        break;
1973
    default: //nothing needed default table allready set in mpegvideo.c
1974
        s->min_qcoeff= -127;
1975
        s->max_qcoeff=  127;
1976
        s->y_dc_scale_table=
1977
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1978
    }
1979
}
1980

    
1981
/**
1982
 * encodes a 8x8 block.
1983
 * @param block the 8x8 block
1984
 * @param n block index (0-3 are luma, 4-5 are chroma)
1985
 */
1986
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1987
{
1988
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1989
    RLTable *rl;
1990

    
1991
    rl = &rl_inter;
1992
    if (s->mb_intra && !s->h263_aic) {
1993
        /* DC coef */
1994
        level = block[0];
1995
        /* 255 cannot be represented, so we clamp */
1996
        if (level > 254) {
1997
            level = 254;
1998
            block[0] = 254;
1999
        }
2000
        /* 0 cannot be represented also */
2001
        else if (level < 1) {
2002
            level = 1;
2003
            block[0] = 1;
2004
        }
2005
        if (level == 128) //FIXME check rv10
2006
            put_bits(&s->pb, 8, 0xff);
2007
        else
2008
            put_bits(&s->pb, 8, level);
2009
        i = 1;
2010
    } else {
2011
        i = 0;
2012
        if (s->h263_aic && s->mb_intra)
2013
            rl = &rl_intra_aic;
2014
            
2015
        if(s->alt_inter_vlc && !s->mb_intra){
2016
            int aic_vlc_bits=0;
2017
            int inter_vlc_bits=0;
2018
            int wrong_pos=-1;
2019
            int aic_code;
2020
            
2021
            last_index = s->block_last_index[n];
2022
            last_non_zero = i - 1;
2023
            for (; i <= last_index; i++) {
2024
                j = s->intra_scantable.permutated[i];
2025
                level = block[j];
2026
                if (level) {
2027
                    run = i - last_non_zero - 1;
2028
                    last = (i == last_index);
2029
                    
2030
                    if(level<0) level= -level;
2031
                
2032
                    code = get_rl_index(rl, last, run, level);
2033
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2034
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2035
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2036

    
2037
                    if (code == rl->n) {
2038
                        inter_vlc_bits += 1+6+8-1;
2039
                    }                
2040
                    if (aic_code == rl_intra_aic.n) {
2041
                        aic_vlc_bits += 1+6+8-1;
2042
                        wrong_pos += run + 1;
2043
                    }else
2044
                        wrong_pos += wrong_run[aic_code];
2045
                    last_non_zero = i;
2046
                }    
2047
            }
2048
            i = 0;
2049
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2050
                rl = &rl_intra_aic;
2051
        }
2052
    }
2053
   
2054
    /* AC coefs */
2055
    last_index = s->block_last_index[n];
2056
    last_non_zero = i - 1;
2057
    for (; i <= last_index; i++) {
2058
        j = s->intra_scantable.permutated[i];
2059
        level = block[j];
2060
        if (level) {
2061
            run = i - last_non_zero - 1;
2062
            last = (i == last_index);
2063
            sign = 0;
2064
            slevel = level;
2065
            if (level < 0) {
2066
                sign = 1;
2067
                level = -level;
2068
            }
2069
            code = get_rl_index(rl, last, run, level);
2070
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2071
            if (code == rl->n) {
2072
              if(s->h263_flv <= 1){
2073
                put_bits(&s->pb, 1, last);
2074
                put_bits(&s->pb, 6, run);
2075
                
2076
                assert(slevel != 0);
2077

    
2078
                if(level < 128) 
2079
                    put_bits(&s->pb, 8, slevel & 0xff);
2080
                else{
2081
                    put_bits(&s->pb, 8, 128);
2082
                    put_bits(&s->pb, 5, slevel & 0x1f);
2083
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2084
                }
2085
              }else{
2086
                if(level < 64) { // 7-bit level
2087
                        put_bits(&s->pb, 1, 0);
2088
                        put_bits(&s->pb, 1, last);
2089
                        put_bits(&s->pb, 6, run);
2090

    
2091
                        put_bits(&s->pb, 7, slevel & 0x7f);
2092
                    } else {
2093
                        /* 11-bit level */
2094
                        put_bits(&s->pb, 1, 1);
2095
                        put_bits(&s->pb, 1, last);
2096
                        put_bits(&s->pb, 6, run);
2097

    
2098
                        put_bits(&s->pb, 11, slevel & 0x7ff);
2099
                    }
2100
              }
2101
            } else {
2102
                put_bits(&s->pb, 1, sign);
2103
            }
2104
            last_non_zero = i;
2105
        }
2106
    }
2107
}
2108
#endif
2109

    
2110
#ifdef CONFIG_ENCODERS
2111

    
2112
/***************************************************/
2113
/**
2114
 * add mpeg4 stuffing bits (01...1)
2115
 */
2116
void ff_mpeg4_stuffing(PutBitContext * pbc)
2117
{
2118
    int length;
2119
    put_bits(pbc, 1, 0);
2120
    length= (-put_bits_count(pbc))&7;
2121
    if(length) put_bits(pbc, length, (1<<length)-1);
2122
}
2123

    
2124
/* must be called before writing the header */
2125
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2126
    int time_div, time_mod;
2127

    
2128
    assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2129
    s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2130

    
2131
    time_div= s->time/s->time_increment_resolution;
2132
    time_mod= s->time%s->time_increment_resolution;
2133

    
2134
    if(s->pict_type==B_TYPE){
2135
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2136
    }else{
2137
        s->last_time_base= s->time_base;
2138
        s->time_base= time_div;
2139
        s->pp_time= s->time - s->last_non_b_time;
2140
        s->last_non_b_time= s->time;
2141
    }
2142
}
2143

    
2144
static void mpeg4_encode_gop_header(MpegEncContext * s){
2145
    int hours, minutes, seconds;
2146
    int64_t time;
2147
    
2148
    put_bits(&s->pb, 16, 0);
2149
    put_bits(&s->pb, 16, GOP_STARTCODE);
2150
    
2151
    time= s->current_picture_ptr->pts;
2152
    if(s->reordered_input_picture[1])
2153
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2154
    time= (time*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2155

    
2156
    seconds= time/s->time_increment_resolution;
2157
    minutes= seconds/60; seconds %= 60;
2158
    hours= minutes/60; minutes %= 60;
2159
    hours%=24;
2160

    
2161
    put_bits(&s->pb, 5, hours);
2162
    put_bits(&s->pb, 6, minutes);
2163
    put_bits(&s->pb, 1, 1);
2164
    put_bits(&s->pb, 6, seconds);
2165
    
2166
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); 
2167
    put_bits(&s->pb, 1, 0); //broken link == NO
2168
    
2169
    s->last_time_base= time / s->time_increment_resolution; 
2170

    
2171
    ff_mpeg4_stuffing(&s->pb);
2172
}
2173

    
2174
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2175
    int profile_and_level_indication;
2176
    int vo_ver_id;
2177
    
2178
    if(s->max_b_frames || s->quarter_sample){
2179
        profile_and_level_indication= 0xF1; // adv simple level 1
2180
        vo_ver_id= 5;
2181
    }else{
2182
        profile_and_level_indication= 0x01; // simple level 1
2183
        vo_ver_id= 1;
2184
    }
2185
    //FIXME levels
2186

    
2187
    put_bits(&s->pb, 16, 0);
2188
    put_bits(&s->pb, 16, VOS_STARTCODE);
2189

    
2190
    put_bits(&s->pb, 8, profile_and_level_indication);
2191

    
2192
    put_bits(&s->pb, 16, 0);
2193
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2194
    
2195
    put_bits(&s->pb, 1, 1);
2196
        put_bits(&s->pb, 4, vo_ver_id);
2197
        put_bits(&s->pb, 3, 1); //priority
2198
 
2199
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
2200
    
2201
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2202

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

    
2206
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2207
{
2208
    int vo_ver_id;
2209

    
2210
    if(s->max_b_frames || s->quarter_sample){
2211
        vo_ver_id= 5;
2212
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2213
    }else{
2214
        vo_ver_id= 1;
2215
        s->vo_type= SIMPLE_VO_TYPE;
2216
    }
2217

    
2218
    put_bits(&s->pb, 16, 0);
2219
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2220
    put_bits(&s->pb, 16, 0);
2221
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2222

    
2223
    put_bits(&s->pb, 1, 0);                /* random access vol */
2224
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
2225
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
2226
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
2227
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
2228
    
2229
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2230

    
2231
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2232
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2233
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2234
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2235
    }
2236

    
2237
    if(s->low_delay){
2238
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
2239
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
2240
        put_bits(&s->pb, 1, s->low_delay);
2241
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
2242
    }else{
2243
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
2244
    }
2245

    
2246
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
2247
    put_bits(&s->pb, 1, 1);                /* marker bit */
2248
    
2249
    put_bits(&s->pb, 16, s->time_increment_resolution);
2250
    if (s->time_increment_bits < 1)
2251
        s->time_increment_bits = 1;
2252
    put_bits(&s->pb, 1, 1);                /* marker bit */
2253
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
2254
    put_bits(&s->pb, 1, 1);                /* marker bit */
2255
    put_bits(&s->pb, 13, s->width);        /* vol width */
2256
    put_bits(&s->pb, 1, 1);                /* marker bit */
2257
    put_bits(&s->pb, 13, s->height);        /* vol height */
2258
    put_bits(&s->pb, 1, 1);                /* marker bit */
2259
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2260
    put_bits(&s->pb, 1, 1);                /* obmc disable */
2261
    if (vo_ver_id == 1) {
2262
        put_bits(&s->pb, 1, s->vol_sprite_usage);                /* sprite enable */
2263
    }else{
2264
        put_bits(&s->pb, 2, s->vol_sprite_usage);                /* sprite enable */
2265
    }
2266
    
2267
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
2268
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
2269

    
2270
    if(s->mpeg_quant){
2271
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2272
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2273
    }
2274

    
2275
    if (vo_ver_id != 1)
2276
        put_bits(&s->pb, 1, s->quarter_sample);
2277
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
2278
    s->resync_marker= s->rtp_mode;
2279
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2280
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2281
    if(s->data_partitioning){
2282
        put_bits(&s->pb, 1, 0);                /* no rvlc */
2283
    }
2284

    
2285
    if (vo_ver_id != 1){
2286
        put_bits(&s->pb, 1, 0);                /* newpred */
2287
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
2288
    }
2289
    put_bits(&s->pb, 1, 0);                /* scalability */
2290
    
2291
    ff_mpeg4_stuffing(&s->pb);
2292

    
2293
    /* user data */
2294
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2295
        put_bits(&s->pb, 16, 0);
2296
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
2297
        put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2298
    }
2299
}
2300

    
2301
/* write mpeg4 VOP header */
2302
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2303
{
2304
    int time_incr;
2305
    int time_div, time_mod;
2306
    
2307
    if(s->pict_type==I_TYPE){
2308
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2309
            if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2310
                mpeg4_encode_visual_object_header(s);
2311
            if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2312
                mpeg4_encode_vol_header(s, 0, 0);
2313
        }
2314
        mpeg4_encode_gop_header(s);
2315
    }
2316
    
2317
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2318

    
2319
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2320
    
2321
    put_bits(&s->pb, 16, 0);                /* vop header */
2322
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2323
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
2324

    
2325
    time_div= s->time/s->time_increment_resolution;
2326
    time_mod= s->time%s->time_increment_resolution;
2327
    time_incr= time_div - s->last_time_base;
2328
    assert(time_incr >= 0);
2329
    while(time_incr--)
2330
        put_bits(&s->pb, 1, 1);
2331
        
2332
    put_bits(&s->pb, 1, 0);
2333

    
2334
    put_bits(&s->pb, 1, 1);        /* marker */
2335
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
2336
    put_bits(&s->pb, 1, 1);        /* marker */
2337
    put_bits(&s->pb, 1, 1);        /* vop coded */
2338
    if (    s->pict_type == P_TYPE 
2339
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2340
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
2341
    }
2342
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
2343
    if(!s->progressive_sequence){
2344
         put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2345
         put_bits(&s->pb, 1, s->alternate_scan);
2346
    }
2347
    //FIXME sprite stuff
2348

    
2349
    put_bits(&s->pb, 5, s->qscale);
2350

    
2351
    if (s->pict_type != I_TYPE)
2352
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
2353
    if (s->pict_type == B_TYPE)
2354
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
2355
    //    printf("****frame %d\n", picture_number);
2356
}
2357

    
2358
#endif //CONFIG_ENCODERS
2359

    
2360
/**
2361
 * set qscale and update qscale dependant variables.
2362
 */
2363
void ff_set_qscale(MpegEncContext * s, int qscale)
2364
{
2365
    if (qscale < 1)
2366
        qscale = 1;
2367
    else if (qscale > 31)
2368
        qscale = 31;
2369
        
2370
    s->qscale = qscale;
2371
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2372

    
2373
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2374
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2375
}
2376

    
2377
/**
2378
 * predicts the dc.
2379
 * @param n block index (0-3 are luma, 4-5 are chroma)
2380
 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
2381
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2382
 * @return the quantized predicted dc
2383
 */
2384
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
2385
{
2386
    int a, b, c, wrap, pred, scale;
2387
    uint16_t *dc_val;
2388

    
2389
    /* find prediction */
2390
    if (n < 4) {
2391
        scale = s->y_dc_scale;
2392
    } else {
2393
        scale = s->c_dc_scale;
2394
    }
2395
    if(IS_3IV1)
2396
        scale= 8;
2397

    
2398
    wrap= s->block_wrap[n];
2399
    dc_val = s->dc_val[0] + s->block_index[n];
2400

    
2401
    /* B C
2402
     * A X 
2403
     */
2404
    a = dc_val[ - 1];
2405
    b = dc_val[ - 1 - wrap];
2406
    c = dc_val[ - wrap];
2407

    
2408
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2409
    if(s->first_slice_line && n!=3){
2410
        if(n!=2) b=c= 1024;
2411
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2412
    }
2413
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2414
        if(n==0 || n==4 || n==5)
2415
            b=1024;
2416
    }
2417

    
2418
    if (abs(a - b) < abs(b - c)) {
2419
        pred = c;
2420
        *dir_ptr = 1; /* top */
2421
    } else {
2422
        pred = a;
2423
        *dir_ptr = 0; /* left */
2424
    }
2425
    /* we assume pred is positive */
2426
    pred = FASTDIV((pred + (scale >> 1)), scale);
2427

    
2428
    /* prepare address for prediction update */
2429
    *dc_val_ptr = &dc_val[0];
2430

    
2431
    return pred;
2432
}
2433

    
2434
/**
2435
 * predicts the ac.
2436
 * @param n block index (0-3 are luma, 4-5 are chroma)
2437
 * @param dir the ac prediction direction
2438
 */
2439
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2440
                   int dir)
2441
{
2442
    int i;
2443
    int16_t *ac_val, *ac_val1;
2444
    int8_t * const qscale_table= s->current_picture.qscale_table;
2445

    
2446
    /* find prediction */
2447
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2448
    ac_val1 = ac_val;
2449
    if (s->ac_pred) {
2450
        if (dir == 0) {
2451
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2452
            /* left prediction */
2453
            ac_val -= 16;
2454
            
2455
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2456
                /* same qscale */
2457
                for(i=1;i<8;i++) {
2458
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2459
                }
2460
            }else{
2461
                /* different qscale, we must rescale */
2462
                for(i=1;i<8;i++) {
2463
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2464
                }
2465
            }
2466
        } else {
2467
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2468
            /* top prediction */
2469
            ac_val -= 16 * s->block_wrap[n];
2470

    
2471
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2472
                /* same qscale */
2473
                for(i=1;i<8;i++) {
2474
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2475
                }
2476
            }else{
2477
                /* different qscale, we must rescale */
2478
                for(i=1;i<8;i++) {
2479
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2480
                }
2481
            }
2482
        }
2483
    }
2484
    /* left copy */
2485
    for(i=1;i<8;i++)
2486
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2487

    
2488
    /* top copy */
2489
    for(i=1;i<8;i++)
2490
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2491

    
2492
}
2493

    
2494
#ifdef CONFIG_ENCODERS
2495

    
2496
/**
2497
 * encodes the dc value.
2498
 * @param n block index (0-3 are luma, 4-5 are chroma)
2499
 */
2500
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2501
{
2502
#if 1
2503
//    if(level<-255 || level>255) printf("dc overflow\n");
2504
    level+=256;
2505
    if (n < 4) {
2506
        /* luminance */
2507
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2508
    } else {
2509
        /* chrominance */
2510
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2511
    }
2512
#else
2513
    int size, v;
2514
    /* find number of bits */
2515
    size = 0;
2516
    v = abs(level);
2517
    while (v) {
2518
        v >>= 1;
2519
        size++;
2520
    }
2521

    
2522
    if (n < 4) {
2523
        /* luminance */
2524
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2525
    } else {
2526
        /* chrominance */
2527
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2528
    }
2529

    
2530
    /* encode remaining bits */
2531
    if (size > 0) {
2532
        if (level < 0)
2533
            level = (-level) ^ ((1 << size) - 1);
2534
        put_bits(&s->pb, size, level);
2535
        if (size > 8)
2536
            put_bits(&s->pb, 1, 1);
2537
    }
2538
#endif
2539
}
2540

    
2541
/**
2542
 * encodes a 8x8 block
2543
 * @param n block index (0-3 are luma, 4-5 are chroma)
2544
 */
2545
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2546
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2547
{
2548
    int i, last_non_zero;
2549
#if 0 //variables for the outcommented version
2550
    int code, sign, last;
2551
#endif
2552
    const RLTable *rl;
2553
    uint32_t *bits_tab;
2554
    uint8_t *len_tab;
2555
    const int last_index = s->block_last_index[n];
2556

    
2557
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2558
        /* mpeg4 based DC predictor */
2559
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2560
        if(last_index<1) return;
2561
        i = 1;
2562
        rl = &rl_intra;
2563
        bits_tab= uni_mpeg4_intra_rl_bits;
2564
        len_tab = uni_mpeg4_intra_rl_len;
2565
    } else {
2566
        if(last_index<0) return;
2567
        i = 0;
2568
        rl = &rl_inter;
2569
        bits_tab= uni_mpeg4_inter_rl_bits;
2570
        len_tab = uni_mpeg4_inter_rl_len;
2571
    }
2572

    
2573
    /* AC coefs */
2574
    last_non_zero = i - 1;
2575
#if 1
2576
    for (; i < last_index; i++) {
2577
        int level = block[ scan_table[i] ];
2578
        if (level) {
2579
            int run = i - last_non_zero - 1;
2580
            level+=64;
2581
            if((level&(~127)) == 0){
2582
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2583
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2584
            }else{ //ESC3
2585
                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);
2586
            }
2587
            last_non_zero = i;
2588
        }
2589
    }
2590
    /*if(i<=last_index)*/{
2591
        int level = block[ scan_table[i] ];
2592
        int run = i - last_non_zero - 1;
2593
        level+=64;
2594
        if((level&(~127)) == 0){
2595
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2596
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2597
        }else{ //ESC3
2598
            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);
2599
        }
2600
    }
2601
#else
2602
    for (; i <= last_index; i++) {
2603
        const int slevel = block[ scan_table[i] ];
2604
        if (slevel) {
2605
            int level;
2606
            int run = i - last_non_zero - 1;
2607
            last = (i == last_index);
2608
            sign = 0;
2609
            level = slevel;
2610
            if (level < 0) {
2611
                sign = 1;
2612
                level = -level;
2613
            }
2614
            code = get_rl_index(rl, last, run, level);
2615
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2616
            if (code == rl->n) {
2617
                int level1, run1;
2618
                level1 = level - rl->max_level[last][run];
2619
                if (level1 < 1) 
2620
                    goto esc2;
2621
                code = get_rl_index(rl, last, run, level1);
2622
                if (code == rl->n) {
2623
                esc2:
2624
                    put_bits(ac_pb, 1, 1);
2625
                    if (level > MAX_LEVEL)
2626
                        goto esc3;
2627
                    run1 = run - rl->max_run[last][level] - 1;
2628
                    if (run1 < 0)
2629
                        goto esc3;
2630
                    code = get_rl_index(rl, last, run1, level);
2631
                    if (code == rl->n) {
2632
                    esc3:
2633
                        /* third escape */
2634
                        put_bits(ac_pb, 1, 1);
2635
                        put_bits(ac_pb, 1, last);
2636
                        put_bits(ac_pb, 6, run);
2637
                        put_bits(ac_pb, 1, 1);
2638
                        put_bits(ac_pb, 12, slevel & 0xfff);
2639
                        put_bits(ac_pb, 1, 1);
2640
                    } else {
2641
                        /* second escape */
2642
                        put_bits(ac_pb, 1, 0);
2643
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2644
                        put_bits(ac_pb, 1, sign);
2645
                    }
2646
                } else {
2647
                    /* first escape */
2648
                    put_bits(ac_pb, 1, 0);
2649
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2650
                    put_bits(ac_pb, 1, sign);
2651
                }
2652
            } else {
2653
                put_bits(ac_pb, 1, sign);
2654
            }
2655
            last_non_zero = i;
2656
        }
2657
    }
2658
#endif
2659
}
2660

    
2661
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2662
                               uint8_t *scan_table)
2663
{
2664
    int i, last_non_zero;
2665
    const RLTable *rl;
2666
    uint8_t *len_tab;
2667
    const int last_index = s->block_last_index[n];
2668
    int len=0;
2669

    
2670
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2671
        /* mpeg4 based DC predictor */
2672
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2673
        if(last_index<1) return len;
2674
        i = 1;
2675
        rl = &rl_intra;
2676
        len_tab = uni_mpeg4_intra_rl_len;
2677
    } else {
2678
        if(last_index<0) return 0;
2679
        i = 0;
2680
        rl = &rl_inter;
2681
        len_tab = uni_mpeg4_inter_rl_len;
2682
    }
2683

    
2684
    /* AC coefs */
2685
    last_non_zero = i - 1;
2686
    for (; i < last_index; i++) {
2687
        int level = block[ scan_table[i] ];
2688
        if (level) {
2689
            int run = i - last_non_zero - 1;
2690
            level+=64;
2691
            if((level&(~127)) == 0){
2692
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2693
                len += len_tab[index];
2694
            }else{ //ESC3
2695
                len += 7+2+1+6+1+12+1;
2696
            }
2697
            last_non_zero = i;
2698
        }
2699
    }
2700
    /*if(i<=last_index)*/{
2701
        int level = block[ scan_table[i] ];
2702
        int run = i - last_non_zero - 1;
2703
        level+=64;
2704
        if((level&(~127)) == 0){
2705
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2706
            len += len_tab[index];
2707
        }else{ //ESC3
2708
            len += 7+2+1+6+1+12+1;
2709
        }
2710
    }
2711
    
2712
    return len;
2713
}
2714

    
2715
#endif
2716

    
2717

    
2718
/***********************************************/
2719
/* decoding */
2720

    
2721
static VLC intra_MCBPC_vlc;
2722
static VLC inter_MCBPC_vlc;
2723
static VLC cbpy_vlc;
2724
static VLC mv_vlc;
2725
static VLC dc_lum, dc_chrom;
2726
static VLC sprite_trajectory;
2727
static VLC mb_type_b_vlc;
2728
static VLC h263_mbtype_b_vlc;
2729
static VLC cbpc_b_vlc;
2730

    
2731
void init_vlc_rl(RLTable *rl)
2732
{
2733
    int i, q;
2734
    
2735
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2736
             &rl->table_vlc[0][1], 4, 2,
2737
             &rl->table_vlc[0][0], 4, 2);
2738

    
2739
    
2740
    for(q=0; q<32; q++){
2741
        int qmul= q*2;
2742
        int qadd= (q-1)|1;
2743
        
2744
        if(q==0){
2745
            qmul=1;
2746
            qadd=0;
2747
        }
2748
        
2749
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2750
        for(i=0; i<rl->vlc.table_size; i++){
2751
            int code= rl->vlc.table[i][0];
2752
            int len = rl->vlc.table[i][1];
2753
            int level, run;
2754
        
2755
            if(len==0){ // illegal code
2756
                run= 66;
2757
                level= MAX_LEVEL;
2758
            }else if(len<0){ //more bits needed
2759
                run= 0;
2760
                level= code;
2761
            }else{
2762
                if(code==rl->n){ //esc
2763
                    run= 66;
2764
                    level= 0;
2765
                }else{
2766
                    run=   rl->table_run  [code] + 1;
2767
                    level= rl->table_level[code] * qmul + qadd;
2768
                    if(code >= rl->last) run+=192;
2769
                }
2770
            }
2771
            rl->rl_vlc[q][i].len= len;
2772
            rl->rl_vlc[q][i].level= level;
2773
            rl->rl_vlc[q][i].run= run;
2774
        }
2775
    }
2776
}
2777

    
2778
/* init vlcs */
2779

    
2780
/* XXX: find a better solution to handle static init */
2781
void h263_decode_init_vlc(MpegEncContext *s)
2782
{
2783
    static int done = 0;
2784

    
2785
    if (!done) {
2786
        done = 1;
2787

    
2788
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, 
2789
                 intra_MCBPC_bits, 1, 1,
2790
                 intra_MCBPC_code, 1, 1);
2791
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, 
2792
                 inter_MCBPC_bits, 1, 1,
2793
                 inter_MCBPC_code, 1, 1);
2794
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2795
                 &cbpy_tab[0][1], 2, 1,
2796
                 &cbpy_tab[0][0], 2, 1);
2797
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2798
                 &mvtab[0][1], 2, 1,
2799
                 &mvtab[0][0], 2, 1);
2800
        init_rl(&rl_inter);
2801
        init_rl(&rl_intra);
2802
        init_rl(&rvlc_rl_inter);
2803
        init_rl(&rvlc_rl_intra);
2804
        init_rl(&rl_intra_aic);
2805
        init_vlc_rl(&rl_inter);
2806
        init_vlc_rl(&rl_intra);
2807
        init_vlc_rl(&rvlc_rl_inter);
2808
        init_vlc_rl(&rvlc_rl_intra);
2809
        init_vlc_rl(&rl_intra_aic);
2810
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2811
                 &DCtab_lum[0][1], 2, 1,
2812
                 &DCtab_lum[0][0], 2, 1);
2813
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2814
                 &DCtab_chrom[0][1], 2, 1,
2815
                 &DCtab_chrom[0][0], 2, 1);
2816
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2817
                 &sprite_trajectory_tab[0][1], 4, 2,
2818
                 &sprite_trajectory_tab[0][0], 4, 2);
2819
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2820
                 &mb_type_b_tab[0][1], 2, 1,
2821
                 &mb_type_b_tab[0][0], 2, 1);
2822
        init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2823
                 &h263_mbtype_b_tab[0][1], 2, 1,
2824
                 &h263_mbtype_b_tab[0][0], 2, 1);
2825
        init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2826
                 &cbpc_b_tab[0][1], 2, 1,
2827
                 &cbpc_b_tab[0][0], 2, 1);
2828
    }
2829
}
2830

    
2831
/**
2832
 * Get the GOB height based on picture height.
2833
 */
2834
int ff_h263_get_gob_height(MpegEncContext *s){
2835
    if (s->height <= 400)
2836
        return 1;
2837
    else if (s->height <= 800)
2838
        return  2;
2839
    else
2840
        return 4;
2841
}
2842

    
2843
int ff_h263_decode_mba(MpegEncContext *s)
2844
{
2845
    int i, mb_pos;
2846

    
2847
    for(i=0; i<6; i++){
2848
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2849
    }
2850
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2851
    s->mb_x= mb_pos % s->mb_width;
2852
    s->mb_y= mb_pos / s->mb_width;
2853

    
2854
    return mb_pos;
2855
}
2856

    
2857
void ff_h263_encode_mba(MpegEncContext *s)
2858
{
2859
    int i, mb_pos;
2860

    
2861
    for(i=0; i<6; i++){
2862
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2863
    }
2864
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
2865
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
2866
}
2867

    
2868
/**
2869
 * decodes the group of blocks header or slice header.
2870
 * @return <0 if an error occured
2871
 */
2872
static int h263_decode_gob_header(MpegEncContext *s)
2873
{
2874
    unsigned int val, gfid, gob_number;
2875
    int left;
2876
    
2877
    /* Check for GOB Start Code */
2878
    val = show_bits(&s->gb, 16);
2879
    if(val)
2880
        return -1;
2881

    
2882
        /* We have a GBSC probably with GSTUFF */
2883
    skip_bits(&s->gb, 16); /* Drop the zeros */
2884
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2885
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2886
    for(;left>13; left--){
2887
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2888
    }
2889
    if(left<=13) 
2890
        return -1;
2891

    
2892
    if(s->h263_slice_structured){
2893
        if(get_bits1(&s->gb)==0)
2894
            return -1;
2895

    
2896
        ff_h263_decode_mba(s);
2897

    
2898
        if(s->mb_num > 1583)
2899
            if(get_bits1(&s->gb)==0)
2900
                return -1;
2901
        
2902
        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
2903
        if(get_bits1(&s->gb)==0)
2904
            return -1;
2905
        gfid = get_bits(&s->gb, 2); /* GFID */
2906
    }else{
2907
        gob_number = get_bits(&s->gb, 5); /* GN */
2908
        s->mb_x= 0;
2909
        s->mb_y= s->gob_index* gob_number;
2910
        gfid = get_bits(&s->gb, 2); /* GFID */
2911
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2912
    }
2913
        
2914
    if(s->mb_y >= s->mb_height) 
2915
        return -1;
2916

    
2917
    if(s->qscale==0) 
2918
        return -1;
2919

    
2920
    return 0;
2921
}
2922

    
2923
static inline void memsetw(short *tab, int val, int n)
2924
{
2925
    int i;
2926
    for(i=0;i<n;i++)
2927
        tab[i] = val;
2928
}
2929

    
2930
#ifdef CONFIG_ENCODERS
2931

    
2932
void ff_mpeg4_init_partitions(MpegEncContext *s)
2933
{
2934
    uint8_t *start= pbBufPtr(&s->pb);
2935
    uint8_t *end= s->pb.buf_end;
2936
    int size= end - start;
2937
    int pb_size = (((int)start + size/3)&(~3)) - (int)start;
2938
    int tex_size= (size - 2*pb_size)&(~3);
2939
    
2940
    set_put_bits_buffer_size(&s->pb, pb_size);
2941
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
2942
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
2943
}
2944

    
2945
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2946
{
2947
    const int pb2_len   = put_bits_count(&s->pb2   );
2948
    const int tex_pb_len= put_bits_count(&s->tex_pb);
2949
    const int bits= put_bits_count(&s->pb);
2950

    
2951
    if(s->pict_type==I_TYPE){
2952
        put_bits(&s->pb, 19, DC_MARKER);
2953
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2954
        s->i_tex_bits+= tex_pb_len;
2955
    }else{
2956
        put_bits(&s->pb, 17, MOTION_MARKER);
2957
        s->misc_bits+=17 + pb2_len;
2958
        s->mv_bits+= bits - s->last_bits;
2959
        s->p_tex_bits+= tex_pb_len;
2960
    }
2961

    
2962
    flush_put_bits(&s->pb2);
2963
    flush_put_bits(&s->tex_pb);
2964

    
2965
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
2966
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
2967
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
2968
    s->last_bits= put_bits_count(&s->pb);
2969
}
2970

    
2971
#endif //CONFIG_ENCODERS
2972

    
2973
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2974
    switch(s->pict_type){
2975
        case I_TYPE:
2976
            return 16;
2977
        case P_TYPE:
2978
        case S_TYPE:
2979
            return s->f_code+15;
2980
        case B_TYPE:
2981
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2982
        default:
2983
            return -1;
2984
    }
2985
}
2986

    
2987
#ifdef CONFIG_ENCODERS
2988

    
2989
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2990
{
2991
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2992

    
2993
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2994
    put_bits(&s->pb, 1, 1);
2995
    
2996
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2997
    put_bits(&s->pb, s->quant_precision, s->qscale);
2998
    put_bits(&s->pb, 1, 0); /* no HEC */
2999
}
3000

    
3001
#endif //CONFIG_ENCODERS
3002

    
3003
/**
3004
 * check if the next stuff is a resync marker or the end.
3005
 * @return 0 if not
3006
 */
3007
static inline int mpeg4_is_resync(MpegEncContext *s){
3008
    const int bits_count= get_bits_count(&s->gb);
3009
    
3010
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3011
        return 0;
3012
    }
3013

    
3014
    if(bits_count + 8 >= s->gb.size_in_bits){
3015
        int v= show_bits(&s->gb, 8);
3016
        v|= 0x7F >> (7-(bits_count&7));
3017
                
3018
        if(v==0x7F)
3019
            return 1;
3020
    }else{
3021
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3022
            int len;
3023
            GetBitContext gb= s->gb;
3024
        
3025
            skip_bits(&s->gb, 1);
3026
            align_get_bits(&s->gb);
3027
        
3028
            for(len=0; len<32; len++){
3029
                if(get_bits1(&s->gb)) break;
3030
            }
3031

    
3032
            s->gb= gb;
3033

    
3034
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3035
                return 1;
3036
        }
3037
    }
3038
    return 0;
3039
}
3040

    
3041
/**
3042
 * decodes the next video packet.
3043
 * @return <0 if something went wrong
3044
 */
3045
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3046
{
3047
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3048
    int header_extension=0, mb_num, len;
3049
    
3050
    /* is there enough space left for a video packet + header */
3051
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3052

    
3053
    for(len=0; len<32; len++){
3054
        if(get_bits1(&s->gb)) break;
3055
    }
3056

    
3057
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3058
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3059
        return -1;
3060
    }
3061
    
3062
    if(s->shape != RECT_SHAPE){
3063
        header_extension= get_bits1(&s->gb);
3064
        //FIXME more stuff here
3065
    }
3066

    
3067
    mb_num= get_bits(&s->gb, mb_num_bits);
3068
    if(mb_num>=s->mb_num){
3069
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3070
        return -1;
3071
    }
3072
    if(s->pict_type == B_TYPE){
3073
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3074
        if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
3075
    }
3076
    
3077
    s->mb_x= mb_num % s->mb_width;
3078
    s->mb_y= mb_num / s->mb_width;
3079

    
3080
    if(s->shape != BIN_ONLY_SHAPE){
3081
        int qscale= get_bits(&s->gb, s->quant_precision); 
3082
        if(qscale)
3083
            s->chroma_qscale=s->qscale= qscale;
3084
    }
3085

    
3086
    if(s->shape == RECT_SHAPE){
3087
        header_extension= get_bits1(&s->gb);
3088
    }
3089
    if(header_extension){
3090
        int time_increment;
3091
        int time_incr=0;
3092

    
3093
        while (get_bits1(&s->gb) != 0) 
3094
            time_incr++;
3095

    
3096
        check_marker(&s->gb, "before time_increment in video packed header");
3097
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3098
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3099
        
3100
        skip_bits(&s->gb, 2); /* vop coding type */
3101
        //FIXME not rect stuff here
3102

    
3103
        if(s->shape != BIN_ONLY_SHAPE){
3104
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3105
//FIXME dont just ignore everything
3106
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3107
                mpeg4_decode_sprite_trajectory(s, &s->gb);
3108
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3109
            }
3110

    
3111
            //FIXME reduced res stuff here
3112
            
3113
            if (s->pict_type != I_TYPE) {
3114
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
3115
                if(f_code==0){
3116
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3117
                }
3118
            }
3119
            if (s->pict_type == B_TYPE) {
3120
                int b_code = get_bits(&s->gb, 3);
3121
                if(b_code==0){
3122
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3123
                }
3124
            }       
3125
        }
3126
    }
3127
    //FIXME new-pred stuff
3128
    
3129
//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));
3130

    
3131
    return 0;
3132
}
3133

    
3134
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3135
{
3136
    int c_wrap, c_xy, l_wrap, l_xy;
3137

    
3138
    l_wrap= s->b8_stride;
3139
    l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3140
    c_wrap= s->mb_stride;
3141
    c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3142

    
3143
#if 0
3144
    /* clean DC */
3145
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3146
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3147
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3148
#endif
3149

    
3150
    /* clean AC */
3151
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3152
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3153
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3154

    
3155
    /* clean MV */
3156
    // we cant clear the MVs as they might be needed by a b frame
3157
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3158
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3159
    s->last_mv[0][0][0]=
3160
    s->last_mv[0][0][1]=
3161
    s->last_mv[1][0][0]=
3162
    s->last_mv[1][0][1]= 0;
3163
}
3164

    
3165
/**
3166
 * decodes the group of blocks / video packet header.
3167
 * @return <0 if no resync found
3168
 */
3169
int ff_h263_resync(MpegEncContext *s){
3170
    int left, ret;
3171
    
3172
    if(s->codec_id==CODEC_ID_MPEG4){
3173
        skip_bits1(&s->gb);
3174
        align_get_bits(&s->gb);
3175
    }
3176

    
3177
    if(show_bits(&s->gb, 16)==0){
3178
        if(s->codec_id==CODEC_ID_MPEG4)
3179
            ret= mpeg4_decode_video_packet_header(s);
3180
        else
3181
            ret= h263_decode_gob_header(s);
3182
        if(ret>=0)
3183
            return 0;
3184
    }
3185
    //ok, its not where its supposed to be ...
3186
    s->gb= s->last_resync_gb;
3187
    align_get_bits(&s->gb);
3188
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3189
    
3190
    for(;left>16+1+5+5; left-=8){ 
3191
        if(show_bits(&s->gb, 16)==0){
3192
            GetBitContext bak= s->gb;
3193

    
3194
            if(s->codec_id==CODEC_ID_MPEG4)
3195
                ret= mpeg4_decode_video_packet_header(s);
3196
            else
3197
                ret= h263_decode_gob_header(s);
3198
            if(ret>=0)
3199
                return 0;
3200

    
3201
            s->gb= bak;
3202
        }
3203
        skip_bits(&s->gb, 8);
3204
    }
3205
    
3206
    return -1;
3207
}
3208

    
3209
/**
3210
 * gets the average motion vector for a GMC MB.
3211
 * @param n either 0 for the x component or 1 for y
3212
 * @returns the average MV for a GMC MB
3213
 */
3214
static inline int get_amv(MpegEncContext *s, int n){
3215
    int x, y, mb_v, sum, dx, dy, shift;
3216
    int len = 1 << (s->f_code + 4);
3217
    const int a= s->sprite_warping_accuracy;
3218

    
3219
    if(s->real_sprite_warping_points==1){
3220
        if(s->divx_version==500 && s->divx_build==413)
3221
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3222
        else
3223
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3224
    }else{
3225
        dx= s->sprite_delta[n][0];
3226
        dy= s->sprite_delta[n][1];
3227
        shift= s->sprite_shift[0];
3228
        if(n) dy -= 1<<(shift + a + 1);
3229
        else  dx -= 1<<(shift + a + 1);
3230
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3231

    
3232
        sum=0;
3233
        for(y=0; y<16; y++){
3234
            int v;
3235
        
3236
            v= mb_v + dy*y;
3237
            //XXX FIXME optimize
3238
            for(x=0; x<16; x++){
3239
                sum+= v>>shift;
3240
                v+= dx;
3241
            }
3242
        }
3243
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3244
    }
3245

    
3246
    if      (sum < -len) sum= -len;
3247
    else if (sum >= len) sum= len-1;
3248

    
3249
    return sum;
3250
}
3251

    
3252
/**
3253
 * decodes first partition.
3254
 * @return number of MBs decoded or <0 if an error occured
3255
 */
3256
static int mpeg4_decode_partition_a(MpegEncContext *s){
3257
    int mb_num;
3258
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3259
    
3260
    /* decode first partition */
3261
    mb_num=0;
3262
    s->first_slice_line=1;
3263
    for(; s->mb_y<s->mb_height; s->mb_y++){
3264
        ff_init_block_index(s);
3265
        for(; s->mb_x<s->mb_width; s->mb_x++){
3266
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3267
            int cbpc;
3268
            int dir=0;
3269
            
3270
            mb_num++;
3271
            ff_update_block_index(s);
3272
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3273
                s->first_slice_line=0;
3274
            
3275
            if(s->pict_type==I_TYPE){
3276
                int i;
3277

    
3278
                do{
3279
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
3280
                        return mb_num-1;
3281
                    }
3282

    
3283
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3284
                    if (cbpc < 0){
3285
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3286
                        return -1;
3287
                    }
3288
                }while(cbpc == 8);
3289
                
3290
                s->cbp_table[xy]= cbpc & 3;
3291
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3292
                s->mb_intra = 1;
3293

    
3294
                if(cbpc & 4) {
3295
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3296
                }
3297
                s->current_picture.qscale_table[xy]= s->qscale;
3298

    
3299
                s->mbintra_table[xy]= 1;
3300
                for(i=0; i<6; i++){
3301
                    int dc_pred_dir;
3302
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3303
                    if(dc < 0){
3304
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3305
                        return -1;
3306
                    }
3307
                    dir<<=1;
3308
                    if(dc_pred_dir) dir|=1;
3309
                }
3310
                s->pred_dir_table[xy]= dir;
3311
            }else{ /* P/S_TYPE */
3312
                int mx, my, pred_x, pred_y, bits;
3313
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3314
                const int stride= s->b8_stride*2;
3315

    
3316
try_again:
3317
                bits= show_bits(&s->gb, 17);
3318
                if(bits==MOTION_MARKER){
3319
                    return mb_num-1;
3320
                }
3321
                skip_bits1(&s->gb);
3322
                if(bits&0x10000){
3323
                    /* skip mb */
3324
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3325
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3326
                        mx= get_amv(s, 0);
3327
                        my= get_amv(s, 1);
3328
                    }else{
3329
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3330
                        mx=my=0;
3331
                    }
3332
                    mot_val[0       ]= mot_val[2       ]=
3333
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3334
                    mot_val[1       ]= mot_val[3       ]=
3335
                    mot_val[1+stride]= mot_val[3+stride]= my;
3336

    
3337
                    if(s->mbintra_table[xy])
3338
                        ff_clean_intra_table_entries(s);
3339
                    continue;
3340
                }
3341

    
3342
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3343
                if (cbpc < 0){
3344
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3345
                    return -1;
3346
                }
3347
                if(cbpc == 20)
3348
                    goto try_again;
3349

    
3350
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3351
    
3352
                s->mb_intra = ((cbpc & 4) != 0);
3353
        
3354
                if(s->mb_intra){
3355
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3356
                    s->mbintra_table[xy]= 1;
3357
                    mot_val[0       ]= mot_val[2       ]= 
3358
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3359
                    mot_val[1       ]= mot_val[3       ]=
3360
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3361
                }else{
3362
                    if(s->mbintra_table[xy])
3363
                        ff_clean_intra_table_entries(s);
3364

    
3365
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3366
                        s->mcsel= get_bits1(&s->gb);
3367
                    else s->mcsel= 0;
3368
        
3369
                    if ((cbpc & 16) == 0) {
3370
                        /* 16x16 motion prediction */
3371

    
3372
                        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3373
                        if(!s->mcsel){
3374
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3375
                            if (mx >= 0xffff)
3376
                                return -1;
3377

    
3378
                            my = h263_decode_motion(s, pred_y, s->f_code);
3379
                            if (my >= 0xffff)
3380
                                return -1;
3381
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3382
                        } else {
3383
                            mx = get_amv(s, 0);
3384
                            my = get_amv(s, 1);
3385
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3386
                        }
3387

    
3388
                        mot_val[0       ]= mot_val[2       ] =
3389
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3390
                        mot_val[1       ]= mot_val[3       ]=
3391
                        mot_val[1+stride]= mot_val[3+stride]= my;
3392
                    } else {
3393
                        int i;
3394
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3395
                        for(i=0;i<4;i++) {
3396
                            int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3397
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3398
                            if (mx >= 0xffff)
3399
                                return -1;
3400
                
3401
                            my = h263_decode_motion(s, pred_y, s->f_code);
3402
                            if (my >= 0xffff)
3403
                                return -1;
3404
                            mot_val[0] = mx;
3405
                            mot_val[1] = my;
3406
                        }
3407
                    }
3408
                }
3409
            }
3410
        }
3411
        s->mb_x= 0;
3412
    }
3413

    
3414
    return mb_num;
3415
}
3416

    
3417
/**
3418
 * decode second partition.
3419
 * @return <0 if an error occured
3420
 */
3421
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3422
    int mb_num=0;
3423
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3424

    
3425
    s->mb_x= s->resync_mb_x;
3426
    s->first_slice_line=1;
3427
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3428
        ff_init_block_index(s);
3429
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3430
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3431

    
3432
            mb_num++;
3433
            ff_update_block_index(s);
3434
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3435
                s->first_slice_line=0;
3436
            
3437
            if(s->pict_type==I_TYPE){
3438
                int ac_pred= get_bits1(&s->gb);
3439
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3440
                if(cbpy<0){
3441
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3442
                    return -1;
3443
                }
3444
                
3445
                s->cbp_table[xy]|= cbpy<<2;
3446
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3447
            }else{ /* P || S_TYPE */
3448
                if(IS_INTRA(s->current_picture.mb_type[xy])){          
3449
                    int dir=0,i;
3450
                    int ac_pred = get_bits1(&s->gb);
3451
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3452

    
3453
                    if(cbpy<0){
3454
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3455
                        return -1;
3456
                    }
3457
                    
3458
                    if(s->cbp_table[xy] & 8) {
3459
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3460
                    }
3461
                    s->current_picture.qscale_table[xy]= s->qscale;
3462

    
3463
                    for(i=0; i<6; i++){
3464
                        int dc_pred_dir;
3465
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3466
                        if(dc < 0){
3467
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3468
                            return -1;
3469
                        }
3470
                        dir<<=1;
3471
                        if(dc_pred_dir) dir|=1;
3472
                    }
3473
                    s->cbp_table[xy]&= 3; //remove dquant
3474
                    s->cbp_table[xy]|= cbpy<<2;
3475
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3476
                    s->pred_dir_table[xy]= dir;
3477
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3478
                    s->current_picture.qscale_table[xy]= s->qscale;
3479
                    s->cbp_table[xy]= 0;
3480
                }else{
3481
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3482

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

    
3493
                    s->cbp_table[xy]&= 3; //remove dquant
3494
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3495
                }
3496
            }
3497
        }
3498
        if(mb_num >= mb_count) return 0;
3499
        s->mb_x= 0;
3500
    }
3501
    return 0;
3502
}
3503

    
3504
/**
3505
 * decodes the first & second partition
3506
 * @return <0 if error (and sets error type in the error_status_table)
3507
 */
3508
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3509
{
3510
    int mb_num;
3511
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3512
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3513
    
3514
    mb_num= mpeg4_decode_partition_a(s);    
3515
    if(mb_num<0){
3516
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3517
        return -1;
3518
    }
3519
    
3520
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3521
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3522
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3523
        return -1;
3524
    }
3525

    
3526
    s->mb_num_left= mb_num;
3527
        
3528
    if(s->pict_type==I_TYPE){
3529
        while(show_bits(&s->gb, 9) == 1)
3530
            skip_bits(&s->gb, 9);
3531
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3532
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3533
            return -1;
3534
        }
3535
    }else{
3536
        while(show_bits(&s->gb, 10) == 1)
3537
            skip_bits(&s->gb, 10);
3538
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3539
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3540
            return -1;
3541
        }
3542
    }
3543
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3544
    
3545
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3546
        if(s->pict_type==P_TYPE)
3547
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3548
        return -1;
3549
    }else{
3550
        if(s->pict_type==P_TYPE)
3551
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3552
    }
3553

    
3554
    return 0;        
3555
}
3556

    
3557
/**
3558
 * decode partition C of one MB.
3559
 * @return <0 if an error occured
3560
 */
3561
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3562
{
3563
    int cbp, mb_type;
3564
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3565

    
3566
    mb_type= s->current_picture.mb_type[xy];
3567
    cbp = s->cbp_table[xy];
3568

    
3569
    if(s->current_picture.qscale_table[xy] != s->qscale){
3570
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3571
    }
3572
    
3573
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3574
        int i;
3575
        for(i=0; i<4; i++){
3576
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3577
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3578
        }
3579
        s->mb_intra = IS_INTRA(mb_type);
3580

    
3581
        if (IS_SKIP(mb_type)) {
3582
            /* skip mb */
3583
            for(i=0;i<6;i++)
3584
                s->block_last_index[i] = -1;
3585
            s->mv_dir = MV_DIR_FORWARD;
3586
            s->mv_type = MV_TYPE_16X16;
3587
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3588
                s->mcsel=1;
3589
                s->mb_skiped = 0;
3590
            }else{
3591
                s->mcsel=0;
3592
                s->mb_skiped = 1;
3593
            }
3594
        }else if(s->mb_intra){
3595
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3596
        }else if(!s->mb_intra){
3597
//            s->mcsel= 0; //FIXME do we need to init that
3598
            
3599
            s->mv_dir = MV_DIR_FORWARD;
3600
            if (IS_8X8(mb_type)) {
3601
                s->mv_type = MV_TYPE_8X8;
3602
            } else {
3603
                s->mv_type = MV_TYPE_16X16;
3604
            }
3605
        }
3606
    } else { /* I-Frame */
3607
        s->mb_intra = 1;
3608
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3609
    }
3610

    
3611
    if (!IS_SKIP(mb_type)) {
3612
        int i;
3613
        /* decode each block */
3614
        for (i = 0; i < 6; i++) {
3615
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3616
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3617
                return -1;
3618
            }
3619
            cbp+=cbp;
3620
        }
3621
    }
3622

    
3623
    /* per-MB end of slice check */
3624

    
3625
    if(--s->mb_num_left <= 0){
3626
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3627
        if(mpeg4_is_resync(s))
3628
            return SLICE_END;
3629
        else
3630
            return SLICE_NOEND;     
3631
    }else{
3632
        if(mpeg4_is_resync(s)){
3633
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3634
            if(s->cbp_table[xy+delta])
3635
                return SLICE_END;
3636
        }
3637
        return SLICE_OK;
3638
    }
3639
}
3640

    
3641
/**
3642
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3643
 */
3644
static void preview_obmc(MpegEncContext *s){
3645
    GetBitContext gb= s->gb;
3646
    
3647
    int cbpc, i, pred_x, pred_y, mx, my;
3648
    int16_t *mot_val;
3649
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3650
    const int stride= s->b8_stride*2;
3651
    
3652
    for(i=0; i<4; i++)
3653
        s->block_index[i]+= 2;
3654
    for(i=4; i<6; i++)
3655
        s->block_index[i]+= 1;
3656
    s->mb_x++;
3657
    
3658
    assert(s->pict_type == P_TYPE);
3659

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

    
3733
    s->gb= gb;
3734
}
3735

    
3736
static void h263_decode_dquant(MpegEncContext *s){
3737
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3738

    
3739
    if(s->modified_quant){
3740
        if(get_bits1(&s->gb))
3741
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3742
        else
3743
            s->qscale= get_bits(&s->gb, 5);
3744
    }else
3745
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3746
    ff_set_qscale(s, s->qscale);
3747
}
3748

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

    
3819
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3820
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3821
        } else {
3822
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3823
            s->mv_type = MV_TYPE_8X8;
3824
            for(i=0;i<4;i++) {
3825
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3826
                if (s->umvplus)
3827
                  mx = h263p_decode_umotion(s, pred_x);
3828
                else
3829
                  mx = h263_decode_motion(s, pred_x, 1);
3830
                if (mx >= 0xffff)
3831
                    return -1;
3832
                
3833
                if (s->umvplus)
3834
                  my = h263p_decode_umotion(s, pred_y);
3835
                else    
3836
                  my = h263_decode_motion(s, pred_y, 1);
3837
                if (my >= 0xffff)
3838
                    return -1;
3839
                s->mv[0][i][0] = mx;
3840
                s->mv[0][i][1] = my;
3841
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3842
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3843
                mot_val[0] = mx;
3844
                mot_val[1] = my;
3845
            }
3846
        }
3847

    
3848
        /* decode each block */
3849
        for (i = 0; i < 6; i++) {
3850
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3851
                return -1;
3852
            cbp+=cbp;
3853
        }
3854

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

    
3866
        //FIXME ugly 
3867
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= 
3868
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= 
3869
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= 
3870
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
3871

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

    
3879
            mb_type= h263_mb_type_b_map[ mb_type ];
3880
        }while(!mb_type);
3881

    
3882
        s->mb_intra = IS_INTRA(mb_type);
3883
        if(HAS_CBP(mb_type)){
3884
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
3885
            if(s->mb_intra){
3886
                dquant = IS_QUANT(mb_type);
3887
                goto intra;
3888
            }
3889

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

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

    
3906
        if(IS_QUANT(mb_type)){
3907
            h263_decode_dquant(s);
3908
        }
3909

    
3910
        if(IS_DIRECT(mb_type)){
3911
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3912
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
3913
        }else{
3914
            s->mv_dir = 0;
3915
            s->mv_type= MV_TYPE_16X16;
3916
//FIXME UMV
3917

    
3918
            if(USES_LIST(mb_type, 0)){
3919
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
3920
                s->mv_dir = MV_DIR_FORWARD;
3921

    
3922
                mx = h263_decode_motion(s, mx, 1);
3923
                my = h263_decode_motion(s, my, 1);
3924
                
3925
                s->mv[0][0][0] = mx;
3926
                s->mv[0][0][1] = my;
3927
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3928
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3929
            }
3930
    
3931
            if(USES_LIST(mb_type, 1)){
3932
                int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
3933
                s->mv_dir |= MV_DIR_BACKWARD;
3934
                
3935
                mx = h263_decode_motion(s, mx, 1);
3936
                my = h263_decode_motion(s, my, 1);
3937

    
3938
                s->mv[1][0][0] = mx;
3939
                s->mv[1][0][1] = my;
3940
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3941
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3942
            }
3943
        }
3944
          
3945
        s->current_picture.mb_type[xy]= mb_type;
3946

    
3947
        /* decode each block */
3948
        for (i = 0; i < 6; i++) {
3949
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3950
                return -1;
3951
            cbp+=cbp;
3952
        }
3953
    } else { /* I-Frame */
3954
        do{
3955
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3956
            if (cbpc < 0){
3957
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3958
                return -1;
3959
            }
3960
        }while(cbpc == 8);
3961

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

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

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

    
4003
        if(v==0)
4004
            return SLICE_END;
4005
    }
4006

    
4007
    return SLICE_OK;     
4008
}
4009

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4329
    return SLICE_OK;     
4330
}
4331

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

    
4337
    if (code == 0)
4338
        return pred;
4339
    if (code < 0)
4340
        return 0xffff;
4341

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

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

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

    
4393
}
4394

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

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

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

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

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

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

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

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

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

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

    
4714
            if(IS_3IV1) 
4715
                cache ^= 0xC0000000;
4716

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

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

    
4734
                        level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4735

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

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

    
4773
                    i+= run + 1;
4774
                    if(last) i+=192;
4775
                } else {