Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ b98202a4

History | View | Annotate | Download (208 KB)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
135
#ifdef CONFIG_ENCODERS
136

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

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

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

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

    
156
      align_put_bits(&s->pb);
157

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

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

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

    
222
    align_put_bits(&s->pb);
223

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

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

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

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

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

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

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

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

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

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

    
350
        ff_h263_encode_mba(s);
351

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

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

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

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

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

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

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

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

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

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

    
458
    return score < 0;
459
}
460

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

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

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

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

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

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

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

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

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

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

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

    
659
#ifdef CONFIG_ENCODERS
660

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1570
    wrap = s->block_wrap[0];
1571
    xy = s->block_index[block];
1572

    
1573
    mot_val = s->current_picture.motion_val[0][xy];
1574

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

    
1623
// identical to above but with s->current_picture->motion_val, the above one will be removed, and this renamed to it
1624
int16_t *h263_pred_motion2(MpegEncContext * s, int block, int dir,
1625
                        int *px, int *py)
1626
{
1627
    int xy, wrap;
1628
    int16_t *A, *B, *C, (*mot_val)[2];
1629
    static const int off[4]= {2, 1, 1, -1};
1630

    
1631
    wrap = s->b8_stride;
1632
    xy = 2*(s->mb_x + s->mb_y * wrap);
1633

    
1634
    mot_val = s->current_picture.motion_val[dir] + xy;
1635

    
1636
    A = mot_val[ - 1];
1637
    /* special case for first (slice) line */
1638
    if (s->first_slice_line && block<3) {
1639
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1640
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1641
        if(block==0){ //most common case
1642
            if(s->mb_x  == s->resync_mb_x){ //rare
1643
                *px= *py = 0;
1644
            }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1645
                C = mot_val[off[block] - wrap];
1646
                if(s->mb_x==0){
1647
                    *px = C[0];
1648
                    *py = C[1];
1649
                }else{
1650
                    *px = mid_pred(A[0], 0, C[0]);
1651
                    *py = mid_pred(A[1], 0, C[1]);
1652
                }
1653
            }else{
1654
                *px = A[0];
1655
                *py = A[1];
1656
            }
1657
        }else if(block==1){
1658
            if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1659
                C = mot_val[off[block] - wrap];
1660
                *px = mid_pred(A[0], 0, C[0]);
1661
                *py = mid_pred(A[1], 0, C[1]);
1662
            }else{
1663
                *px = A[0];
1664
                *py = A[1];
1665
            }
1666
        }else{ /* block==2*/
1667
            B = mot_val[ - wrap];
1668
            C = mot_val[off[block] - wrap];
1669
            if(s->mb_x == s->resync_mb_x) //rare
1670
                A[0]=A[1]=0;
1671
    
1672
            *px = mid_pred(A[0], B[0], C[0]);
1673
            *py = mid_pred(A[1], B[1], C[1]);
1674
        }
1675
    } else {
1676
        B = mot_val[ - wrap];
1677
        C = mot_val[off[block] - wrap];
1678
        *px = mid_pred(A[0], B[0], C[0]);
1679
        *py = mid_pred(A[1], B[1], C[1]);
1680
    }
1681
    return *mot_val;
1682
}
1683

    
1684
#ifdef CONFIG_ENCODERS
1685
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1686
{
1687
    int range, l, bit_size, sign, code, bits;
1688

    
1689
    if (val == 0) {
1690
        /* zero vector */
1691
        code = 0;
1692
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1693
    } else {
1694
        bit_size = f_code - 1;
1695
        range = 1 << bit_size;
1696
        /* modulo encoding */
1697
        l = range * 32;
1698
#if 1
1699
        val+= l;
1700
        val&= 2*l-1;
1701
        val-= l;
1702
        sign = val>>31;
1703
        val= (val^sign)-sign;
1704
        sign&=1;
1705
#else
1706
        if (val < -l) {
1707
            val += 2*l;
1708
        } else if (val >= l) {
1709
            val -= 2*l;
1710
        }
1711

    
1712
        assert(val>=-l && val<l);
1713

    
1714
        if (val >= 0) {
1715
            sign = 0;
1716
        } else {
1717
            val = -val;
1718
            sign = 1;
1719
        }
1720
#endif
1721
        val--;
1722
        code = (val >> bit_size) + 1;
1723
        bits = val & (range - 1);
1724

    
1725
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1726
        if (bit_size > 0) {
1727
            put_bits(&s->pb, bit_size, bits);
1728
        }
1729
    }
1730

    
1731
}
1732

    
1733
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1734
static void h263p_encode_umotion(MpegEncContext * s, int val)
1735
{
1736
    short sval = 0; 
1737
    short i = 0;
1738
    short n_bits = 0;
1739
    short temp_val;
1740
    int code = 0;
1741
    int tcode;
1742
    
1743
    if ( val == 0)
1744
        put_bits(&s->pb, 1, 1);
1745
    else if (val == 1)
1746
        put_bits(&s->pb, 3, 0);
1747
    else if (val == -1)
1748
        put_bits(&s->pb, 3, 2);
1749
    else {
1750
        
1751
        sval = ((val < 0) ? (short)(-val):(short)val);
1752
        temp_val = sval;
1753
        
1754
        while (temp_val != 0) {
1755
            temp_val = temp_val >> 1;
1756
            n_bits++;
1757
        }
1758
        
1759
        i = n_bits - 1;
1760
        while (i > 0) {
1761
            tcode = (sval & (1 << (i-1))) >> (i-1);
1762
            tcode = (tcode << 1) | 1;
1763
            code = (code << 2) | tcode;
1764
            i--;
1765
        }
1766
        code = ((code << 1) | (val < 0)) << 1;
1767
        put_bits(&s->pb, (2*n_bits)+1, code);
1768
        //printf("\nVal = %d\tCode = %d", sval, code);
1769
    }
1770
}
1771

    
1772
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1773
{
1774
    int f_code;
1775
    int mv;
1776
    
1777
    if(mv_penalty==NULL)
1778
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1779
    
1780
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1781
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1782
            int len;
1783

    
1784
            if(mv==0) len= mvtab[0][1];
1785
            else{
1786
                int val, bit_size, range, code;
1787

    
1788
                bit_size = s->f_code - 1;
1789
                range = 1 << bit_size;
1790

    
1791
                val=mv;
1792
                if (val < 0) 
1793
                    val = -val;
1794
                val--;
1795
                code = (val >> bit_size) + 1;
1796
                if(code<33){
1797
                    len= mvtab[code][1] + 1 + bit_size;
1798
                }else{
1799
                    len= mvtab[32][1] + 2 + bit_size;
1800
                }
1801
            }
1802

    
1803
            mv_penalty[f_code][mv+MAX_MV]= len;
1804
        }
1805
    }
1806

    
1807
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1808
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1809
            fcode_tab[mv+MAX_MV]= f_code;
1810
        }
1811
    }
1812

    
1813
    for(mv=0; mv<MAX_MV*2+1; mv++){
1814
        umv_fcode_tab[mv]= 1;
1815
    }
1816
}
1817
#endif
1818

    
1819
#ifdef CONFIG_ENCODERS
1820

    
1821
static void init_uni_dc_tab(void)
1822
{
1823
    int level, uni_code, uni_len;
1824

    
1825
    for(level=-256; level<256; level++){
1826
        int size, v, l;
1827
        /* find number of bits */
1828
        size = 0;
1829
        v = abs(level);
1830
        while (v) {
1831
            v >>= 1;
1832
            size++;
1833
        }
1834

    
1835
        if (level < 0)
1836
            l= (-level) ^ ((1 << size) - 1);
1837
        else
1838
            l= level;
1839

    
1840
        /* luminance */
1841
        uni_code= DCtab_lum[size][0];
1842
        uni_len = DCtab_lum[size][1];
1843

    
1844
        if (size > 0) {
1845
            uni_code<<=size; uni_code|=l;
1846
            uni_len+=size;
1847
            if (size > 8){
1848
                uni_code<<=1; uni_code|=1;
1849
                uni_len++;
1850
            }
1851
        }
1852
        uni_DCtab_lum_bits[level+256]= uni_code;
1853
        uni_DCtab_lum_len [level+256]= uni_len;
1854

    
1855
        /* chrominance */
1856
        uni_code= DCtab_chrom[size][0];
1857
        uni_len = DCtab_chrom[size][1];
1858
        
1859
        if (size > 0) {
1860
            uni_code<<=size; uni_code|=l;
1861
            uni_len+=size;
1862
            if (size > 8){
1863
                uni_code<<=1; uni_code|=1;
1864
                uni_len++;
1865
            }
1866
        }
1867
        uni_DCtab_chrom_bits[level+256]= uni_code;
1868
        uni_DCtab_chrom_len [level+256]= uni_len;
1869

    
1870
    }
1871
}
1872

    
1873
#endif //CONFIG_ENCODERS
1874

    
1875
#ifdef CONFIG_ENCODERS
1876
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1877
    int slevel, run, last;
1878
    
1879
    assert(MAX_LEVEL >= 64);
1880
    assert(MAX_RUN   >= 63);
