Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 2c656386

History | View | Annotate | Download (209 KB)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
136
#ifdef CONFIG_ENCODERS
137

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

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

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

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

    
157
      align_put_bits(&s->pb);
158

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

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

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

    
223
    align_put_bits(&s->pb);
224

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

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

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

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

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

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

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

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

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

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

    
351
        ff_h263_encode_mba(s);
352

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

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

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

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

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

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

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

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

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

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

    
459
    return score < 0;
460
}
461

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

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

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

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

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

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

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

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

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

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

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

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

    
666
#ifdef CONFIG_ENCODERS
667

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1651
}
1652

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

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

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

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

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

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

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

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

    
1739
#ifdef CONFIG_ENCODERS
1740

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

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

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

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

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

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

    
1790
    }
1791
}
1792

    
1793
#endif //CONFIG_ENCODERS
1794

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

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

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

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

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

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

    
1932
        init_uni_dc_tab();
1933

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2146
#ifdef CONFIG_ENCODERS
2147

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

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

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

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

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

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

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

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

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

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

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

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

    
2236
    //FIXME levels
2237

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2405
#endif //CONFIG_ENCODERS
2406

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

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

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

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

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

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

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

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

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

    
2500
    return ret;
2501
}
2502

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

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

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

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

    
2561
}
2562

    
2563
#ifdef CONFIG_ENCODERS
2564

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

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

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

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

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

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

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

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

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

    
2784
#endif
2785

    
2786

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

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

    
2800
void init_vlc_rl(RLTable *rl, int use_static)
2801
{
2802
    int i, q;
2803
 
2804
    /* Return if static table is already initialized */
2805
    if(use_static && rl->rl_vlc[0])
2806
        return;    
2807

    
2808
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2809
             &rl->table_vlc[0][1], 4, 2,
2810
             &rl->table_vlc[0][0], 4, 2, use_static);
