Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 58c2182d

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 = (((int)start + size/3)&(~3)) - (int)start;
3000
    int tex_size= (size - 2*pb_size)&(~3);
3001
    
3002
    set_put_bits_buffer_size(&s->pb, pb_size);
3003
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3004
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3005
}
3006

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

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

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

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

    
3033
#endif //CONFIG_ENCODERS
3034

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

    
3049
#ifdef CONFIG_ENCODERS
3050

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

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

    
3063
#endif //CONFIG_ENCODERS
3064

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

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

    
3094
            s->gb= gb;
3095

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

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

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

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

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

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

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

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

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

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

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

    
3193
    return 0;
3194
}
3195

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3311
    return sum;
3312
}
3313

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3476
    return mb_num;
3477
}
3478

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

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

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

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

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

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

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

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

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

    
3616
    return 0;        
3617
}
3618

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

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

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

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

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

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

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

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

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

    
3795
    s->gb= gb;
3796
}
3797

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4069
    return SLICE_OK;     
4070
}
4071

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4391
    return SLICE_OK;     
4392
}
4393

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

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

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

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

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

    
4455
}
4456

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

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

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

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

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

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

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

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

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

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

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

    
4779