1881

    
1882
    for(slevel=-64; slevel<64; slevel++){
1883
        if(slevel==0) continue;
1884
        for(run=0; run<64; run++){
1885
            for(last=0; last<=1; last++){
1886
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1887
                int level= slevel < 0 ? -slevel : slevel;
1888
                int sign= slevel < 0 ? 1 : 0;
1889
                int bits, len, code;
1890
                int level1, run1;
1891
                
1892
                len_tab[index]= 100;
1893
                     
1894
                /* ESC0 */
1895
                code= get_rl_index(rl, last, run, level);
1896
                bits= rl->table_vlc[code][0];
1897
                len=  rl->table_vlc[code][1];
1898
                bits=bits*2+sign; len++;
1899
                
1900
                if(code!=rl->n && len < len_tab[index]){
1901
                    bits_tab[index]= bits;
1902
                    len_tab [index]= len;
1903
                }
1904
#if 1
1905
                /* ESC1 */
1906
                bits= rl->table_vlc[rl->n][0];
1907
                len=  rl->table_vlc[rl->n][1];
1908
                bits=bits*2;    len++; //esc1
1909
                level1= level - rl->max_level[last][run];
1910
                if(level1>0){
1911
                    code= get_rl_index(rl, last, run, level1);
1912
                    bits<<= rl->table_vlc[code][1];
1913
                    len  += rl->table_vlc[code][1];
1914
                    bits += rl->table_vlc[code][0];
1915
                    bits=bits*2+sign; len++;
1916
                
1917
                    if(code!=rl->n && len < len_tab[index]){
1918
                        bits_tab[index]= bits;
1919
                        len_tab [index]= len;
1920
                    }
1921
                }
1922
#endif 
1923
#if 1
1924
                /* ESC2 */
1925
                bits= rl->table_vlc[rl->n][0];
1926
                len=  rl->table_vlc[rl->n][1];
1927
                bits=bits*4+2;    len+=2; //esc2
1928
                run1 = run - rl->max_run[last][level] - 1;
1929
                if(run1>=0){
1930
                    code= get_rl_index(rl, last, run1, level);
1931
                    bits<<= rl->table_vlc[code][1];
1932
                    len  += rl->table_vlc[code][1];
1933
                    bits += rl->table_vlc[code][0];
1934
                    bits=bits*2+sign; len++;
1935
                
1936
                    if(code!=rl->n && len < len_tab[index]){
1937
                        bits_tab[index]= bits;
1938
                        len_tab [index]= len;
1939
                    }
1940
                }
1941
#endif           
1942
                /* ESC3 */        
1943
                bits= rl->table_vlc[rl->n][0];
1944
                len = rl->table_vlc[rl->n][1];
1945
                bits=bits*4+3;    len+=2; //esc3
1946
                bits=bits*2+last; len++;
1947
                bits=bits*64+run; len+=6;
1948
                bits=bits*2+1;    len++;  //marker
1949
                bits=bits*4096+(slevel&0xfff); len+=12;
1950
                bits=bits*2+1;    len++;  //marker
1951
                
1952
                if(len < len_tab[index]){
1953
                    bits_tab[index]= bits;
1954
                    len_tab [index]= len;
1955
                }
1956
            }
1957
        }
1958
    }
1959
}
1960

    
1961
void h263_encode_init(MpegEncContext *s)
1962
{
1963
    static int done = 0;
1964

    
1965
    if (!done) {
1966
        done = 1;
1967

    
1968
        init_uni_dc_tab();
1969

    
1970
        init_rl(&rl_inter);
1971
        init_rl(&rl_intra);
1972
        init_rl(&rl_intra_aic);
1973
        
1974
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1975
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1976

    
1977
        init_mv_penalty_and_fcode(s);
1978
    }
1979
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1980
    
1981
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1982
    switch(s->codec_id){
1983
    case CODEC_ID_MPEG4:
1984
        s->fcode_tab= fcode_tab;
1985
        s->min_qcoeff= -2048;
1986
        s->max_qcoeff=  2047;
1987
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1988
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1989
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1990
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1991
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
1992
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1993
        s->ac_esc_length= 7+2+1+6+1+12+1;
1994
        s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
1995
        s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1996

    
1997
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1998

    
1999
            s->avctx->extradata= av_malloc(1024);
2000
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
2001
            
2002
            mpeg4_encode_visual_object_header(s);
2003
            mpeg4_encode_vol_header(s, 0, 0);
2004

    
2005
//            ff_mpeg4_stuffing(&s->pb); ?
2006
            flush_put_bits(&s->pb);
2007
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2008
        }
2009
        
2010
        break;
2011
    case CODEC_ID_H263P:
2012
        if(s->umvplus)
2013
            s->fcode_tab= umv_fcode_tab;
2014
        if(s->modified_quant){
2015
            s->min_qcoeff= -2047;
2016
            s->max_qcoeff=  2047;
2017
        }else{
2018
            s->min_qcoeff= -127;
2019
            s->max_qcoeff=  127;
2020
        }
2021
        break;
2022
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
2023
    case CODEC_ID_FLV1:
2024
        if (s->h263_flv > 1) {
2025
            s->min_qcoeff= -1023;
2026
            s->max_qcoeff=  1023;
2027
        } else {
2028
            s->min_qcoeff= -127;
2029
            s->max_qcoeff=  127;
2030
        }
2031
        s->y_dc_scale_table=
2032
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2033
        break;
2034
    default: //nothing needed default table allready set in mpegvideo.c
2035
        s->min_qcoeff= -127;
2036
        s->max_qcoeff=  127;
2037
        s->y_dc_scale_table=
2038
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2039
    }
2040
}
2041

    
2042
/**
2043
 * encodes a 8x8 block.
2044
 * @param block the 8x8 block
2045
 * @param n block index (0-3 are luma, 4-5 are chroma)
2046
 */
2047
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2048
{
2049
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2050
    RLTable *rl;
2051

    
2052
    rl = &rl_inter;
2053
    if (s->mb_intra && !s->h263_aic) {
2054
        /* DC coef */
2055
        level = block[0];
2056
        /* 255 cannot be represented, so we clamp */
2057
        if (level > 254) {
2058
            level = 254;
2059
            block[0] = 254;
2060
        }
2061
        /* 0 cannot be represented also */
2062
        else if (level < 1) {
2063
            level = 1;
2064
            block[0] = 1;
2065
        }
2066
        if (level == 128) //FIXME check rv10
2067
            put_bits(&s->pb, 8, 0xff);
2068
        else
2069
            put_bits(&s->pb, 8, level);
2070
        i = 1;
2071
    } else {
2072
        i = 0;
2073
        if (s->h263_aic && s->mb_intra)
2074
            rl = &rl_intra_aic;
2075
            
2076
        if(s->alt_inter_vlc && !s->mb_intra){
2077
            int aic_vlc_bits=0;
2078
            int inter_vlc_bits=0;
2079
            int wrong_pos=-1;
2080
            int aic_code;
2081
            
2082
            last_index = s->block_last_index[n];
2083
            last_non_zero = i - 1;
2084
            for (; i <= last_index; i++) {
2085
                j = s->intra_scantable.permutated[i];
2086
                level = block[j];
2087
                if (level) {
2088
                    run = i - last_non_zero - 1;
2089
                    last = (i == last_index);
2090
                    
2091
                    if(level<0) level= -level;
2092
                
2093
                    code = get_rl_index(rl, last, run, level);
2094
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2095
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2096
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2097

    
2098
                    if (code == rl->n) {
2099
                        inter_vlc_bits += 1+6+8-1;
2100
                    }                
2101
                    if (aic_code == rl_intra_aic.n) {
2102
                        aic_vlc_bits += 1+6+8-1;
2103
                        wrong_pos += run + 1;
2104
                    }else
2105
                        wrong_pos += wrong_run[aic_code];
2106
                    last_non_zero = i;
2107
                }    
2108
            }
2109
            i = 0;
2110
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2111
                rl = &rl_intra_aic;
2112
        }
2113
    }
2114
   
2115
    /* AC coefs */
2116
    last_index = s->block_last_index[n];
2117
    last_non_zero = i - 1;
2118
    for (; i <= last_index; i++) {
2119
        j = s->intra_scantable.permutated[i];
2120
        level = block[j];
2121
        if (level) {
2122
            run = i - last_non_zero - 1;
2123
            last = (i == last_index);
2124
            sign = 0;
2125
            slevel = level;
2126
            if (level < 0) {
2127
                sign = 1;
2128
                level = -level;
2129
            }
2130
            code = get_rl_index(rl, last, run, level);
2131
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2132
            if (code == rl->n) {
2133
              if(s->h263_flv <= 1){
2134
                put_bits(&s->pb, 1, last);
2135
                put_bits(&s->pb, 6, run);
2136
                
2137
                assert(slevel != 0);
2138

    
2139
                if(level < 128) 
2140
                    put_bits(&s->pb, 8, slevel & 0xff);
2141
                else{
2142
                    put_bits(&s->pb, 8, 128);
2143
                    put_bits(&s->pb, 5, slevel & 0x1f);
2144
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2145
                }
2146
              }else{
2147
                if(level < 64) { // 7-bit level
2148
                        put_bits(&s->pb, 1, 0);
2149
                        put_bits(&s->pb, 1, last);
2150
                        put_bits(&s->pb, 6, run);
2151

    
2152
                        put_bits(&s->pb, 7, slevel & 0x7f);
2153
                    } else {
2154
                        /* 11-bit level */
2155
                        put_bits(&s->pb, 1, 1);
2156
                        put_bits(&s->pb, 1, last);
2157
                        put_bits(&s->pb, 6, run);
2158

    
2159
                        put_bits(&s->pb, 11, slevel & 0x7ff);
2160
                    }
2161
              }
2162
            } else {
2163
                put_bits(&s->pb, 1, sign);
2164
            }
2165
            last_non_zero = i;
2166
        }
2167
    }
2168
}
2169
#endif
2170

    
2171
#ifdef CONFIG_ENCODERS
2172

    
2173
/***************************************************/
2174
/**
2175
 * add mpeg4 stuffing bits (01...1)
2176
 */