2811

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

    
2853
/* init vlcs */
2854

    
2855
/* XXX: find a better solution to handle static init */
2856
void h263_decode_init_vlc(MpegEncContext *s)
2857
{
2858
    static int done = 0;
2859

    
2860
    if (!done) {
2861
        done = 1;
2862

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

    
2906
/**
2907
 * Get the GOB height based on picture height.
2908
 */
2909
int ff_h263_get_gob_height(MpegEncContext *s){
2910
    if (s->height <= 400)
2911
        return 1;
2912
    else if (s->height <= 800)
2913
        return  2;
2914
    else
2915
        return 4;
2916
}
2917

    
2918
int ff_h263_decode_mba(MpegEncContext *s)
2919
{
2920
    int i, mb_pos;
2921

    
2922
    for(i=0; i<6; i++){
2923
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2924
    }
2925
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2926
    s->mb_x= mb_pos % s->mb_width;
2927
    s->mb_y= mb_pos / s->mb_width;
2928

    
2929
    return mb_pos;
2930
}
2931

    
2932
void ff_h263_encode_mba(MpegEncContext *s)
2933
{
2934
    int i, mb_pos;
2935

    
2936
    for(i=0; i<6; i++){
2937
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2938
    }
2939
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
2940
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
2941
}
2942

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

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

    
2967
    if(s->h263_slice_structured){
2968
        if(get_bits1(&s->gb)==0)
2969
            return -1;
2970

    
2971
        ff_h263_decode_mba(s);
2972

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

    
2992
    if(s->qscale==0) 
2993
        return -1;
2994

    
2995
    return 0;
2996
}
2997

    
2998
static inline void memsetw(short *tab, int val, int n)
2999
{
3000
    int i;
3001
    for(i=0;i<n;i++)
3002
        tab[i] = val;
3003
}
3004

    
3005
#ifdef CONFIG_ENCODERS
3006

    
3007
void ff_mpeg4_init_partitions(MpegEncContext *s)
3008
{
3009
    uint8_t *start= pbBufPtr(&s->pb);
3010
    uint8_t *end= s->pb.buf_end;
3011
    int size= end - start;
3012
    int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3013
    int tex_size= (size - 2*pb_size)&(~3);
3014
    
3015
    set_put_bits_buffer_size(&s->pb, pb_size);
3016
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3017
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3018
}
3019

    
3020
void ff_mpeg4_merge_partitions(MpegEncContext *s)
3021
{
3022
    const int pb2_len   = put_bits_count(&s->pb2   );
3023
    const int tex_pb_len= put_bits_count(&s->tex_pb);
3024
    const int bits= put_bits_count(&s->pb);
3025

    
3026
    if(s->pict_type==I_TYPE){
3027
        put_bits(&s->pb, 19, DC_MARKER);
3028
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3029
        s->i_tex_bits+= tex_pb_len;
3030
    }else{
3031
        put_bits(&s->pb, 17, MOTION_MARKER);
3032
        s->misc_bits+=17 + pb2_len;
3033
        s->mv_bits+= bits - s->last_bits;
3034
        s->p_tex_bits+= tex_pb_len;
3035
    }
3036

    
3037
    flush_put_bits(&s->pb2);
3038
    flush_put_bits(&s->tex_pb);
3039

    
3040
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3041
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3042
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3043
    s->last_bits= put_bits_count(&s->pb);
3044
}
3045

    
3046
#endif //CONFIG_ENCODERS
3047

    
3048
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3049
    switch(s->pict_type){
3050
        case I_TYPE:
3051
            return 16;
3052
        case P_TYPE:
3053
        case S_TYPE:
3054
            return s->f_code+15;
3055
        case B_TYPE:
3056
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3057
        default:
3058
            return -1;
3059
    }
3060
}
3061

    
3062
#ifdef CONFIG_ENCODERS
3063

    
3064
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3065
{
3066
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3067

    
3068
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3069
    put_bits(&s->pb, 1, 1);
3070
    
3071
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3072
    put_bits(&s->pb, s->quant_precision, s->qscale);
3073
    put_bits(&s->pb, 1, 0); /* no HEC */
3074
}
3075

    
3076
#endif //CONFIG_ENCODERS
3077

    
3078
/**
3079
 * check if the next stuff is a resync marker or the end.
3080
 * @return 0 if not
3081
 */
3082
static inline int mpeg4_is_resync(MpegEncContext *s){
3083
    const int bits_count= get_bits_count(&s->gb);
3084
    
3085
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3086
        return 0;
3087
    }
3088

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

    
3107
            s->gb= gb;
3108

    
3109
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3110
                return 1;
3111
        }
3112
    }
3113
    return 0;
3114
}
3115

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

    
3128
    for(len=0; len<32; len++){
3129
        if(get_bits1(&s->gb)) break;
3130
    }
3131

    
3132
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3133
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3134
        return -1;
3135
    }
3136
    
3137
    if(s->shape != RECT_SHAPE){
3138
        header_extension= get_bits1(&s->gb);
3139
        //FIXME more stuff here
3140
    }
3141

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

    
3155
    if(s->shape != BIN_ONLY_SHAPE){
3156
        int qscale= get_bits(&s->gb, s->quant_precision); 
3157
        if(qscale)
3158
            s->chroma_qscale=s->qscale= qscale;
3159
    }
3160

    
3161
    if(s->shape == RECT_SHAPE){
3162
        header_extension= get_bits1(&s->gb);
3163
    }
