Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 204b5c9e

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!=3){
1460
        if(n!=2) c= 1024;
1461
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1462
    }
1463
    pred_dc = 1024;
1464
    /* just DC prediction */
1465
    if (a != 1024 && c != 1024)
1466
        pred_dc = (a + c) >> 1;
1467
    else if (a != 1024)
1468
        pred_dc = a;
1469
    else
1470
        pred_dc = c;
1471
    
1472
    /* we assume pred is positive */
1473
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1474
    *dc_val_ptr = &dc_val[x + y * wrap];
1475
    return pred_dc;
1476
}
1477

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

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

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

    
1572
    wrap = s->block_wrap[0];
1573
    xy = s->block_index[block];
1574

    
1575
    mot_val = s->current_picture.motion_val[0][xy];
1576

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

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

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

    
1636
    mot_val = s->current_picture.motion_val[dir] + xy;
1637

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

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

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

    
1714
        assert(val>=-l && val<l);
1715

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

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

    
1733
}
1734

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

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

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

    
1790
                bit_size = f_code - 1;
1791
                range = 1 << bit_size;
1792

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

    
1805
            mv_penalty[f_code][mv+MAX_MV]= len;
1806
        }
1807
    }
1808

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

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

    
1821
#ifdef CONFIG_ENCODERS
1822

    
1823
static void init_uni_dc_tab(void)
1824
{
1825
    int level, uni_code, uni_len;
1826

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

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

    
1842
        /* luminance */
1843
        uni_code= DCtab_lum[size][0];
1844
        uni_len = DCtab_lum[size][1];
1845

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

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

    
1872
    }
1873
}
1874

    
1875
#endif //CONFIG_ENCODERS
1876

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

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

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

    
1967
    if (!done) {
1968
        done = 1;
1969

    
1970
        init_uni_dc_tab();
1971

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

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

    
1999
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2000

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

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

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

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

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

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

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

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

    
2173
#ifdef CONFIG_ENCODERS
2174

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

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

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

    
2194
    time_div= s->time/s->time_increment_resolution;
2195
    time_mod= s->time%s->time_increment_resolution;
2196

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

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

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

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

    
2234
    ff_mpeg4_stuffing(&s->pb);
2235
}
2236

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

    
2250
    put_bits(&s->pb, 16, 0);
2251
    put_bits(&s->pb, 16, VOS_STARTCODE);
2252

    
2253
    put_bits(&s->pb, 8, profile_and_level_indication);
2254

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

    
2266
    ff_mpeg4_stuffing(&s->pb);
2267
}
2268

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2411
    put_bits(&s->pb, 5, s->qscale);
2412

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

    
2420
#endif //CONFIG_ENCODERS
2421

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

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

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

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

    
2460
    wrap= s->block_wrap[n];
2461
    dc_val = s->dc_val[0] + s->block_index[n];
2462

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

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

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

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

    
2493
    return pred;
2494
}
2495

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

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

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

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

    
2554
}
2555

    
2556
#ifdef CONFIG_ENCODERS
2557

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

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

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

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

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

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

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

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

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

    
2777
#endif
2778

    
2779

    
2780
/***********************************************/
2781
/* decoding */
2782

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

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

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

    
2840
/* init vlcs */
2841

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

    
2847
    if (!done) {
2848
        done = 1;
2849

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

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

    
2905
int ff_h263_decode_mba(MpegEncContext *s)
2906
{
2907
    int i, mb_pos;
2908

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

    
2916
    return mb_pos;
2917
}
2918

    
2919
void ff_h263_encode_mba(MpegEncContext *s)
2920
{
2921
    int i, mb_pos;
2922

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

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

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

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

    
2958
        ff_h263_decode_mba(s);
2959

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

    
2979
    if(s->qscale==0) 
2980
        return -1;
2981

    
2982
    return 0;
2983
}
2984

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

    
2992
#ifdef CONFIG_ENCODERS
2993

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

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

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

    
3025
    flush_put_bits(&s->pb2);
3026
    flush_put_bits(&s->tex_pb);
3027

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

    
3034
#endif //CONFIG_ENCODERS
3035

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

    
3050
#ifdef CONFIG_ENCODERS
3051

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

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

    
3064
#endif //CONFIG_ENCODERS
3065

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

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

    
3095
            s->gb= gb;
3096

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

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

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

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

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

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

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

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

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

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

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

    
3194
    return 0;
3195
}
3196

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

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

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

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

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

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

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

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

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

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

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

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

    
3309
    if      (sum < -len) sum= -len;
3310
    else if (sum >= len) sum= len-1;
3311

    
3312
    return sum;
3313
}
3314

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3477
    return mb_num;
3478
}
3479

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

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

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

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

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

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

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

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

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

    
3617
    return 0;        
3618
}
3619

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

    
3629
    mb_type= s->current_picture.mb_type[xy];
3630
    cbp = s->cbp_table[xy];
3631

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

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

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

    
3686
    /* per-MB end of slice check */
3687

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

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

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

    
3796
    s->gb= gb;
3797
}
3798

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

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

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

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

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

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

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

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

    
3942
            mb_type= h263_mb_type_b_map[ mb_type ];
3943
        }while(!mb_type);
3944

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

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

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

    
3969
        if(IS_QUANT(mb_type)){
3970
            h263_decode_dquant(s);
3971
        }
3972

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

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

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

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

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

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

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

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

    
4066
        if(v==0)
4067
            return SLICE_END;
4068
    }
4069

    
4070
    return SLICE_OK;     
4071
}
4072

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4392
    return SLICE_OK;     
4393
}
4394

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

    
4400
    if (code == 0)
4401
        return pred;
4402
    if (code < 0)
4403
        return 0xffff;
4404

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

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

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

    
4456
}
4457

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

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

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

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

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

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

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

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

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

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

    
4777
            if(IS_3IV1) 
4778
                cache ^= 0xC0000000;
4779

    
4