2177
void ff_mpeg4_stuffing(PutBitContext * pbc)
2178
{
2179
    int length;
2180
    put_bits(pbc, 1, 0);
2181
    length= (-put_bits_count(pbc))&7;
2182
    if(length) put_bits(pbc, length, (1<<length)-1);
2183
}
2184

    
2185
/* must be called before writing the header */
2186
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2187
    int time_div, time_mod;
2188

    
2189
    assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2190
    s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2191

    
2192
    time_div= s->time/s->time_increment_resolution;
2193
    time_mod= s->time%s->time_increment_resolution;
2194

    
2195
    if(s->pict_type==B_TYPE){
2196
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2197
    }else{
2198
        s->last_time_base= s->time_base;
2199
        s->time_base= time_div;
2200
        s->pp_time= s->time - s->last_non_b_time;
2201
        s->last_non_b_time= s->time;
2202
    }
2203
}
2204

    
2205
static void mpeg4_encode_gop_header(MpegEncContext * s){
2206
    int hours, minutes, seconds;
2207
    int64_t time;
2208
    
2209
    put_bits(&s->pb, 16, 0);
2210
    put_bits(&s->pb, 16, GOP_STARTCODE);
2211
    
2212
    time= s->current_picture_ptr->pts;
2213
    if(s->reordered_input_picture[1])
2214
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2215
    time= (time*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2216

    
2217
    seconds= time/s->time_increment_resolution;
2218
    minutes= seconds/60; seconds %= 60;
2219
    hours= minutes/60; minutes %= 60;
2220
    hours%=24;
2221

    
2222
    put_bits(&s->pb, 5, hours);
2223
    put_bits(&s->pb, 6, minutes);
2224
    put_bits(&s->pb, 1, 1);
2225
    put_bits(&s->pb, 6, seconds);
2226
    
2227
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); 
2228
    put_bits(&s->pb, 1, 0); //broken link == NO
2229
    
2230
    s->last_time_base= time / s->time_increment_resolution; 
2231

    
2232
    ff_mpeg4_stuffing(&s->pb);
2233
}
2234

    
2235
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2236
    int profile_and_level_indication;
2237
    int vo_ver_id;
2238
    
2239
    if(s->max_b_frames || s->quarter_sample){
2240
        profile_and_level_indication= 0xF1; // adv simple level 1
2241
        vo_ver_id= 5;
2242
    }else{
2243
        profile_and_level_indication= 0x01; // simple level 1
2244
        vo_ver_id= 1;
2245
    }
2246
    //FIXME levels
2247

    
2248
    put_bits(&s->pb, 16, 0);
2249
    put_bits(&s->pb, 16, VOS_STARTCODE);
2250

    
2251
    put_bits(&s->pb, 8, profile_and_level_indication);
2252

    
2253
    put_bits(&s->pb, 16, 0);
2254
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2255
    
2256
    put_bits(&s->pb, 1, 1);
2257
        put_bits(&s->pb, 4, vo_ver_id);
2258
        put_bits(&s->pb, 3, 1); //priority
2259
 
2260
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
2261
    
2262
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2263

    
2264
    ff_mpeg4_stuffing(&s->pb);
2265
}
2266

    
2267
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2268
{
2269
    int vo_ver_id;
2270

    
2271
    if(s->max_b_frames || s->quarter_sample){
2272
        vo_ver_id= 5;
2273
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2274
    }else{
2275
        vo_ver_id= 1;
2276
        s->vo_type= SIMPLE_VO_TYPE;
2277
    }
2278

    
2279
    put_bits(&s->pb, 16, 0);
2280
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2281
    put_bits(&s->pb, 16, 0);
2282
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2283

    
2284
    put_bits(&s->pb, 1, 0);                /* random access vol */
2285
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
2286
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
2287
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
2288
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
2289
    
2290
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2291

    
2292
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2293
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2294
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2295
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2296
    }
2297

    
2298
    if(s->low_delay){
2299
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
2300
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
2301
        put_bits(&s->pb, 1, s->low_delay);
2302
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
2303
    }else{
2304
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
2305
    }
2306

    
2307
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
2308
    put_bits(&s->pb, 1, 1);                /* marker bit */
2309
    
2310
    put_bits(&s->pb, 16, s->time_increment_resolution);
2311
    if (s->time_increment_bits < 1)
2312
        s->time_increment_bits = 1;
2313
    put_bits(&s->pb, 1, 1);                /* marker bit */
2314
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
2315
    put_bits(&s->pb, 1, 1);                /* marker bit */
2316
    put_bits(&s->pb, 13, s->width);        /* vol width */
2317
    put_bits(&s->pb, 1, 1);                /* marker bit */
2318
    put_bits(&s->pb, 13, s->height);        /* vol height */
2319
    put_bits(&s->pb, 1, 1);                /* marker bit */
2320
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2321
    put_bits(&s->pb, 1, 1);                /* obmc disable */
2322
    if (vo_ver_id == 1) {
2323
        put_bits(&s->pb, 1, s->vol_sprite_usage);                /* sprite enable */
2324
    }else{
2325
        put_bits(&s->pb, 2, s->vol_sprite_usage);                /* sprite enable */
2326
    }
2327
    
2328
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
2329
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
2330

    
2331
    if(s->mpeg_quant){
2332
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2333
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2334
    }
2335

    
2336
    if (vo_ver_id != 1)
2337
        put_bits(&s->pb, 1, s->quarter_sample);
2338
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
2339
    s->resync_marker= s->rtp_mode;
2340
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2341
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2342
    if(s->data_partitioning){
2343
        put_bits(&s->pb, 1, 0);                /* no rvlc */
2344
    }
2345

    
2346
    if (vo_ver_id != 1){
2347
        put_bits(&s->pb, 1, 0);                /* newpred */
2348
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
2349
    }
2350
    put_bits(&s->pb, 1, 0);                /* scalability */
2351
    
2352
    ff_mpeg4_stuffing(&s->pb);
2353

    
2354
    /* user data */
2355
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2356
        put_bits(&s->pb, 16, 0);
2357
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
2358
        put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2359
    }
2360
}
2361

    
2362
/* write mpeg4 VOP header */
2363
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2364
{
2365
    int time_incr;
2366
    int time_div, time_mod;
2367
    
2368
    if(s->pict_type==I_TYPE){
2369
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2370
            if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2371
                mpeg4_encode_visual_object_header(s);
2372
            if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2373
                mpeg4_encode_vol_header(s, 0, 0);
2374
        }
2375
        mpeg4_encode_gop_header(s);
2376
    }
2377
    
2378
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2379

    
2380
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2381
    
2382
    put_bits(&s->pb, 16, 0);                /* vop header */
2383
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2384
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
2385

    
2386
    time_div= s->time/s->time_increment_resolution;
2387
    time_mod= s->time%s->time_increment_resolution;
2388
    time_incr= time_div - s->last_time_base;
2389
    while(time_incr--)
2390
        put_bits(&s->pb, 1, 1);
2391
        
2392
    put_bits(&s->pb, 1, 0);
2393

    
2394
    put_bits(&s->pb, 1, 1);        /* marker */
2395
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
2396
    put_bits(&s->pb, 1, 1);        /* marker */
2397
    put_bits(&s->pb, 1, 1);        /* vop coded */
2398
    if (    s->pict_type == P_TYPE 
2399
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2400
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
2401
    }
2402
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
2403
    if(!s->progressive_sequence){
2404
         put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2405
         put_bits(&s->pb, 1, s->alternate_scan);
2406
    }
2407
    //FIXME sprite stuff
2408

    
2409
    put_bits(&s->pb, 5, s->qscale);
2410

    
2411
    if (s->pict_type != I_TYPE)
2412
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
2413
    if (s->pict_type == B_TYPE)
2414
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
2415
    //    printf("****frame %d\n", picture_number);
2416
}
2417

    
2418
#endif //CONFIG_ENCODERS
2419

    
2420
/**
2421
 * set qscale and update qscale dependant variables.
2422
 */
2423
void ff_set_qscale(MpegEncContext * s, int qscale)
2424
{
2425
    if (qscale < 1)
2426
        qscale = 1;
2427
    else if (qscale > 31)
2428
        qscale = 31;
2429
        
2430
    s->qscale = qscale;
2431
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2432

    
2433
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2434
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2435
}
2436

    
2437
/**
2438
 * predicts the dc.
2439
 * @param n block index (0-3 are luma, 4-5 are chroma)
2440
 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
2441
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2442
 * @return the quantized predicted dc
2443
 */
2444
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
2445
{
2446
    int a, b, c, wrap, pred, scale;
2447
    uint16_t *dc_val;
2448

    
2449
    /* find prediction */
2450
    if (n < 4) {
2451
        scale = s->y_dc_scale;
2452
    } else {
2453
        scale = s->c_dc_scale;
2454
    }
2455
    if(IS_3IV1)
2456
        scale= 8;
2457

    
2458
    wrap= s->block_wrap[n];
2459
    dc_val = s->dc_val[0] + s->block_index[n];
2460

    
2461
    /* B C
2462
     * A X 
2463
     */
2464
    a = dc_val[ - 1];
2465
    b = dc_val[ - 1 - wrap];
2466
    c = dc_val[ - wrap];
2467

    
2468
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2469
    if(s->first_slice_line && n!=3){
2470
        if(n!=2) b=c= 1024;
2471
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2472
    }
2473
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2474
        if(n==0 || n==4 || n==5)
2475
            b=1024;
2476
    }