3164
    if(header_extension){
3165
        int time_increment;
3166
        int time_incr=0;
3167

    
3168
        while (get_bits1(&s->gb) != 0) 
3169
            time_incr++;
3170

    
3171
        check_marker(&s->gb, "before time_increment in video packed header");
3172
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3173
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3174
        
3175
        skip_bits(&s->gb, 2); /* vop coding type */
3176
        //FIXME not rect stuff here
3177

    
3178
        if(s->shape != BIN_ONLY_SHAPE){
3179
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3180
//FIXME dont just ignore everything
3181
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3182
                mpeg4_decode_sprite_trajectory(s, &s->gb);
3183
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3184
            }
3185

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

    
3206
    return 0;
3207
}
3208

    
3209
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3210
{
3211
    int c_wrap, c_xy, l_wrap, l_xy;
3212

    
3213
    l_wrap= s->b8_stride;
3214
    l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3215
    c_wrap= s->mb_stride;
3216
    c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3217

    
3218
#if 0
3219
    /* clean DC */
3220
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3221
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3222
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3223
#endif
3224

    
3225
    /* clean AC */
3226
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3227
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3228
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3229

    
3230
    /* clean MV */
3231
    // we cant clear the MVs as they might be needed by a b frame
3232
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3233
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3234
    s->last_mv[0][0][0]=
3235
    s->last_mv[0][0][1]=
3236
    s->last_mv[1][0][0]=
3237
    s->last_mv[1][0][1]= 0;
3238
}
3239

    
3240
/**
3241
 * decodes the group of blocks / video packet header.
3242
 * @return <0 if no resync found
3243
 */
3244
int ff_h263_resync(MpegEncContext *s){
3245
    int left, ret;
3246
    
3247
    if(s->codec_id==CODEC_ID_MPEG4){
3248
        skip_bits1(&s->gb);
3249
        align_get_bits(&s->gb);
3250
    }
3251

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

    
3269
            if(s->codec_id==CODEC_ID_MPEG4)
3270
                ret= mpeg4_decode_video_packet_header(s);
3271
            else
3272
                ret= h263_decode_gob_header(s);
3273
            if(ret>=0)
3274
                return 0;
3275

    
3276
            s->gb= bak;
3277
        }
3278
        skip_bits(&s->gb, 8);
3279
    }
3280
    
3281
    return -1;
3282
}
3283

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

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

    
3310
        sum=0;
3311
        for(y=0; y<16; y++){
3312
            int v;
3313
        
3314
            v= mb_v + dy*y;
3315
            //XXX FIXME optimize
3316
            for(x=0; x<16; x++){
3317
                sum+= v>>shift;
3318
                v+= dx;
3319
            }
3320
        }
3321
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3322
    }
3323

    
3324
    if      (sum < -len) sum= -len;
3325
    else if (sum >= len) sum= len-1;
3326

    
3327
    return sum;
3328
}
3329

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

    
3356
                do{
3357
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
3358
                        return mb_num-1;
3359
                    }
3360

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

    
3372
                if(cbpc & 4) {
3373
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3374
                }
3375
                s->current_picture.qscale_table[xy]= s->qscale;
3376

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

    
3394
try_again:
3395
                bits= show_bits(&s->gb, 17);
3396
                if(bits==MOTION_MARKER){
3397
                    return mb_num-1;
3398
                }
3399
                skip_bits1(&s->gb);
3400
                if(bits&0x10000){
3401
                    /* skip mb */
3402
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3403
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3404
                        mx= get_amv(s, 0);
3405
                        my= get_amv(s, 1);
3406
                    }else{
3407
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3408
                        mx=my=0;
3409
                    }
3410
                    mot_val[0       ]= mot_val[2       ]=
3411
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3412
                    mot_val[1       ]= mot_val[3       ]=
3413
                    mot_val[1+stride]= mot_val[3+stride]= my;
3414

    
3415
                    if(s->mbintra_table[xy])
3416
                        ff_clean_intra_table_entries(s);
3417
                    continue;
3418
                }
3419

    
3420
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3421
                if (cbpc < 0){
3422
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3423
                    return -1;
3424
                }
3425
                if(cbpc == 20)
3426
                    goto try_again;
3427

    
3428
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3429
    
3430
                s->mb_intra = ((cbpc & 4) != 0);
3431
        