2477

    
2478
    if (abs(a - b) < abs(b - c)) {
2479
        pred = c;
2480
        *dir_ptr = 1; /* top */
2481
    } else {
2482
        pred = a;
2483
        *dir_ptr = 0; /* left */
2484
    }
2485
    /* we assume pred is positive */
2486
    pred = FASTDIV((pred + (scale >> 1)), scale);
2487

    
2488
    /* prepare address for prediction update */
2489
    *dc_val_ptr = &dc_val[0];
2490

    
2491
    return pred;
2492
}
2493

    
2494
/**
2495
 * predicts the ac.
2496
 * @param n block index (0-3 are luma, 4-5 are chroma)
2497
 * @param dir the ac prediction direction
2498
 */
2499
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2500
                   int dir)
2501
{
2502
    int i;
2503
    int16_t *ac_val, *ac_val1;
2504
    int8_t * const qscale_table= s->current_picture.qscale_table;
2505

    
2506
    /* find prediction */
2507
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2508
    ac_val1 = ac_val;
2509
    if (s->ac_pred) {
2510
        if (dir == 0) {
2511
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2512
            /* left prediction */
2513
            ac_val -= 16;
2514
            
2515
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2516
                /* same qscale */
2517
                for(i=1;i<8;i++) {
2518
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2519
                }
2520
            }else{
2521
                /* different qscale, we must rescale */
2522
                for(i=1;i<8;i++) {
2523
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2524
                }
2525
            }
2526
        } else {
2527
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2528
            /* top prediction */
2529
            ac_val -= 16 * s->block_wrap[n];
2530

    
2531
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2532
                /* same qscale */
2533
                for(i=1;i<8;i++) {
2534
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2535
                }
2536
            }else{
2537
                /* different qscale, we must rescale */
2538
                for(i=1;i<8;i++) {
2539
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2540
                }
2541
            }
2542
        }
2543
    }
2544
    /* left copy */
2545
    for(i=1;i<8;i++)
2546
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2547

    
2548
    /* top copy */
2549
    for(i=1;i<8;i++)
2550
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2551

    
2552
}
2553

    
2554
#ifdef CONFIG_ENCODERS
2555

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

    
2582
    if (n < 4) {
2583
        /* luminance */
2584
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2585
    } else {
2586
        /* chrominance */
2587
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2588
    }
2589

    
2590
    /* encode remaining bits */
2591
    if (size > 0) {
2592
        if (level < 0)
2593
            level = (-level) ^ ((1 << size) - 1);
2594
        put_bits(&s->pb, size, level);
2595
        if (size > 8)
2596
            put_bits(&s->pb, 1, 1);
2597
    }
2598
#endif
2599
}
2600

    
2601
/**
2602
 * encodes a 8x8 block
2603
 * @param n block index (0-3 are luma, 4-5 are chroma)
2604
 */
2605
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2606
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2607
{
2608
    int i, last_non_zero;
2609
#if 0 //variables for the outcommented version
2610
    int code, sign, last;
2611
#endif
2612
    const RLTable *rl;
2613
    uint32_t *bits_tab;
2614
    uint8_t *len_tab;
2615
    const int last_index = s->block_last_index[n];
2616

    
2617
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2618
        /* mpeg4 based DC predictor */
2619
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2620
        if(last_index<1) return;
2621
        i = 1;
2622
        rl = &rl_intra;
2623
        bits_tab= uni_mpeg4_intra_rl_bits;
2624
        len_tab = uni_mpeg4_intra_rl_len;
2625
    } else {
2626
        if(last_index<0) return;
2627
        i = 0;
2628
        rl = &rl_inter;
2629
        bits_tab= uni_mpeg4_inter_rl_bits;
2630
        len_tab = uni_mpeg4_inter_rl_len;
2631
    }
2632

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

    
2721
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2722
                               uint8_t *scan_table)
2723
{
2724
    int i, last_non_zero;
2725
    const RLTable *rl;
2726
    uint8_t *len_tab;
2727
    const int last_index = s->block_last_index[n];
2728
    int len=0;
2729

    
2730
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2731
        /* mpeg4 based DC predictor */
2732
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2733
        if(last_index<1) return len;
2734
        i = 1;
2735
        rl = &rl_intra;
2736
        len_tab = uni_mpeg4_intra_rl_len;
2737
    } else {
2738
        if(last_index<0) return 0;
2739
        i = 0;
2740
        rl = &rl_inter;
2741
        len_tab = uni_mpeg4_inter_rl_len;
2742
    }
2743

    
2744
    /* AC coefs */
2745
    last_non_zero = i - 1;
2746
    for (; i < last_index; i++) {
2747
        int level = block[ scan_table[i] ];
2748
        if (level) {
2749
            int run = i - last_non_zero - 1;
2750
            level+=64;
2751
            if((level&(~127)) == 0){
2752
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2753
                len += len_tab[index];
2754
            }else{ //ESC3
2755
                len += 7+2+1+6+1+12+1;
2756
            }
2757
            last_non_zero = i;
2758
        }
2759
    }
2760
    /*if(i<=last_index)*/{
2761
        int level = block[ scan_table[i] ];
2762
        int run = i - last_non_zero - 1;
2763
        level+=64;
2764
        if((level&(~127)) == 0){
2765
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2766
            len += len_tab[index];
2767
        }else{ //ESC3
2768
            len += 7+2+1+6+1+12+1;
2769
        }
2770
    }
2771
    
2772
    return len;
2773
}
2774

    
2775
#endif
2776

    
2777

    
2778
/***********************************************/
2779
/* decoding */
2780

    
2781
static VLC intra_MCBPC_vlc;
2782
static VLC inter_MCBPC_vlc;
2783
static VLC cbpy_vlc;
2784
static VLC mv_vlc;
2785
static VLC dc_lum, dc_chrom;
2786
static VLC sprite_trajectory;
2787
static VLC mb_type_b_vlc;
2788
static VLC h263_mbtype_b_vlc;
2789
static VLC cbpc_b_vlc;
2790

    
2791
void init_vlc_rl(RLTable *rl)
2792
{
2793
    int i, q;
2794
    
2795
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2796
             &rl->table_vlc[0][1], 4, 2,
2797
             &rl->table_vlc[0][0], 4, 2);
2798

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

    
2838
/* init vlcs */
2839

    
2840
/* XXX: find a better solution to handle static init */
2841
void h263_decode_init_vlc(MpegEncContext *s)
2842
{
2843
    static int done = 0;
2844

    
2845
    if (!done) {
2846
        done = 1;
2847

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

    
2891
/**
2892
 * Get the GOB height based on picture height.
2893
 */
2894
int ff_h263_get_gob_height(MpegEncContext *s){
2895
    if (s->height <= 400)
2896
        return 1;
2897
    else if (s->height <= 800)
2898
        return  2;
2899
    else
2900
        return 4;
2901
}
2902

    
2903
int ff_h263_decode_mba(MpegEncContext *s)
2904
{
2905
    int i, mb_pos;
2906

    
2907
    for(i=0; i<6; i++){
2908
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2909
    }
2910
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2911
    s->mb_x= mb_pos % s->mb_width;
2912
    s->mb_y= mb_pos / s->mb_width;
2913

    
2914
    return mb_pos;
2915
}
2916

    
2917
void ff_h263_encode_mba(MpegEncContext *s)
2918
{
2919
    int i, mb_pos;
2920

    
2921
    for(i=0; i<6; i++){
2922
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2923
    }
2924
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
2925
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
2926
}
2927

    
2928
/**
2929
 * decodes the group of blocks header or slice header.
2930
 * @return <0 if an error occured
2931
 */
2932
static int h263_decode_gob_header(MpegEncContext *s)
2933
{
2934
    unsigned int val, gfid, gob_number;
2935
    int left;
2936
    
2937
    /* Check for GOB Start Code */
2938
    val = show_bits(&s->gb, 16);
2939
    if(val)
2940
        return -1;
2941

    
2942
        /* We have a GBSC probably with GSTUFF */
2943
    skip_bits(&s->gb, 16); /* Drop the zeros */
2944
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2945
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2946
    for(;left>13; left--){
2947
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2948
    }
2949
    if(left<=13) 
2950
        return -1;
2951

    
2952
    if(s->h263_slice_structured){
2953
        if(get_bits1(&s->gb)==0)
2954
            return -1;
2955

    
2956
        ff_h263_decode_mba(s);
2957

    
2958
        if(s->mb_num > 1583)
2959
            if(get_bits1(&s->gb)==0)
2960
                return -1;
2961
        
2962
        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
2963
        if(get_bits1(&s->gb)==0)
2964
            return -1;
2965
        gfid = get_bits(&s->gb, 2); /* GFID */
2966
    }else{
2967
        gob_number = get_bits(&s->gb, 5); /* GN */
2968
        s->mb_x= 0;
2969
        s->mb_y= s->gob_index* gob_number;
2970
        gfid = get_bits(&s->gb, 2); /* GFID */
2971
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2972
    }
2973
        
2974
    if(s->mb_y >= s->mb_height) 
2975
        return -1;
2976

    
2977
    if(s->qscale==0) 
2978
        return -1;
2979

    
2980
    return 0;
2981
}
2982

    
2983
static inline void memsetw(short *tab, int val, int n)
2984
{
2985
    int i;
2986
    for(i=0;i<n;i++)
2987
        tab[i] = val;
2988
}
2989

    
2990
#ifdef CONFIG_ENCODERS
2991

    
2992
void ff_mpeg4_init_partitions(MpegEncContext *s)
2993
{
2994
    uint8_t *start= pbBufPtr(&s->pb);
2995
    uint8_t *end= s->pb.buf_end;
2996
    int size= end - start;
2997
    int pb_size = size/3;
2998
    int pb2_size= size/3;
2999
    int tex_size= size - pb_size - pb2_size;
3000
    
3001
    set_put_bits_buffer_size(&s->pb, pb_size);
3002
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3003
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb2_size);
3004
}
3005

    
3006
void ff_mpeg4_merge_partitions(MpegEncContext *s)
3007
{
3008
    const int pb2_len   = put_bits_count(&s->pb2   );
3009
    const int tex_pb_len= put_bits_count(&s->tex_pb);
3010
    const int bits= put_bits_count(&s->pb);
3011

    
3012
    if(s->pict_type==I_TYPE){
3013
        put_bits(&s->pb, 19, DC_MARKER);
3014
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3015
        s->i_tex_bits+= tex_pb_len;
3016
    }else{
3017
        put_bits(&s->pb, 17, MOTION_MARKER);
3018
        s->misc_bits+=17 + pb2_len;
3019
        s->mv_bits+= bits - s->last_bits;
3020
        s->p_tex_bits+= tex_pb_len;
3021
    }
3022

    
3023
    flush_put_bits(&s->pb2);
3024
    flush_put_bits(&s->tex_pb);
3025

    
3026
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3027
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3028
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3029
    s->last_bits= put_bits_count(&s->pb);
3030
}
3031

    
3032
#endif //CONFIG_ENCODERS
3033

    
3034
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3035
    switch(s->pict_type){
3036
        case I_TYPE:
3037
            return 16;
3038
        case P_TYPE:
3039
        case S_TYPE:
3040
            return s->f_code+15;
3041
        case B_TYPE:
3042
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3043
        default:
3044
            return -1;
3045
    }
3046
}
3047

    
3048
#ifdef CONFIG_ENCODERS
3049

    
3050
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3051
{
3052
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3053

    
3054
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3055
    put_bits(&s->pb, 1, 1);
3056
    
3057
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3058
    put_bits(&s->pb, s->quant_precision, s->qscale);
3059
    put_bits(&s->pb, 1, 0); /* no HEC */
3060
}
3061

    
3062
#endif //CONFIG_ENCODERS
3063

    
3064
/**
3065
 * check if the next stuff is a resync marker or the end.
3066
 * @return 0 if not
3067
 */
3068
static inline int mpeg4_is_resync(MpegEncContext *s){
3069
    const int bits_count= get_bits_count(&s->gb);
3070
    
3071
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3072
        return 0;
3073
    }
3074

    
3075
    if(bits_count + 8 >= s->gb.size_in_bits){
3076
        int v= show_bits(&s->gb, 8);
3077
        v|= 0x7F >> (7-(bits_count&7));
3078
                
3079
        if(v==0x7F)
3080
            return 1;
3081
    }else{
3082
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3083
            int len;
3084
            GetBitContext gb= s->gb;
3085
        
3086
            skip_bits(&s->gb, 1);
3087
            align_get_bits(&s->gb);
3088
        
3089
            for(len=0; len<32; len++){
3090
                if(get_bits1(&s->gb)) break;
3091
            }
3092

    
3093
            s->gb= gb;
3094

    
3095
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3096
                return 1;
3097
        }
3098
    }
3099
    return 0;
3100
}
3101

    
3102
/**
3103
 * decodes the next video packet.
3104
 * @return <0 if something went wrong
3105
 */
3106
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3107
{
3108
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3109
    int header_extension=0, mb_num, len;
3110
    
3111
    /* is there enough space left for a video packet + header */
3112
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3113

    
3114
    for(len=0; len<32; len++){
3115
        if(get_bits1(&s->gb)) break;
3116
    }
3117

    
3118
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3119
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3120
        return -1;
3121
    }
3122
    
3123
    if(s->shape != RECT_SHAPE){
3124
        header_extension= get_bits1(&s->gb);
3125
        //FIXME more stuff here
3126
    }
3127

    
3128
    mb_num= get_bits(&s->gb, mb_num_bits);
3129
    if(mb_num>=s->mb_num){
3130
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3131
        return -1;
3132
    }
3133
    if(s->pict_type == B_TYPE){
3134
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3135
        if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
3136
    }
3137
    
3138
    s->mb_x= mb_num % s->mb_width;
3139
    s->mb_y= mb_num / s->mb_width;
3140

    
3141
    if(s->shape != BIN_ONLY_SHAPE){
3142
        int qscale= get_bits(&s->gb, s->quant_precision); 
3143
        if(qscale)
3144
            s->chroma_qscale=s->qscale= qscale;
3145
    }
3146

    
3147
    if(s->shape == RECT_SHAPE){
3148
        header_extension= get_bits1(&s->gb);
3149
    }
3150
    if(header_extension){
3151
        int time_increment;
3152
        int time_incr=0;
3153

    
3154
        while (get_bits1(&s->gb) != 0) 
3155
            time_incr++;
3156

    
3157
        check_marker(&s->gb, "before time_increment in video packed header");
3158
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3159
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3160
        
3161
        skip_bits(&s->gb, 2); /* vop coding type */
3162
        //FIXME not rect stuff here
3163

    
3164
        if(s->shape != BIN_ONLY_SHAPE){
3165
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3166
//FIXME dont just ignore everything
3167
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3168
                mpeg4_decode_sprite_trajectory(s);
3169
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3170
            }
3171

    
3172
            //FIXME reduced res stuff here
3173
            
3174
            if (s->pict_type != I_TYPE) {
3175
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
3176
                if(f_code==0){
3177
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3178
                }
3179
            }
3180
            if (s->pict_type == B_TYPE) {
3181
                int b_code = get_bits(&s->gb, 3);
3182
                if(b_code==0){
3183
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3184
                }
3185
            }       
3186
        }
3187
    }
3188
    //FIXME new-pred stuff
3189
    
3190
//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));
3191

    
3192
    return 0;
3193
}
3194

    
3195
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3196
{
3197
    int c_wrap, c_xy, l_wrap, l_xy;
3198

    
3199
    l_wrap= s->block_wrap[0];
3200
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
3201
    c_wrap= s->block_wrap[4];
3202
    c_xy= s->mb_y*c_wrap + s->mb_x;
3203

    
3204
#if 0
3205
    /* clean DC */
3206
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3207
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3208
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3209
#endif
3210

    
3211
    /* clean AC */
3212
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3213
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3214
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3215

    
3216
    /* clean MV */
3217
    // we cant clear the MVs as they might be needed by a b frame
3218
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3219
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3220
    s->last_mv[0][0][0]=
3221
    s->last_mv[0][0][1]=
3222
    s->last_mv[1][0][0]=
3223
    s->last_mv[1][0][1]= 0;
3224
}
3225

    
3226
/**
3227
 * decodes the group of blocks / video packet header.
3228
 * @return <0 if no resync found
3229
 */
3230
int ff_h263_resync(MpegEncContext *s){
3231
    int left, ret;
3232
    
3233
    if(s->codec_id==CODEC_ID_MPEG4){
3234
        skip_bits1(&s->gb);
3235
        align_get_bits(&s->gb);
3236
    }
3237

    
3238
    if(show_bits(&s->gb, 16)==0){
3239
        if(s->codec_id==CODEC_ID_MPEG4)
3240
            ret= mpeg4_decode_video_packet_header(s);
3241
        else
3242
            ret= h263_decode_gob_header(s);
3243
        if(ret>=0)
3244
            return 0;
3245
    }
3246
    //ok, its not where its supposed to be ...
3247
    s->gb= s->last_resync_gb;
3248
    align_get_bits(&s->gb);
3249
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3250
    
3251
    for(;left>16+1+5+5; left-=8){ 
3252
        if(show_bits(&s->gb, 16)==0){
3253
            GetBitContext bak= s->gb;
3254

    
3255
            if(s->codec_id==CODEC_ID_MPEG4)
3256
                ret= mpeg4_decode_video_packet_header(s);
3257
            else
3258
                ret= h263_decode_gob_header(s);
3259
            if(ret>=0)
3260
                return 0;
3261

    
3262
            s->gb= bak;
3263
        }
3264
        skip_bits(&s->gb, 8);
3265
    }
3266
    
3267
    return -1;
3268
}
3269

    
3270
/**
3271
 * gets the average motion vector for a GMC MB.
3272
 * @param n either 0 for the x component or 1 for y
3273
 * @returns the average MV for a GMC MB
3274
 */