3432
                if(s->mb_intra){
3433
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3434
                    s->mbintra_table[xy]= 1;
3435
                    mot_val[0       ]= mot_val[2       ]= 
3436
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3437
                    mot_val[1       ]= mot_val[3       ]=
3438
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3439
                }else{
3440
                    if(s->mbintra_table[xy])
3441
                        ff_clean_intra_table_entries(s);
3442

    
3443
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3444
                        s->mcsel= get_bits1(&s->gb);
3445
                    else s->mcsel= 0;
3446
        
3447
                    if ((cbpc & 16) == 0) {
3448
                        /* 16x16 motion prediction */
3449

    
3450
                        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3451
                        if(!s->mcsel){
3452
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3453
                            if (mx >= 0xffff)
3454
                                return -1;
3455

    
3456
                            my = h263_decode_motion(s, pred_y, s->f_code);
3457
                            if (my >= 0xffff)
3458
                                return -1;
3459
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3460
                        } else {
3461
                            mx = get_amv(s, 0);
3462
                            my = get_amv(s, 1);
3463
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3464
                        }
3465

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

    
3492
    return mb_num;
3493
}
3494

    
3495
/**
3496
 * decode second partition.
3497
 * @return <0 if an error occured
3498
 */
3499
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3500
    int mb_num=0;
3501
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3502

    
3503
    s->mb_x= s->resync_mb_x;
3504
    s->first_slice_line=1;
3505
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3506
        ff_init_block_index(s);
3507
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3508
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3509

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

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

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

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

    
3571
                    s->cbp_table[xy]&= 3; //remove dquant
3572
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3573
                }
3574
            }
3575
        }
3576
        if(mb_num >= mb_count) return 0;
3577
        s->mb_x= 0;
3578
    }
3579
    return 0;
3580
}
3581

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

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

    
3632
    return 0;        
3633
}
3634

    
3635
/**
3636
 * decode partition C of one MB.
3637
 * @return <0 if an error occured
3638
 */
3639
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3640
{
3641
    int cbp, mb_type;
3642
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3643

    
3644
    mb_type= s->current_picture.mb_type[xy];
3645
    cbp = s->cbp_table[xy];
3646

    
3647
    if(s->current_picture.qscale_table[xy] != s->qscale){
3648
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3649
    }
3650
    
3651
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3652
        int i;
3653
        for(i=0; i<4; i++){
3654
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3655
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3656
        }
3657
        s->mb_intra = IS_INTRA(mb_type);
3658

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

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

    
3701
    /* per-MB end of slice check */
3702

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

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

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

    
3811
    s->gb= gb;
3812
}
3813

    
3814
static void h263_decode_dquant(MpegEncContext *s){
3815
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3816

    
3817
    if(s->modified_quant){
3818
        if(get_bits1(&s->gb))
3819
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3820
        else
3821
            s->qscale= get_bits(&s->gb, 5);
3822
    }else
3823
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3824
    ff_set_qscale(s, s->qscale);
3825
}
3826

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

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

    
3926
        /* decode each block */
3927
        for (i = 0; i < 6; i++) {
3928
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3929
                return -1;
3930
            cbp+=cbp;
3931
        }
3932

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

    
3944
        //FIXME ugly 
3945
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= 
3946
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= 
3947
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= 
3948
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
3949

    
3950
        do{
3951
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
3952
            if (mb_type < 0){
3953
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
3954
                return -1;
3955
            }
3956

    
3957
            mb_type= h263_mb_type_b_map[ mb_type ];
3958
        }while(!mb_type);
3959

    
3960
        s->mb_intra = IS_INTRA(mb_type);