3275
static inline int get_amv(MpegEncContext *s, int n){
3276
    int x, y, mb_v, sum, dx, dy, shift;
3277
    int len = 1 << (s->f_code + 4);
3278
    const int a= s->sprite_warping_accuracy;
3279

    
3280
    if(s->real_sprite_warping_points==1){
3281
        if(s->divx_version==500 && s->divx_build==413)
3282
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3283
        else
3284
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3285
    }else{
3286
        dx= s->sprite_delta[n][0];
3287
        dy= s->sprite_delta[n][1];
3288
        shift= s->sprite_shift[0];
3289
        if(n) dy -= 1<<(shift + a + 1);
3290
        else  dx -= 1<<(shift + a + 1);
3291
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3292

    
3293
        sum=0;
3294
        for(y=0; y<16; y++){
3295
            int v;
3296
        
3297
            v= mb_v + dy*y;
3298
            //XXX FIXME optimize
3299
            for(x=0; x<16; x++){
3300
                sum+= v>>shift;
3301
                v+= dx;
3302
            }
3303
        }
3304
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3305
    }
3306

    
3307
    if      (sum < -len) sum= -len;
3308
    else if (sum >= len) sum= len-1;
3309

    
3310
    return sum;
3311
}
3312

    
3313
/**
3314
 * decodes first partition.
3315
 * @return number of MBs decoded or <0 if an error occured
3316
 */
3317
static int mpeg4_decode_partition_a(MpegEncContext *s){
3318
    int mb_num;
3319
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3320
    
3321
    /* decode first partition */
3322
    mb_num=0;
3323
    s->first_slice_line=1;
3324
    for(; s->mb_y<s->mb_height; s->mb_y++){
3325
        ff_init_block_index(s);
3326
        for(; s->mb_x<s->mb_width; s->mb_x++){
3327
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3328
            int cbpc;
3329
            int dir=0;
3330
            
3331
            mb_num++;
3332
            ff_update_block_index(s);
3333
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3334
                s->first_slice_line=0;
3335
            
3336
            if(s->pict_type==I_TYPE){
3337
                int i;
3338

    
3339
                do{
3340
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
3341
                        return mb_num-1;
3342
                    }
3343

    
3344
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3345
                    if (cbpc < 0){
3346
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3347
                        return -1;
3348
                    }
3349
                }while(cbpc == 8);
3350
                
3351
                s->cbp_table[xy]= cbpc & 3;
3352
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3353
                s->mb_intra = 1;
3354

    
3355
                if(cbpc & 4) {
3356
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3357
                }
3358
                s->current_picture.qscale_table[xy]= s->qscale;
3359

    
3360
                s->mbintra_table[xy]= 1;
3361
                for(i=0; i<6; i++){
3362
                    int dc_pred_dir;
3363
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3364
                    if(dc < 0){
3365
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3366
                        return -1;
3367
                    }
3368
                    dir<<=1;
3369
                    if(dc_pred_dir) dir|=1;
3370
                }
3371
                s->pred_dir_table[xy]= dir;
3372
            }else{ /* P/S_TYPE */
3373
                int mx, my, pred_x, pred_y, bits;
3374
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3375
                const int stride= s->block_wrap[0]*2;
3376

    
3377
try_again:
3378
                bits= show_bits(&s->gb, 17);
3379
                if(bits==MOTION_MARKER){
3380
                    return mb_num-1;
3381
                }
3382
                skip_bits1(&s->gb);
3383
                if(bits&0x10000){
3384
                    /* skip mb */
3385
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3386
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3387
                        mx= get_amv(s, 0);
3388
                        my= get_amv(s, 1);
3389
                    }else{
3390
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3391
                        mx=my=0;
3392
                    }
3393
                    mot_val[0       ]= mot_val[2       ]=
3394
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3395
                    mot_val[1       ]= mot_val[3       ]=
3396
                    mot_val[1+stride]= mot_val[3+stride]= my;
3397

    
3398
                    if(s->mbintra_table[xy])
3399
                        ff_clean_intra_table_entries(s);
3400
                    continue;
3401
                }
3402

    
3403
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3404
                if (cbpc < 0){
3405
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3406
                    return -1;
3407
                }
3408
                if(cbpc == 20)
3409
                    goto try_again;
3410

    
3411
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3412
    
3413
                s->mb_intra = ((cbpc & 4) != 0);
3414
        
3415
                if(s->mb_intra){
3416
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3417
                    s->mbintra_table[xy]= 1;
3418
                    mot_val[0       ]= mot_val[2       ]= 
3419
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3420
                    mot_val[1       ]= mot_val[3       ]=
3421
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3422
                }else{
3423
                    if(s->mbintra_table[xy])
3424
                        ff_clean_intra_table_entries(s);
3425

    
3426
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3427
                        s->mcsel= get_bits1(&s->gb);
3428
                    else s->mcsel= 0;
3429
        
3430
                    if ((cbpc & 16) == 0) {
3431
                        /* 16x16 motion prediction */
3432

    
3433
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
3434
                        if(!s->mcsel){
3435
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3436
                            if (mx >= 0xffff)
3437
                                return -1;
3438

    
3439
                            my = h263_decode_motion(s, pred_y, s->f_code);
3440
                            if (my >= 0xffff)
3441
                                return -1;
3442
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3443
                        } else {
3444
                            mx = get_amv(s, 0);
3445
                            my = get_amv(s, 1);
3446
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3447
                        }
3448

    
3449
                        mot_val[0       ]= mot_val[2       ] =
3450
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3451
                        mot_val[1       ]= mot_val[3       ]=
3452
                        mot_val[1+stride]= mot_val[3+stride]= my;
3453
                    } else {
3454
                        int i;
3455
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3456
                        for(i=0;i<4;i++) {
3457
                            int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
3458
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3459
                            if (mx >= 0xffff)
3460
                                return -1;
3461
                
3462
                            my = h263_decode_motion(s, pred_y, s->f_code);
3463
                            if (my >= 0xffff)
3464
                                return -1;
3465
                            mot_val[0] = mx;
3466
                            mot_val[1] = my;
3467
                        }
3468
                    }
3469
                }
3470
            }
3471
        }
3472
        s->mb_x= 0;
3473
    }
3474

    
3475
    return mb_num;
3476
}
3477

    
3478
/**
3479
 * decode second partition.
3480
 * @return <0 if an error occured
3481
 */
3482
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3483
    int mb_num=0;
3484
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3485

    
3486
    s->mb_x= s->resync_mb_x;
3487
    s->first_slice_line=1;
3488
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3489
        ff_init_block_index(s);
3490
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3491
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3492

    
3493
            mb_num++;
3494
            ff_update_block_index(s);
3495
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3496
                s->first_slice_line=0;
3497
            
3498
            if(s->pict_type==I_TYPE){
3499
                int ac_pred= get_bits1(&s->gb);
3500
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3501
                if(cbpy<0){
3502
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3503
                    return -1;
3504
                }
3505
                
3506
                s->cbp_table[xy]|= cbpy<<2;
3507
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3508
            }else{ /* P || S_TYPE */
3509
                if(IS_INTRA(s->current_picture.mb_type[xy])){          
3510
                    int dir=0,i;
3511
                    int ac_pred = get_bits1(&s->gb);
3512
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3513

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

    
3524
                    for(i=0; i<6; i++){
3525
                        int dc_pred_dir;
3526
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3527
                        if(dc < 0){
3528
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3529
                            return -1;
3530
                        }
3531
                        dir<<=1;
3532
                        if(dc_pred_dir) dir|=1;
3533
                    }
3534
                    s->cbp_table[xy]&= 3; //remove dquant
3535
                    s->cbp_table[xy]|= cbpy<<2;
3536
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3537
                    s->pred_dir_table[xy]= dir;
3538
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3539
                    s->current_picture.qscale_table[xy]= s->qscale;
3540
                    s->cbp_table[xy]= 0;
3541
                }else{
3542
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3543

    
3544
                    if(cbpy<0){
3545
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3546
                        return -1;
3547
                    }
3548
                    
3549
                    if(s->cbp_table[xy] & 8) {
3550
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3551
                    }
3552
                    s->current_picture.qscale_table[xy]= s->qscale;
3553

    
3554
                    s->cbp_table[xy]&= 3; //remove dquant
3555
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3556
                }
3557
            }
3558
        }
3559
        if(mb_num >= mb_count) return 0;
3560
        s->mb_x= 0;
3561
    }
3562
    return 0;
3563
}
3564

    
3565
/**
3566
 * decodes the first & second partition
3567
 * @return <0 if error (and sets error type in the error_status_table)
3568
 */
3569
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3570
{
3571
    int mb_num;
3572
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3573
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3574
    
3575
    mb_num= mpeg4_decode_partition_a(s);    
3576
    if(mb_num<0){
3577
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3578
        return -1;
3579
    }
3580
    
3581
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3582
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3583
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3584
        return -1;
3585
    }
3586

    
3587
    s->mb_num_left= mb_num;
3588
        
3589
    if(s->pict_type==I_TYPE){
3590
        while(show_bits(&s->gb, 9) == 1)
3591
            skip_bits(&s->gb, 9);
3592
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3593
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3594
            return -1;
3595
        }
3596
    }else{
3597
        while(show_bits(&s->gb, 10) == 1)
3598
            skip_bits(&s->gb, 10);
3599
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3600
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3601
            return -1;
3602
        }
3603
    }
3604
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3605
    
3606
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3607
        if(s->pict_type==P_TYPE)
3608
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3609
        return -1;
3610
    }else{
3611
        if(s->pict_type==P_TYPE)
3612
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3613
    }
3614

    
3615
    return 0;        
3616
}
3617

    
3618
/**
3619
 * decode partition C of one MB.
3620
 * @return <0 if an error occured
3621
 */
3622
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3623
{
3624
    int cbp, mb_type;
3625
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3626

    
3627
    mb_type= s->current_picture.mb_type[xy];
3628
    cbp = s->cbp_table[xy];
3629

    
3630
    if(s->current_picture.qscale_table[xy] != s->qscale){
3631
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3632
    }
3633
    
3634
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3635
        int i;
3636
        for(i=0; i<4; i++){
3637
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3638
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3639
        }
3640
        s->mb_intra = IS_INTRA(mb_type);
3641

    
3642
        if (IS_SKIP(mb_type)) {
3643
            /* skip mb */
3644
            for(i=0;i<6;i++)
3645
                s->block_last_index[i] = -1;
3646
            s->mv_dir = MV_DIR_FORWARD;
3647
            s->mv_type = MV_TYPE_16X16;
3648
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3649
                s->mcsel=1;
3650
                s->mb_skiped = 0;
3651
            }else{
3652
                s->mcsel=0;
3653
                s->mb_skiped = 1;
3654
            }
3655
        }else if(s->mb_intra){
3656
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3657
        }else if(!s->mb_intra){
3658
//            s->mcsel= 0; //FIXME do we need to init that
3659
            
3660
            s->mv_dir = MV_DIR_FORWARD;
3661
            if (IS_8X8(mb_type)) {
3662
                s->mv_type = MV_TYPE_8X8;
3663
            } else {
3664
                s->mv_type = MV_TYPE_16X16;
3665
            }
3666
        }
3667
    } else { /* I-Frame */
3668
        s->mb_intra = 1;
3669
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3670
    }
3671

    
3672
    if (!IS_SKIP(mb_type)) {
3673
        int i;
3674
        /* decode each block */
3675
        for (i = 0; i < 6; i++) {
3676
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3677
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3678
                return -1;
3679
            }
3680
            cbp+=cbp;
3681
        }
3682
    }
3683

    
3684
    /* per-MB end of slice check */
3685

    
3686
    if(--s->mb_num_left <= 0){
3687
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3688
        if(mpeg4_is_resync(s))
3689
            return SLICE_END;
3690
        else
3691
            return SLICE_NOEND;     
3692
    }else{
3693
        if(mpeg4_is_resync(s)){
3694
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3695
            if(s->cbp_table[xy+delta])
3696
                return SLICE_END;
3697
        }
3698
        return SLICE_OK;
3699
    }
3700
}
3701

    
3702
/**
3703
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3704
 */
3705
static void preview_obmc(MpegEncContext *s){
3706
    GetBitContext gb= s->gb;
3707
    
3708
    int cbpc, i, pred_x, pred_y, mx, my;
3709
    int16_t *mot_val;
3710
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3711
    const int stride= s->block_wrap[0]*2;
3712
    
3713
    for(i=0; i<4; i++)
3714
        s->block_index[i]+= 2;
3715
    for(i=4; i<6; i++)
3716
        s->block_index[i]+= 1;
3717
    s->mb_x++;
3718
    
3719
    assert(s->pict_type == P_TYPE);
3720

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

    
3794
    s->gb= gb;
3795
}
3796

    
3797
static void h263_decode_dquant(MpegEncContext *s){
3798
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3799

    
3800
    if(s->modified_quant){
3801
        if(get_bits1(&s->gb))
3802
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3803
        else
3804
            s->qscale= get_bits(&s->gb, 5);
3805
    }else
3806
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3807
    ff_set_qscale(s, s->qscale);
3808
}
3809

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

    
3880
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3881
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3882
        } else {
3883
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3884
            s->mv_type = MV_TYPE_8X8;
3885
            for(i=0;i<4;i++) {
3886
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3887
                if (s->umvplus)
3888
                  mx = h263p_decode_umotion(s, pred_x);
3889
                else
3890
                  mx = h263_decode_motion(s, pred_x, 1);
3891
                if (mx >= 0xffff)
3892
                    return -1;
3893
                
3894
                if (s->umvplus)
3895
                  my = h263p_decode_umotion(s, pred_y);
3896
                else    
3897
                  my = h263_decode_motion(s, pred_y, 1);
3898
                if (my >= 0xffff)
3899
                    return -1;
3900
                s->mv[0][i][0] = mx;
3901
                s->mv[0][i][1] = my;
3902
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3903
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3904
                mot_val[0] = mx;
3905
                mot_val[1] = my;
3906
            }
3907
        }
3908

    
3909
        /* decode each block */
3910
        for (i = 0; i < 6; i++) {
3911
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3912
                return -1;
3913
            cbp+=cbp;
3914
        }
3915

    
3916
        if(s->obmc){
3917
            if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
3918
                preview_obmc(s);
3919
        }
3920
    } else if(s->pict_type==B_TYPE) {
3921
        int mb_type;
3922
        const int stride= s->b8_stride;
3923
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
3924
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
3925
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3926

    
3927
        //FIXME ugly 
3928
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= 
3929
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= 
3930
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= 
3931
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
3932

    
3933
        do{
3934
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
3935
            if (mb_type < 0){
3936
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
3937
                return -1;
3938
            }
3939

    
3940
            mb_type= h263_mb_type_b_map[ mb_type ];
3941
        }while(!mb_type);
3942

    
3943
        s->mb_intra = IS_INTRA(mb_type);
3944
        if(HAS_CBP(mb_type)){
3945
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
3946
            if(s->mb_intra){
3947
                dquant = IS_QUANT(mb_type);
3948
                goto intra;
3949
            }
3950

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

    
3953
            if (cbpy < 0){
3954
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3955
                return -1;
3956
            }
3957
        
3958
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3959
                cbpy ^= 0xF;
3960
        
3961
            cbp = (cbpc & 3) | (cbpy << 2);
3962
        }else
3963
            cbp=0;
3964
            
3965
        assert(!s->mb_intra);
3966

    
3967
        if(IS_QUANT(mb_type)){
3968
            h263_decode_dquant(s);
3969
        }
3970

    
3971
        if(IS_DIRECT(mb_type)){
3972
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3973
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
3974
        }else{
3975
            s->mv_dir = 0;
3976
            s->mv_type= MV_TYPE_16X16;
3977
//FIXME UMV
3978

    
3979
            if(USES_LIST(mb_type, 0)){
3980
                int16_t *mot_val= h263_pred_motion2(s, 0, 0, &mx, &my);
3981
                s->mv_dir = MV_DIR_FORWARD;
3982

    
3983
                mx = h263_decode_motion(s, mx, 1);
3984
                my = h263_decode_motion(s, my, 1);
3985
                
3986
                s->mv[0][0][0] = mx;
3987
                s->mv[0][0][1] = my;
3988
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3989
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3990
            }
3991
    
3992
            if(USES_LIST(mb_type, 1)){
3993
                int16_t *mot_val= h263_pred_motion2(s, 0, 1, &mx, &my);
3994
                s->mv_dir |= MV_DIR_BACKWARD;
3995
                
3996
                mx = h263_decode_motion(s, mx, 1);
3997
                my = h263_decode_motion(s, my, 1);
3998

    
3999
                s->mv[1][0][0] = mx;
4000
                s->mv[1][0][1] = my;
4001
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4002
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4003
            }
4004
        }
4005
          
4006
        s->current_picture.mb_type[xy]= mb_type;
4007

    
4008
        /* decode each block */
4009
        for (i = 0; i < 6; i++) {
4010
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4011
                return -1;
4012
            cbp+=cbp;
4013
        }
4014
    } else { /* I-Frame */
4015
        do{
4016
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4017
            if (cbpc < 0){
4018
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4019
                return -1;
4020
            }
4021
        }while(cbpc == 8);
4022

    
4023
        dquant = cbpc & 4;
4024
        s->mb_intra = 1;
4025
intra:
4026
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4027
        if (s->h263_aic) {
4028
            s->ac_pred = get_bits1(&s->gb);
4029
            if(s->ac_pred){
4030
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4031
            
4032
                s->h263_aic_dir = get_bits1(&s->gb);
4033
            }
4034
        }else
4035
            s->ac_pred = 0;
4036
        
4037
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4038
        if(cbpy<0){
4039
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4040
            return -1;
4041
        }
4042
        cbp = (cbpc & 3) | (cbpy << 2);
4043
        if (dquant) {
4044
            h263_decode_dquant(s);
4045
        }
4046

    
4047
        /* decode each block */
4048
        for (i = 0; i < 6; i++) {
4049
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4050
                return -1;
4051
            cbp+=cbp;
4052
        }
4053
    }
4054
end:
4055

    
4056
        /* per-MB end of slice check */
4057
    {
4058
        int v= show_bits(&s->gb, 16);
4059
    
4060
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4061
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4062
        }
4063

    
4064
        if(v==0)
4065
            return SLICE_END;
4066
    }
4067

    
4068
    return SLICE_OK;     
4069
}
4070

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

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

    
4145
                s->field_select[0][0]= get_bits1(&s->gb);
4146
                s->field_select[0][1]= get_bits1(&s->gb);
4147

    
4148
                h263_pred_motion(s, 0, &pred_x, &pred_y);
4149
                