3961
        if(HAS_CBP(mb_type)){
3962
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
3963
            if(s->mb_intra){
3964
                dquant = IS_QUANT(mb_type);
3965
                goto intra;
3966
            }
3967

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

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

    
3984
        if(IS_QUANT(mb_type)){
3985
            h263_decode_dquant(s);
3986
        }
3987

    
3988
        if(IS_DIRECT(mb_type)){
3989
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3990
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
3991
        }else{
3992
            s->mv_dir = 0;
3993
            s->mv_type= MV_TYPE_16X16;
3994
//FIXME UMV
3995

    
3996
            if(USES_LIST(mb_type, 0)){
3997
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
3998
                s->mv_dir = MV_DIR_FORWARD;
3999

    
4000
                mx = h263_decode_motion(s, mx, 1);
4001
                my = h263_decode_motion(s, my, 1);
4002
                
4003
                s->mv[0][0][0] = mx;
4004
                s->mv[0][0][1] = my;
4005
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4006
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4007
            }
4008
    
4009
            if(USES_LIST(mb_type, 1)){
4010
                int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4011
                s->mv_dir |= MV_DIR_BACKWARD;
4012
                
4013
                mx = h263_decode_motion(s, mx, 1);
4014
                my = h263_decode_motion(s, my, 1);
4015

    
4016
                s->mv[1][0][0] = mx;
4017
                s->mv[1][0][1] = my;
4018
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4019
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4020
            }
4021
        }
4022
          
4023
        s->current_picture.mb_type[xy]= mb_type;
4024

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

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

    
4064
        /* decode each block */
4065
        for (i = 0; i < 6; i++) {
4066
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4067
                return -1;
4068
            cbp+=cbp;
4069
        }
4070
    }
4071
end:
4072

    
4073
        /* per-MB end of slice check */
4074
    {
4075
        int v= show_bits(&s->gb, 16);
4076
    
4077
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4078
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4079
        }
4080

    
4081
        if(v==0)
4082
            return SLICE_END;
4083
    }
4084

    
4085
    return SLICE_OK;     
4086
}
4087

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

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

    
4162
                s->field_select[0][0]= get_bits1(&s->gb);
4163
                s->field_select[0][1]= get_bits1(&s->gb);
4164

    
4165
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4166
                
4167
                for(i=0; i<2; i++){
4168
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4169
                    if (mx >= 0xffff)
4170
                        return -1;
4171
            
4172
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4173
                    if (my >= 0xffff)
4174
                        return -1;
4175

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

    
4219
        s->mb_intra = 0; //B-frames never contain intra blocks
4220
        s->mcsel=0;      //     ...               true gmc blocks
4221

    
4222
        if(s->mb_x==0){
4223
            for(i=0; i<2; i++){
4224
                s->last_mv[i][0][0]= 
4225
                s->last_mv[i][0][1]= 
4226
                s->last_mv[i][1][0]= 
4227
                s->last_mv[i][1][1]= 0;
4228
            }
4229
        }
4230

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

    
4234
        if(s->mb_skiped){
4235
                /* skip mb */
4236
            for(i=0;i<6;i++)
4237
                s->block_last_index[i] = -1;
4238

    
4239
            s->mv_dir = MV_DIR_FORWARD;
4240
            s->mv_type = MV_TYPE_16X16;
4241
            s->mv[0][0][0] = 0;
4242
            s->mv[0][0][1] = 0;
4243
            s->mv[1][0][0] = 0;
4244
            s->mv[1][0][1] = 0;
4245
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 
4246
            goto end;
4247
        }
4248

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

    
4264
            if ((!IS_DIRECT(mb_type)) && cbp) {
4265
                if(get_bits1(&s->gb)){
4266
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4267
                }
4268
            }
4269

    
4270
            if(!s->progressive_sequence){
4271
                if(cbp)
4272
                    s->interlaced_dct= get_bits1(&s->gb);
4273

    
4274
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4275
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4276
                    mb_type &= ~MB_TYPE_16x16;
4277

    
4278
                    if(USES_LIST(mb_type, 0)){
4279
                        s->field_select[0][0]= get_bits1(&s->gb);
4280
                        s->field_select[0][1]= get_bits1(&s->gb);
4281
                    }
4282
                    if(USES_LIST(mb_type, 1)){
4283
                        s->field_select[1][0]= get_bits1(&s->gb);
4284
                        s->field_select[1][1]= get_bits1(&s->gb);
4285
                    }
4286
                }
4287
            }