4150
                for(i=0; i<2; i++){
4151
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4152
                    if (mx >= 0xffff)
4153
                        return -1;
4154
            
4155
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4156
                    if (my >= 0xffff)
4157
                        return -1;
4158

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

    
4202
        s->mb_intra = 0; //B-frames never contain intra blocks
4203
        s->mcsel=0;      //     ...               true gmc blocks
4204

    
4205
        if(s->mb_x==0){
4206
            for(i=0; i<2; i++){
4207
                s->last_mv[i][0][0]= 
4208
                s->last_mv[i][0][1]= 
4209
                s->last_mv[i][1][0]= 
4210
                s->last_mv[i][1][1]= 0;
4211
            }
4212
        }
4213

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

    
4217
        if(s->mb_skiped){
4218
                /* skip mb */
4219
            for(i=0;i<6;i++)
4220
                s->block_last_index[i] = -1;
4221

    
4222
            s->mv_dir = MV_DIR_FORWARD;
4223
            s->mv_type = MV_TYPE_16X16;
4224
            s->mv[0][0][0] = 0;
4225
            s->mv[0][0][1] = 0;
4226
            s->mv[1][0][0] = 0;
4227
            s->mv[1][0][1] = 0;
4228
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 
4229
            goto end;
4230
        }
4231

    
4232
        modb1= get_bits1(&s->gb); 
4233
        if(modb1){
4234
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4235
            cbp=0;
4236
        }else{
4237
            modb2= get_bits1(&s->gb);
4238
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4239
            if(mb_type<0){
4240
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4241
                return -1;
4242
            }
4243
            mb_type= mb_type_b_map[ mb_type ];
4244
            if(modb2) cbp= 0;
4245
            else      cbp= get_bits(&s->gb, 6);
4246

    
4247
            if ((!IS_DIRECT(mb_type)) && cbp) {
4248
                if(get_bits1(&s->gb)){
4249
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4250
                }
4251
            }
4252

    
4253
            if(!s->progressive_sequence){
4254
                if(cbp)
4255
                    s->interlaced_dct= get_bits1(&s->gb);
4256

    
4257
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4258
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4259
                    mb_type &= ~MB_TYPE_16x16;
4260

    
4261
                    if(USES_LIST(mb_type, 0)){
4262
                        s->field_select[0][0]= get_bits1(&s->gb);
4263
                        s->field_select[0][1]= get_bits1(&s->gb);
4264
                    }
4265
                    if(USES_LIST(mb_type, 1)){
4266
                        s->field_select[1][0]= get_bits1(&s->gb);
4267
                        s->field_select[1][1]= get_bits1(&s->gb);
4268
                    }
4269
                }
4270
            }
4271

    
4272
            s->mv_dir = 0;
4273
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4274
                s->mv_type= MV_TYPE_16X16;
4275

    
4276
                if(USES_LIST(mb_type, 0)){
4277
                    s->mv_dir = MV_DIR_FORWARD;
4278

    
4279
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4280
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4281
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4282
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4283
                }
4284
    
4285
                if(USES_LIST(mb_type, 1)){
4286
                    s->mv_dir |= MV_DIR_BACKWARD;
4287

    
4288
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4289
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4290
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4291
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4292
                }
4293
            }else if(!IS_DIRECT(mb_type)){
4294
                s->mv_type= MV_TYPE_FIELD;
4295

    
4296
                if(USES_LIST(mb_type, 0)){
4297
                    s->mv_dir = MV_DIR_FORWARD;
4298
                
4299
                    for(i=0; i<2; i++){
4300
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4301
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4302
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4303
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4304
                    }
4305
                }
4306
    
4307
                if(USES_LIST(mb_type, 1)){
4308
                    s->mv_dir |= MV_DIR_BACKWARD;
4309

    
4310
                    for(i=0; i<2; i++){
4311
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4312
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4313
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4314
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4315
                    }
4316
                }
4317
            }
4318
        }
4319
          
4320
        if(IS_DIRECT(mb_type)){
4321
            if(IS_SKIP(mb_type))
4322
                mx=my=0;
4323
            else{
4324
                mx = h263_decode_motion(s, 0, 1);
4325
                my = h263_decode_motion(s, 0, 1);
4326
            }
4327
 
4328
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4329
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4330
        }
4331
        s->current_picture.mb_type[xy]= mb_type;
4332
    } else { /* I-Frame */
4333
        do{
4334
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4335
            if (cbpc < 0){
4336
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4337
                return -1;
4338
            }
4339
        }while(cbpc == 8);
4340

    
4341
        dquant = cbpc & 4;
4342
        s->mb_intra = 1;
4343
intra:
4344
        s->ac_pred = get_bits1(&s->gb);
4345
        if(s->ac_pred)
4346
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4347
        else
4348
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4349
        
4350
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4351
        if(cbpy<0){
4352
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4353
            return -1;
4354
        }
4355
        cbp = (cbpc & 3) | (cbpy << 2);
4356
        if (dquant) {
4357
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4358
        }
4359
        
4360
        if(!s->progressive_sequence)
4361
            s->interlaced_dct= get_bits1(&s->gb);
4362

    
4363
        /* decode each block */
4364
        for (i = 0; i < 6; i++) {
4365
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4366
                return -1;
4367
            cbp+=cbp;
4368
        }
4369
        goto end;
4370
    }
4371

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

    
4380
        /* per-MB end of slice check */
4381
    if(s->codec_id==CODEC_ID_MPEG4){
4382
        if(mpeg4_is_resync(s)){
4383
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4384
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4385
                return SLICE_OK;
4386
            return SLICE_END;
4387
        }
4388
    }
4389

    
4390
    return SLICE_OK;     
4391
}
4392

    
4393
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4394
{
4395
    int code, val, sign, shift, l;
4396
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4397

    
4398
    if (code == 0)
4399
        return pred;
4400
    if (code < 0)
4401
        return 0xffff;
4402

    
4403
    sign = get_bits1(&s->gb);
4404
    shift = f_code - 1;
4405
    val = code;
4406
    if (shift) {
4407
        val = (val - 1) << shift;
4408
        val |= get_bits(&s->gb, shift);
4409
        val++;
4410
    }
4411
    if (sign)
4412
        val = -val;
4413
    val += pred;
4414

    
4415
    /* modulo decoding */
4416
    if (!s->h263_long_vectors) {
4417
        l = 1 << (f_code + 4);
4418
        val = ((val + l)&(l*2-1)) - l;
4419
    } else {
4420
        /* horrible h263 long vector mode */
4421
        if (pred < -31 && val < -63)
4422
            val += 64;
4423
        if (pred > 32 && val > 63)
4424
            val -= 64;
4425
        
4426
    }
4427
    return val;
4428
}
4429

    
4430
/* Decodes RVLC of H.263+ UMV */
4431
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4432
{
4433
   int code = 0, sign;
4434
   
4435
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4436
      return pred;
4437
   
4438
   code = 2 + get_bits1(&s->gb);
4439
   
4440
   while (get_bits1(&s->gb))
4441
   {
4442
      code <<= 1;
4443
      code += get_bits1(&s->gb);
4444
   }
4445
   sign = code & 1;
4446
   code >>= 1;
4447
   
4448
   code = (sign) ? (pred - code) : (pred + code);
4449
#ifdef DEBUG
4450
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
4451
#endif
4452
   return code;   
4453

    
4454
}
4455

    
4456
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4457
                             int n, int coded)
4458
{
4459
    int code, level, i, j, last, run;
4460
    RLTable *rl = &rl_inter;
4461
    const uint8_t *scan_table;
4462
    GetBitContext gb= s->gb;
4463

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

    
4582
/**
4583
 * decodes the dc value.
4584
 * @param n block index (0-3 are luma, 4-5 are chroma)
4585
 * @param dir_ptr the prediction direction will be stored here
4586
 * @return the quantized dc
4587
 */
4588
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4589
{
4590
    int level, pred, code;
4591
    uint16_t *dc_val;
4592

    
4593
    if (n < 4) 
4594
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4595
    else 
4596
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4597
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4598
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4599
        return -1;
4600
    }
4601
    if (code == 0) {
4602
        level = 0;
4603
    } else {
4604
        if(IS_3IV1){
4605
            if(code==1)
4606
                level= 2*get_bits1(&s->gb)-1;
4607
            else{
4608
                if(get_bits1(&s->gb))
4609
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4610
                else
4611
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4612
            }
4613
        }else{
4614
            level = get_xbits(&s->gb, code);
4615
        }
4616

    
4617
        if (code > 8){
4618
            if(get_bits1(&s->gb)==0){ /* marker */
4619
                if(s->error_resilience>=2){
4620
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4621
                    return -1;
4622
                }
4623
            }
4624
        }
4625
    }
4626
    pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
4627
    level += pred;
4628
    if (level < 0){
4629
        if(s->error_resilience>=3){
4630
            av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
4631
            return -1;
4632
        }
4633
        level = 0;
4634
    }
4635
    if (n < 4) {
4636
        *dc_val = level * s->y_dc_scale;
4637
    } else {
4638
        *dc_val = level * s->c_dc_scale;
4639
    }
4640
    if(IS_3IV1)
4641
        *dc_val = level * 8;
4642
    
4643
    if(s->error_resilience>=3){
4644
        if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
4645
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
4646
            return -1;
4647
        }
4648
    }
4649
    return level;
4650
}
4651

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

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

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

    
4765
                level=  level * qmul + qadd;
4766
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4767
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4768

    
4769
                i+= run + 1;
4770
                if(last) i+=192;
4771
          }else{
4772
            int cache;
4773
            cache= GET_CACHE(re, &s->gb);
4774

    
4775
            if(IS_3IV1) 
4776
                cache ^= 0xC0000000;
4777

    
4778
            if (cache&0x80000000) {
4779
                if (cache&0x40000000) {