4288

    
4289
            s->mv_dir = 0;
4290
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4291
                s->mv_type= MV_TYPE_16X16;
4292

    
4293
                if(USES_LIST(mb_type, 0)){
4294
                    s->mv_dir = MV_DIR_FORWARD;
4295

    
4296
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4297
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4298
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4299
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4300
                }
4301
    
4302
                if(USES_LIST(mb_type, 1)){
4303
                    s->mv_dir |= MV_DIR_BACKWARD;
4304

    
4305
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4306
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4307
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4308
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4309
                }
4310
            }else if(!IS_DIRECT(mb_type)){
4311
                s->mv_type= MV_TYPE_FIELD;
4312

    
4313
                if(USES_LIST(mb_type, 0)){
4314
                    s->mv_dir = MV_DIR_FORWARD;
4315
                
4316
                    for(i=0; i<2; i++){
4317
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4318
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4319
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4320
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4321
                    }
4322
                }
4323
    
4324
                if(USES_LIST(mb_type, 1)){
4325
                    s->mv_dir |= MV_DIR_BACKWARD;
4326

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

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

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

    
4389
    /* decode each block */
4390
    for (i = 0; i < 6; i++) {
4391
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4392
            return -1;
4393
        cbp+=cbp;
4394
    }
4395
end:
4396

    
4397
        /* per-MB end of slice check */
4398
    if(s->codec_id==CODEC_ID_MPEG4){
4399
        if(mpeg4_is_resync(s)){
4400
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4401
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4402
                return SLICE_OK;
4403
            return SLICE_END;
4404
        }
4405
    }
4406

    
4407
    return SLICE_OK;     
4408
}
4409

    
4410
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4411
{
4412
    int code, val, sign, shift, l;
4413
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4414

    
4415
    if (code == 0)
4416
        return pred;
4417
    if (code < 0)
4418
        return 0xffff;
4419

    
4420
    sign = get_bits1(&s->gb);
4421
    shift = f_code - 1;
4422
    val = code;
4423
    if (shift) {
4424
        val = (val - 1) << shift;
4425
        val |= get_bits(&s->gb, shift);
4426
        val++;
4427
    }
4428
    if (sign)
4429
        val = -val;
4430
    val += pred;
4431

    
4432
    /* modulo decoding */
4433
    if (!s->h263_long_vectors) {
4434
        l = INT_BIT - 5 - f_code;
4435
        val = (val<<l)>>l;
4436
    } else {
4437
        /* horrible h263 long vector mode */
4438
        if (pred < -31 && val < -63)
4439
            val += 64;
4440
        if (pred > 32 && val > 63)
4441
            val -= 64;
4442
        
4443
    }
4444
    return val;
4445
}
4446

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

    
4471
}
4472

    
4473
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4474
                             int n, int coded)
4475
{
4476
    int code, level, i, j, last, run;
4477
    RLTable *rl = &rl_inter;
4478
    const uint8_t *scan_table;
4479
    GetBitContext gb= s->gb;
4480

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

    
4601
/**
4602
 * decodes the dc value.
4603
 * @param n block index (0-3 are luma, 4-5 are chroma)
4604
 * @param dir_ptr the prediction direction will be stored here
4605
 * @return the quantized dc
4606
 */
4607
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4608
{
4609
    int level, code;
4610

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

    
4635
        if (code > 8){
4636
            if(get_bits1(&s->gb)==0){ /* marker */
4637
                if(s->error_resilience>=2){
4638
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4639
                    return -1;
4640
                }
4641
            }
4642
        }
4643
    }
4644

    
4645
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4646
}
4647

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

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

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

    
4761
                level=  level * qmul + qadd;
4762
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4763
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4764

    
4765
                i+= run + 1;
4766
                if(last) i+=192;
4767
          }else{
4768
            int cache;
4769
            cache= GET_CACHE(re, &s->gb);
4770

    
4771
            if(IS_3IV1) 
4772
                cache ^= 0xC0000000;
4773

    
4774