Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ b1114f18

History | View | Annotate | Download (206 KB)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
134
#ifdef CONFIG_ENCODERS
135

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

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

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

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

    
155
      align_put_bits(&s->pb);
156

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

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

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

    
221
    align_put_bits(&s->pb);
222

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

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

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

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

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

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

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

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

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

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

    
349
        ff_h263_encode_mba(s);
350

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

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

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

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

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

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

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

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

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

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

    
457
    return score < 0;
458
}
459

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

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

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

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

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

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

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

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

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

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

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

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

    
664
#ifdef CONFIG_ENCODERS
665

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
942
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
943

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1363
    if(s->mb_y){
1364
        int qp_dt, qp_t, qp_tc;
1365

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1649
}
1650

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

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

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

    
1706
                bit_size = f_code - 1;
1707
                range = 1 << bit_size;
1708

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

    
1721
            mv_penalty[f_code][mv+MAX_MV]= len;
1722
        }
1723
    }
1724

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

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

    
1737
#ifdef CONFIG_ENCODERS
1738

    
1739
static void init_uni_dc_tab(void)
1740
{
1741
    int level, uni_code, uni_len;
1742

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

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

    
1758
        /* luminance */
1759
        uni_code= DCtab_lum[size][0];
1760
        uni_len = DCtab_lum[size][1];
1761

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

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

    
1788
    }
1789
}
1790

    
1791
#endif //CONFIG_ENCODERS
1792

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

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

    
1879
void h263_encode_init(MpegEncContext *s)
1880
{
1881
    static int done = 0;
1882

    
1883
    if (!done) {
1884
        done = 1;
1885

    
1886
        init_uni_dc_tab();
1887

    
1888
        init_rl(&rl_inter);
1889
        init_rl(&rl_intra);
1890
        init_rl(&rl_intra_aic);
1891
        
1892
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1893
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1894

    
1895
        init_mv_penalty_and_fcode(s);
1896
    }
1897
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1898
    
1899
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1900
    switch(s->codec_id){
1901
    case CODEC_ID_MPEG4:
1902
        s->fcode_tab= fcode_tab;
1903
        s->min_qcoeff= -2048;
1904
        s->max_qcoeff=  2047;
1905
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1906
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1907
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1908
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1909
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
1910
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1911
        s->ac_esc_length= 7+2+1+6+1+12+1;
1912
        s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
1913
        s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1914

    
1915
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1916

    
1917
            s->avctx->extradata= av_malloc(1024);
1918
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
1919
            
1920
            mpeg4_encode_visual_object_header(s);
1921
            mpeg4_encode_vol_header(s, 0, 0);
1922

    
1923
//            ff_mpeg4_stuffing(&s->pb); ?
1924
            flush_put_bits(&s->pb);
1925
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
1926
        }
1927
        
1928
        break;
1929
    case CODEC_ID_H263P:
1930
        if(s->umvplus)
1931
            s->fcode_tab= umv_fcode_tab;
1932
        if(s->modified_quant){
1933
            s->min_qcoeff= -2047;
1934
            s->max_qcoeff=  2047;
1935
        }else{
1936
            s->min_qcoeff= -127;
1937
            s->max_qcoeff=  127;
1938
        }
1939
        break;
1940
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1941
    case CODEC_ID_FLV1:
1942
        if (s->h263_flv > 1) {
1943
            s->min_qcoeff= -1023;
1944
            s->max_qcoeff=  1023;
1945
        } else {
1946
            s->min_qcoeff= -127;
1947
            s->max_qcoeff=  127;
1948
        }
1949
        s->y_dc_scale_table=
1950
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1951
        break;
1952
    default: //nothing needed default table allready set in mpegvideo.c
1953
        s->min_qcoeff= -127;
1954
        s->max_qcoeff=  127;
1955
        s->y_dc_scale_table=
1956
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1957
    }
1958
}
1959

    
1960
/**
1961
 * encodes a 8x8 block.
1962
 * @param block the 8x8 block
1963
 * @param n block index (0-3 are luma, 4-5 are chroma)
1964
 */
1965
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1966
{
1967
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1968
    RLTable *rl;
1969

    
1970
    rl = &rl_inter;
1971
    if (s->mb_intra && !s->h263_aic) {
1972
        /* DC coef */
1973
        level = block[0];
1974
        /* 255 cannot be represented, so we clamp */
1975
        if (level > 254) {
1976
            level = 254;
1977
            block[0] = 254;
1978
        }
1979
        /* 0 cannot be represented also */
1980
        else if (level < 1) {
1981
            level = 1;
1982
            block[0] = 1;
1983
        }
1984
        if (level == 128) //FIXME check rv10
1985
            put_bits(&s->pb, 8, 0xff);
1986
        else
1987
            put_bits(&s->pb, 8, level);
1988
        i = 1;
1989
    } else {
1990
        i = 0;
1991
        if (s->h263_aic && s->mb_intra)
1992
            rl = &rl_intra_aic;
1993
            
1994
        if(s->alt_inter_vlc && !s->mb_intra){
1995
            int aic_vlc_bits=0;
1996
            int inter_vlc_bits=0;
1997
            int wrong_pos=-1;
1998
            int aic_code;
1999
            
2000
            last_index = s->block_last_index[n];
2001
            last_non_zero = i - 1;
2002
            for (; i <= last_index; i++) {
2003
                j = s->intra_scantable.permutated[i];
2004
                level = block[j];
2005
                if (level) {
2006
                    run = i - last_non_zero - 1;
2007
                    last = (i == last_index);
2008
                    
2009
                    if(level<0) level= -level;
2010
                
2011
                    code = get_rl_index(rl, last, run, level);
2012
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2013
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2014
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2015

    
2016
                    if (code == rl->n) {
2017
                        inter_vlc_bits += 1+6+8-1;
2018
                    }                
2019
                    if (aic_code == rl_intra_aic.n) {
2020
                        aic_vlc_bits += 1+6+8-1;
2021
                        wrong_pos += run + 1;
2022
                    }else
2023
                        wrong_pos += wrong_run[aic_code];
2024
                    last_non_zero = i;
2025
                }    
2026
            }
2027
            i = 0;
2028
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2029
                rl = &rl_intra_aic;
2030
        }
2031
    }
2032
   
2033
    /* AC coefs */
2034
    last_index = s->block_last_index[n];
2035
    last_non_zero = i - 1;
2036
    for (; i <= last_index; i++) {
2037
        j = s->intra_scantable.permutated[i];
2038
        level = block[j];
2039
        if (level) {
2040
            run = i - last_non_zero - 1;
2041
            last = (i == last_index);
2042
            sign = 0;
2043
            slevel = level;
2044
            if (level < 0) {
2045
                sign = 1;
2046
                level = -level;
2047
            }
2048
            code = get_rl_index(rl, last, run, level);
2049
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2050
            if (code == rl->n) {
2051
              if(s->h263_flv <= 1){
2052
                put_bits(&s->pb, 1, last);
2053
                put_bits(&s->pb, 6, run);
2054
                
2055
                assert(slevel != 0);
2056

    
2057
                if(level < 128) 
2058
                    put_bits(&s->pb, 8, slevel & 0xff);
2059
                else{
2060
                    put_bits(&s->pb, 8, 128);
2061
                    put_bits(&s->pb, 5, slevel & 0x1f);
2062
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2063
                }
2064
              }else{
2065
                if(level < 64) { // 7-bit level
2066
                        put_bits(&s->pb, 1, 0);
2067
                        put_bits(&s->pb, 1, last);
2068
                        put_bits(&s->pb, 6, run);
2069

    
2070
                        put_bits(&s->pb, 7, slevel & 0x7f);
2071
                    } else {
2072
                        /* 11-bit level */
2073
                        put_bits(&s->pb, 1, 1);
2074
                        put_bits(&s->pb, 1, last);
2075
                        put_bits(&s->pb, 6, run);
2076

    
2077
                        put_bits(&s->pb, 11, slevel & 0x7ff);
2078
                    }
2079
              }
2080
            } else {
2081
                put_bits(&s->pb, 1, sign);
2082
            }
2083
            last_non_zero = i;
2084
        }
2085
    }
2086
}
2087
#endif
2088

    
2089
#ifdef CONFIG_ENCODERS
2090

    
2091
/***************************************************/
2092
/**
2093
 * add mpeg4 stuffing bits (01...1)
2094
 */
2095
void ff_mpeg4_stuffing(PutBitContext * pbc)
2096
{
2097
    int length;
2098
    put_bits(pbc, 1, 0);
2099
    length= (-put_bits_count(pbc))&7;
2100
    if(length) put_bits(pbc, length, (1<<length)-1);
2101
}
2102

    
2103
/* must be called before writing the header */
2104
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2105
    int time_div, time_mod;
2106

    
2107
    assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2108
    s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2109

    
2110
    time_div= s->time/s->time_increment_resolution;
2111
    time_mod= s->time%s->time_increment_resolution;
2112

    
2113
    if(s->pict_type==B_TYPE){
2114
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2115
    }else{
2116
        s->last_time_base= s->time_base;
2117
        s->time_base= time_div;
2118
        s->pp_time= s->time - s->last_non_b_time;
2119
        s->last_non_b_time= s->time;
2120
    }
2121
}
2122

    
2123
static void mpeg4_encode_gop_header(MpegEncContext * s){
2124
    int hours, minutes, seconds;
2125
    int64_t time;
2126
    
2127
    put_bits(&s->pb, 16, 0);
2128
    put_bits(&s->pb, 16, GOP_STARTCODE);
2129
    
2130
    time= s->current_picture_ptr->pts;
2131
    if(s->reordered_input_picture[1])
2132
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2133
    time= (time*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2134

    
2135
    seconds= time/s->time_increment_resolution;
2136
    minutes= seconds/60; seconds %= 60;
2137
    hours= minutes/60; minutes %= 60;
2138
    hours%=24;
2139

    
2140
    put_bits(&s->pb, 5, hours);
2141
    put_bits(&s->pb, 6, minutes);
2142
    put_bits(&s->pb, 1, 1);
2143
    put_bits(&s->pb, 6, seconds);
2144
    
2145
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); 
2146
    put_bits(&s->pb, 1, 0); //broken link == NO
2147
    
2148
    s->last_time_base= time / s->time_increment_resolution; 
2149

    
2150
    ff_mpeg4_stuffing(&s->pb);
2151
}
2152

    
2153
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2154
    int profile_and_level_indication;
2155
    int vo_ver_id;
2156
    
2157
    if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2158
        profile_and_level_indication = s->avctx->profile << 4;
2159
    }else if(s->max_b_frames || s->quarter_sample){
2160
        profile_and_level_indication= 0xF0; // adv simple
2161
    }else{
2162
        profile_and_level_indication= 0x00; // simple
2163
    }
2164

    
2165
    if(s->avctx->level != FF_LEVEL_UNKNOWN){
2166
        profile_and_level_indication |= s->avctx->level;
2167
    }else{
2168
        profile_and_level_indication |= 1; //level 1
2169
    }
2170

    
2171
    if(profile_and_level_indication>>4 == 0xF){
2172
        vo_ver_id= 5;
2173
    }else{
2174
        vo_ver_id= 1;
2175
    }
2176

    
2177
    //FIXME levels
2178

    
2179
    put_bits(&s->pb, 16, 0);
2180
    put_bits(&s->pb, 16, VOS_STARTCODE);
2181

    
2182
    put_bits(&s->pb, 8, profile_and_level_indication);
2183

    
2184
    put_bits(&s->pb, 16, 0);
2185
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2186
    
2187
    put_bits(&s->pb, 1, 1);
2188
        put_bits(&s->pb, 4, vo_ver_id);
2189
        put_bits(&s->pb, 3, 1); //priority
2190
 
2191
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
2192
    
2193
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2194

    
2195
    ff_mpeg4_stuffing(&s->pb);
2196
}
2197

    
2198
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2199
{
2200
    int vo_ver_id;
2201

    
2202
    if(s->max_b_frames || s->quarter_sample){
2203
        vo_ver_id= 5;
2204
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2205
    }else{
2206
        vo_ver_id= 1;
2207
        s->vo_type= SIMPLE_VO_TYPE;
2208
    }
2209

    
2210
    put_bits(&s->pb, 16, 0);
2211
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2212
    put_bits(&s->pb, 16, 0);
2213
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2214

    
2215
    put_bits(&s->pb, 1, 0);                /* random access vol */
2216
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
2217
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
2218
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
2219
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
2220
    
2221
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2222

    
2223
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2224
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2225
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2226
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2227
    }
2228

    
2229
    if(s->low_delay){
2230
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
2231
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
2232
        put_bits(&s->pb, 1, s->low_delay);
2233
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
2234
    }else{
2235
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
2236
    }
2237

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

    
2262
    if(s->mpeg_quant){
2263
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2264
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2265
    }
2266

    
2267
    if (vo_ver_id != 1)
2268
        put_bits(&s->pb, 1, s->quarter_sample);
2269
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
2270
    s->resync_marker= s->rtp_mode;
2271
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2272
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2273
    if(s->data_partitioning){
2274
        put_bits(&s->pb, 1, 0);                /* no rvlc */
2275
    }
2276

    
2277
    if (vo_ver_id != 1){
2278
        put_bits(&s->pb, 1, 0);                /* newpred */
2279
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
2280
    }
2281
    put_bits(&s->pb, 1, 0);                /* scalability */
2282
    
2283
    ff_mpeg4_stuffing(&s->pb);
2284

    
2285
    /* user data */
2286
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2287
        put_bits(&s->pb, 16, 0);
2288
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
2289
        put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2290
    }
2291
}
2292

    
2293
/* write mpeg4 VOP header */
2294
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2295
{
2296
    int time_incr;
2297
    int time_div, time_mod;
2298
    
2299
    if(s->pict_type==I_TYPE){
2300
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2301
            if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2302
                mpeg4_encode_visual_object_header(s);
2303
            if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2304
                mpeg4_encode_vol_header(s, 0, 0);
2305
        }
2306
        mpeg4_encode_gop_header(s);
2307
    }
2308
    
2309
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2310

    
2311
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2312
    
2313
    put_bits(&s->pb, 16, 0);                /* vop header */
2314
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2315
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
2316

    
2317
    time_div= s->time/s->time_increment_resolution;
2318
    time_mod= s->time%s->time_increment_resolution;
2319
    time_incr= time_div - s->last_time_base;
2320
    assert(time_incr >= 0);
2321
    while(time_incr--)
2322
        put_bits(&s->pb, 1, 1);
2323
        
2324
    put_bits(&s->pb, 1, 0);
2325

    
2326
    put_bits(&s->pb, 1, 1);        /* marker */
2327
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
2328
    put_bits(&s->pb, 1, 1);        /* marker */
2329
    put_bits(&s->pb, 1, 1);        /* vop coded */
2330
    if (    s->pict_type == P_TYPE 
2331
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2332
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
2333
    }
2334
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
2335
    if(!s->progressive_sequence){
2336
         put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2337
         put_bits(&s->pb, 1, s->alternate_scan);
2338
    }
2339
    //FIXME sprite stuff
2340

    
2341
    put_bits(&s->pb, 5, s->qscale);
2342

    
2343
    if (s->pict_type != I_TYPE)
2344
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
2345
    if (s->pict_type == B_TYPE)
2346
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
2347
    //    printf("****frame %d\n", picture_number);
2348
}
2349

    
2350
#endif //CONFIG_ENCODERS
2351

    
2352
/**
2353
 * set qscale and update qscale dependant variables.
2354
 */
2355
void ff_set_qscale(MpegEncContext * s, int qscale)
2356
{
2357
    if (qscale < 1)
2358
        qscale = 1;
2359
    else if (qscale > 31)
2360
        qscale = 31;
2361
        
2362
    s->qscale = qscale;
2363
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2364

    
2365
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2366
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2367
}
2368

    
2369
/**
2370
 * predicts the dc.
2371
 * encoding quantized level -> quantized diff
2372
 * decoding quantized diff -> quantized level  
2373
 * @param n block index (0-3 are luma, 4-5 are chroma)
2374
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2375
 */
2376
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2377
{
2378
    int a, b, c, wrap, pred, scale, ret;
2379
    uint16_t *dc_val;
2380

    
2381
    /* find prediction */
2382
    if (n < 4) {
2383
        scale = s->y_dc_scale;
2384
    } else {
2385
        scale = s->c_dc_scale;
2386
    }
2387
    if(IS_3IV1)
2388
        scale= 8;
2389

    
2390
    wrap= s->block_wrap[n];
2391
    dc_val = s->dc_val[0] + s->block_index[n];
2392

    
2393
    /* B C
2394
     * A X 
2395
     */
2396
    a = dc_val[ - 1];
2397
    b = dc_val[ - 1 - wrap];
2398
    c = dc_val[ - wrap];
2399

    
2400
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2401
    if(s->first_slice_line && n!=3){
2402
        if(n!=2) b=c= 1024;
2403
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2404
    }
2405
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2406
        if(n==0 || n==4 || n==5)
2407
            b=1024;
2408
    }
2409

    
2410
    if (abs(a - b) < abs(b - c)) {
2411
        pred = c;
2412
        *dir_ptr = 1; /* top */
2413
    } else {
2414
        pred = a;
2415
        *dir_ptr = 0; /* left */
2416
    }
2417
    /* we assume pred is positive */
2418
    pred = FASTDIV((pred + (scale >> 1)), scale);
2419

    
2420
    if(encoding){
2421
        ret = level - pred;
2422
    }else{
2423
        level += pred;
2424
        ret= level;
2425
        if(s->error_resilience>=3){
2426
            if(level<0){
2427
                av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2428
                return -1;
2429
            }
2430
            if(level*scale > 2048 + scale){
2431
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2432
                return -1;
2433
            }
2434
        }
2435
    }
2436
    level *=scale;
2437
    if(level&(~2047)){
2438
        if(level<0) 
2439
            level=0;
2440
        else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2441
            level=2047;
2442
    }
2443
    dc_val[0]= level;
2444

    
2445
    return ret;
2446
}
2447

    
2448
/**
2449
 * predicts the ac.
2450
 * @param n block index (0-3 are luma, 4-5 are chroma)
2451
 * @param dir the ac prediction direction
2452
 */
2453
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2454
                   int dir)
2455
{
2456
    int i;
2457
    int16_t *ac_val, *ac_val1;
2458
    int8_t * const qscale_table= s->current_picture.qscale_table;
2459

    
2460
    /* find prediction */
2461
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2462
    ac_val1 = ac_val;
2463
    if (s->ac_pred) {
2464
        if (dir == 0) {
2465
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2466
            /* left prediction */
2467
            ac_val -= 16;
2468
            
2469
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2470
                /* same qscale */
2471
                for(i=1;i<8;i++) {
2472
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2473
                }
2474
            }else{
2475
                /* different qscale, we must rescale */
2476
                for(i=1;i<8;i++) {
2477
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2478
                }
2479
            }
2480
        } else {
2481
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2482
            /* top prediction */
2483
            ac_val -= 16 * s->block_wrap[n];
2484

    
2485
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2486
                /* same qscale */
2487
                for(i=1;i<8;i++) {
2488
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2489
                }
2490
            }else{
2491
                /* different qscale, we must rescale */
2492
                for(i=1;i<8;i++) {
2493
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2494
                }
2495
            }
2496
        }
2497
    }
2498
    /* left copy */
2499
    for(i=1;i<8;i++)
2500
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2501

    
2502
    /* top copy */
2503
    for(i=1;i<8;i++)
2504
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2505

    
2506
}
2507

    
2508
#ifdef CONFIG_ENCODERS
2509

    
2510
/**
2511
 * encodes the dc value.
2512
 * @param n block index (0-3 are luma, 4-5 are chroma)
2513
 */
2514
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2515
{
2516
#if 1
2517
//    if(level<-255 || level>255) printf("dc overflow\n");
2518
    level+=256;
2519
    if (n < 4) {
2520
        /* luminance */
2521
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2522
    } else {
2523
        /* chrominance */
2524
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2525
    }
2526
#else
2527
    int size, v;
2528
    /* find number of bits */
2529
    size = 0;
2530
    v = abs(level);
2531
    while (v) {
2532
        v >>= 1;
2533
        size++;
2534
    }
2535

    
2536
    if (n < 4) {
2537
        /* luminance */
2538
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2539
    } else {
2540
        /* chrominance */
2541
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2542
    }
2543

    
2544
    /* encode remaining bits */
2545
    if (size > 0) {
2546
        if (level < 0)
2547
            level = (-level) ^ ((1 << size) - 1);
2548
        put_bits(&s->pb, size, level);
2549
        if (size > 8)
2550
            put_bits(&s->pb, 1, 1);
2551
    }
2552
#endif
2553
}
2554

    
2555
/**
2556
 * encodes a 8x8 block
2557
 * @param n block index (0-3 are luma, 4-5 are chroma)
2558
 */
2559
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2560
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2561
{
2562
    int i, last_non_zero;
2563
#if 0 //variables for the outcommented version
2564
    int code, sign, last;
2565
#endif
2566
    const RLTable *rl;
2567
    uint32_t *bits_tab;
2568
    uint8_t *len_tab;
2569
    const int last_index = s->block_last_index[n];
2570

    
2571
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2572
        /* mpeg4 based DC predictor */
2573
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2574
        if(last_index<1) return;
2575
        i = 1;
2576
        rl = &rl_intra;
2577
        bits_tab= uni_mpeg4_intra_rl_bits;
2578
        len_tab = uni_mpeg4_intra_rl_len;
2579
    } else {
2580
        if(last_index<0) return;
2581
        i = 0;
2582
        rl = &rl_inter;
2583
        bits_tab= uni_mpeg4_inter_rl_bits;
2584
        len_tab = uni_mpeg4_inter_rl_len;
2585
    }
2586

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

    
2675
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2676
                               uint8_t *scan_table)
2677
{
2678
    int i, last_non_zero;
2679
    const RLTable *rl;
2680
    uint8_t *len_tab;
2681
    const int last_index = s->block_last_index[n];
2682
    int len=0;
2683

    
2684
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2685
        /* mpeg4 based DC predictor */
2686
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2687
        if(last_index<1) return len;
2688
        i = 1;
2689
        rl = &rl_intra;
2690
        len_tab = uni_mpeg4_intra_rl_len;
2691
    } else {
2692
        if(last_index<0) return 0;
2693
        i = 0;
2694
        rl = &rl_inter;
2695
        len_tab = uni_mpeg4_inter_rl_len;
2696
    }
2697

    
2698
    /* AC coefs */
2699
    last_non_zero = i - 1;
2700
    for (; i < last_index; i++) {
2701
        int level = block[ scan_table[i] ];
2702
        if (level) {
2703
            int run = i - last_non_zero - 1;
2704
            level+=64;
2705
            if((level&(~127)) == 0){
2706
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2707
                len += len_tab[index];
2708
            }else{ //ESC3
2709
                len += 7+2+1+6+1+12+1;
2710
            }
2711
            last_non_zero = i;
2712
        }
2713
    }
2714
    /*if(i<=last_index)*/{
2715
        int level = block[ scan_table[i] ];
2716
        int run = i - last_non_zero - 1;
2717
        level+=64;
2718
        if((level&(~127)) == 0){
2719
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2720
            len += len_tab[index];
2721
        }else{ //ESC3
2722
            len += 7+2+1+6+1+12+1;
2723
        }
2724
    }
2725
    
2726
    return len;
2727
}
2728

    
2729
#endif
2730

    
2731

    
2732
/***********************************************/
2733
/* decoding */
2734

    
2735
static VLC intra_MCBPC_vlc;
2736
static VLC inter_MCBPC_vlc;
2737
static VLC cbpy_vlc;
2738
static VLC mv_vlc;
2739
static VLC dc_lum, dc_chrom;
2740
static VLC sprite_trajectory;
2741
static VLC mb_type_b_vlc;
2742
static VLC h263_mbtype_b_vlc;
2743
static VLC cbpc_b_vlc;
2744

    
2745
void init_vlc_rl(RLTable *rl)
2746
{
2747
    int i, q;
2748
    
2749
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2750
             &rl->table_vlc[0][1], 4, 2,
2751
             &rl->table_vlc[0][0], 4, 2);
2752

    
2753
    
2754
    for(q=0; q<32; q++){
2755
        int qmul= q*2;
2756
        int qadd= (q-1)|1;
2757
        
2758
        if(q==0){
2759
            qmul=1;
2760
            qadd=0;
2761
        }
2762
        
2763
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2764
        for(i=0; i<rl->vlc.table_size; i++){
2765
            int code= rl->vlc.table[i][0];
2766
            int len = rl->vlc.table[i][1];
2767
            int level, run;
2768
        
2769
            if(len==0){ // illegal code
2770
                run= 66;
2771
                level= MAX_LEVEL;
2772
            }else if(len<0){ //more bits needed
2773
                run= 0;
2774
                level= code;
2775
            }else{
2776
                if(code==rl->n){ //esc
2777
                    run= 66;
2778
                    level= 0;
2779
                }else{
2780
                    run=   rl->table_run  [code] + 1;
2781
                    level= rl->table_level[code] * qmul + qadd;
2782
                    if(code >= rl->last) run+=192;
2783
                }
2784
            }
2785
            rl->rl_vlc[q][i].len= len;
2786
            rl->rl_vlc[q][i].level= level;
2787
            rl->rl_vlc[q][i].run= run;
2788
        }
2789
    }
2790
}
2791

    
2792
/* init vlcs */
2793

    
2794
/* XXX: find a better solution to handle static init */
2795
void h263_decode_init_vlc(MpegEncContext *s)
2796
{
2797
    static int done = 0;
2798

    
2799
    if (!done) {
2800
        done = 1;
2801

    
2802
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, 
2803
                 intra_MCBPC_bits, 1, 1,
2804
                 intra_MCBPC_code, 1, 1);
2805
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, 
2806
                 inter_MCBPC_bits, 1, 1,
2807
                 inter_MCBPC_code, 1, 1);
2808
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2809
                 &cbpy_tab[0][1], 2, 1,
2810
                 &cbpy_tab[0][0], 2, 1);
2811
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2812
                 &mvtab[0][1], 2, 1,
2813
                 &mvtab[0][0], 2, 1);
2814
        init_rl(&rl_inter);
2815
        init_rl(&rl_intra);
2816
        init_rl(&rvlc_rl_inter);
2817
        init_rl(&rvlc_rl_intra);
2818
        init_rl(&rl_intra_aic);
2819
        init_vlc_rl(&rl_inter);
2820
        init_vlc_rl(&rl_intra);
2821
        init_vlc_rl(&rvlc_rl_inter);
2822
        init_vlc_rl(&rvlc_rl_intra);
2823
        init_vlc_rl(&rl_intra_aic);
2824
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2825
                 &DCtab_lum[0][1], 2, 1,
2826
                 &DCtab_lum[0][0], 2, 1);
2827
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2828
                 &DCtab_chrom[0][1], 2, 1,
2829
                 &DCtab_chrom[0][0], 2, 1);
2830
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2831
                 &sprite_trajectory_tab[0][1], 4, 2,
2832
                 &sprite_trajectory_tab[0][0], 4, 2);
2833
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2834
                 &mb_type_b_tab[0][1], 2, 1,
2835
                 &mb_type_b_tab[0][0], 2, 1);
2836
        init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2837
                 &h263_mbtype_b_tab[0][1], 2, 1,
2838
                 &h263_mbtype_b_tab[0][0], 2, 1);
2839
        init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2840
                 &cbpc_b_tab[0][1], 2, 1,
2841
                 &cbpc_b_tab[0][0], 2, 1);
2842
    }
2843
}
2844

    
2845
/**
2846
 * Get the GOB height based on picture height.
2847
 */
2848
int ff_h263_get_gob_height(MpegEncContext *s){
2849
    if (s->height <= 400)
2850
        return 1;
2851
    else if (s->height <= 800)
2852
        return  2;
2853
    else
2854
        return 4;
2855
}
2856

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

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

    
2868
    return mb_pos;
2869
}
2870

    
2871
void ff_h263_encode_mba(MpegEncContext *s)
2872
{
2873
    int i, mb_pos;
2874

    
2875
    for(i=0; i<6; i++){
2876
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2877
    }
2878
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
2879
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
2880
}
2881

    
2882
/**
2883
 * decodes the group of blocks header or slice header.
2884
 * @return <0 if an error occured
2885
 */
2886
static int h263_decode_gob_header(MpegEncContext *s)
2887
{
2888
    unsigned int val, gfid, gob_number;
2889
    int left;
2890
    
2891
    /* Check for GOB Start Code */
2892
    val = show_bits(&s->gb, 16);
2893
    if(val)
2894
        return -1;
2895

    
2896
        /* We have a GBSC probably with GSTUFF */
2897
    skip_bits(&s->gb, 16); /* Drop the zeros */
2898
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2899
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2900
    for(;left>13; left--){
2901
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2902
    }
2903
    if(left<=13) 
2904
        return -1;
2905

    
2906
    if(s->h263_slice_structured){
2907
        if(get_bits1(&s->gb)==0)
2908
            return -1;
2909

    
2910
        ff_h263_decode_mba(s);
2911

    
2912
        if(s->mb_num > 1583)
2913
            if(get_bits1(&s->gb)==0)
2914
                return -1;
2915
        
2916
        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
2917
        if(get_bits1(&s->gb)==0)
2918
            return -1;
2919
        gfid = get_bits(&s->gb, 2); /* GFID */
2920
    }else{
2921
        gob_number = get_bits(&s->gb, 5); /* GN */
2922
        s->mb_x= 0;
2923
        s->mb_y= s->gob_index* gob_number;
2924
        gfid = get_bits(&s->gb, 2); /* GFID */
2925
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2926
    }
2927
        
2928
    if(s->mb_y >= s->mb_height) 
2929
        return -1;
2930

    
2931
    if(s->qscale==0) 
2932
        return -1;
2933

    
2934
    return 0;
2935
}
2936

    
2937
static inline void memsetw(short *tab, int val, int n)
2938
{
2939
    int i;
2940
    for(i=0;i<n;i++)
2941
        tab[i] = val;
2942
}
2943

    
2944
#ifdef CONFIG_ENCODERS
2945

    
2946
void ff_mpeg4_init_partitions(MpegEncContext *s)
2947
{
2948
    uint8_t *start= pbBufPtr(&s->pb);
2949
    uint8_t *end= s->pb.buf_end;
2950
    int size= end - start;
2951
    int pb_size = (((int)start + size/3)&(~3)) - (int)start;
2952
    int tex_size= (size - 2*pb_size)&(~3);
2953
    
2954
    set_put_bits_buffer_size(&s->pb, pb_size);
2955
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
2956
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
2957
}
2958

    
2959
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2960
{
2961
    const int pb2_len   = put_bits_count(&s->pb2   );
2962
    const int tex_pb_len= put_bits_count(&s->tex_pb);
2963
    const int bits= put_bits_count(&s->pb);
2964

    
2965
    if(s->pict_type==I_TYPE){
2966
        put_bits(&s->pb, 19, DC_MARKER);
2967
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2968
        s->i_tex_bits+= tex_pb_len;
2969
    }else{
2970
        put_bits(&s->pb, 17, MOTION_MARKER);
2971
        s->misc_bits+=17 + pb2_len;
2972
        s->mv_bits+= bits - s->last_bits;
2973
        s->p_tex_bits+= tex_pb_len;
2974
    }
2975

    
2976
    flush_put_bits(&s->pb2);
2977
    flush_put_bits(&s->tex_pb);
2978

    
2979
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
2980
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
2981
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
2982
    s->last_bits= put_bits_count(&s->pb);
2983
}
2984

    
2985
#endif //CONFIG_ENCODERS
2986

    
2987
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2988
    switch(s->pict_type){
2989
        case I_TYPE:
2990
            return 16;
2991
        case P_TYPE:
2992
        case S_TYPE:
2993
            return s->f_code+15;
2994
        case B_TYPE:
2995
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2996
        default:
2997
            return -1;
2998
    }
2999
}
3000

    
3001
#ifdef CONFIG_ENCODERS
3002

    
3003
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3004
{
3005
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3006

    
3007
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3008
    put_bits(&s->pb, 1, 1);
3009
    
3010
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3011
    put_bits(&s->pb, s->quant_precision, s->qscale);
3012
    put_bits(&s->pb, 1, 0); /* no HEC */
3013
}
3014

    
3015
#endif //CONFIG_ENCODERS
3016

    
3017
/**
3018
 * check if the next stuff is a resync marker or the end.
3019
 * @return 0 if not
3020
 */
3021
static inline int mpeg4_is_resync(MpegEncContext *s){
3022
    const int bits_count= get_bits_count(&s->gb);
3023
    
3024
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3025
        return 0;
3026
    }
3027

    
3028
    if(bits_count + 8 >= s->gb.size_in_bits){
3029
        int v= show_bits(&s->gb, 8);
3030
        v|= 0x7F >> (7-(bits_count&7));
3031
                
3032
        if(v==0x7F)
3033
            return 1;
3034
    }else{
3035
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3036
            int len;
3037
            GetBitContext gb= s->gb;
3038
        
3039
            skip_bits(&s->gb, 1);
3040
            align_get_bits(&s->gb);
3041
        
3042
            for(len=0; len<32; len++){
3043
                if(get_bits1(&s->gb)) break;
3044
            }
3045

    
3046
            s->gb= gb;
3047

    
3048
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3049
                return 1;
3050
        }
3051
    }
3052
    return 0;
3053
}
3054

    
3055
/**
3056
 * decodes the next video packet.
3057
 * @return <0 if something went wrong
3058
 */
3059
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3060
{
3061
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3062
    int header_extension=0, mb_num, len;
3063
    
3064
    /* is there enough space left for a video packet + header */
3065
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3066

    
3067
    for(len=0; len<32; len++){
3068
        if(get_bits1(&s->gb)) break;
3069
    }
3070

    
3071
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3072
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3073
        return -1;
3074
    }
3075
    
3076
    if(s->shape != RECT_SHAPE){
3077
        header_extension= get_bits1(&s->gb);
3078
        //FIXME more stuff here
3079
    }
3080

    
3081
    mb_num= get_bits(&s->gb, mb_num_bits);
3082
    if(mb_num>=s->mb_num){
3083
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3084
        return -1;
3085
    }
3086
    if(s->pict_type == B_TYPE){
3087
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3088
        if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
3089
    }
3090
    
3091
    s->mb_x= mb_num % s->mb_width;
3092
    s->mb_y= mb_num / s->mb_width;
3093

    
3094
    if(s->shape != BIN_ONLY_SHAPE){
3095
        int qscale= get_bits(&s->gb, s->quant_precision); 
3096
        if(qscale)
3097
            s->chroma_qscale=s->qscale= qscale;
3098
    }
3099

    
3100
    if(s->shape == RECT_SHAPE){
3101
        header_extension= get_bits1(&s->gb);
3102
    }
3103
    if(header_extension){
3104
        int time_increment;
3105
        int time_incr=0;
3106

    
3107
        while (get_bits1(&s->gb) != 0) 
3108
            time_incr++;
3109

    
3110
        check_marker(&s->gb, "before time_increment in video packed header");
3111
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3112
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3113
        
3114
        skip_bits(&s->gb, 2); /* vop coding type */
3115
        //FIXME not rect stuff here
3116

    
3117
        if(s->shape != BIN_ONLY_SHAPE){
3118
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3119
//FIXME dont just ignore everything
3120
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3121
                mpeg4_decode_sprite_trajectory(s, &s->gb);
3122
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3123
            }
3124

    
3125
            //FIXME reduced res stuff here
3126
            
3127
            if (s->pict_type != I_TYPE) {
3128
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
3129
                if(f_code==0){
3130
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3131
                }
3132
            }
3133
            if (s->pict_type == B_TYPE) {
3134
                int b_code = get_bits(&s->gb, 3);
3135
                if(b_code==0){
3136
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3137
                }
3138
            }       
3139
        }
3140
    }
3141
    //FIXME new-pred stuff
3142
    
3143
//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));
3144

    
3145
    return 0;
3146
}
3147

    
3148
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3149
{
3150
    int c_wrap, c_xy, l_wrap, l_xy;
3151

    
3152
    l_wrap= s->b8_stride;
3153
    l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3154
    c_wrap= s->mb_stride;
3155
    c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3156

    
3157
#if 0
3158
    /* clean DC */
3159
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3160
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3161
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3162
#endif
3163

    
3164
    /* clean AC */
3165
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3166
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3167
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3168

    
3169
    /* clean MV */
3170
    // we cant clear the MVs as they might be needed by a b frame
3171
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3172
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3173
    s->last_mv[0][0][0]=
3174
    s->last_mv[0][0][1]=
3175
    s->last_mv[1][0][0]=
3176
    s->last_mv[1][0][1]= 0;
3177
}
3178

    
3179
/**
3180
 * decodes the group of blocks / video packet header.
3181
 * @return <0 if no resync found
3182
 */
3183
int ff_h263_resync(MpegEncContext *s){
3184
    int left, ret;
3185
    
3186
    if(s->codec_id==CODEC_ID_MPEG4){
3187
        skip_bits1(&s->gb);
3188
        align_get_bits(&s->gb);
3189
    }
3190

    
3191
    if(show_bits(&s->gb, 16)==0){
3192
        if(s->codec_id==CODEC_ID_MPEG4)
3193
            ret= mpeg4_decode_video_packet_header(s);
3194
        else
3195
            ret= h263_decode_gob_header(s);
3196
        if(ret>=0)
3197
            return 0;
3198
    }
3199
    //ok, its not where its supposed to be ...
3200
    s->gb= s->last_resync_gb;
3201
    align_get_bits(&s->gb);
3202
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3203
    
3204
    for(;left>16+1+5+5; left-=8){ 
3205
        if(show_bits(&s->gb, 16)==0){
3206
            GetBitContext bak= s->gb;
3207

    
3208
            if(s->codec_id==CODEC_ID_MPEG4)
3209
                ret= mpeg4_decode_video_packet_header(s);
3210
            else
3211
                ret= h263_decode_gob_header(s);
3212
            if(ret>=0)
3213
                return 0;
3214

    
3215
            s->gb= bak;
3216
        }
3217
        skip_bits(&s->gb, 8);
3218
    }
3219
    
3220
    return -1;
3221
}
3222

    
3223
/**
3224
 * gets the average motion vector for a GMC MB.
3225
 * @param n either 0 for the x component or 1 for y
3226
 * @returns the average MV for a GMC MB
3227
 */
3228
static inline int get_amv(MpegEncContext *s, int n){
3229
    int x, y, mb_v, sum, dx, dy, shift;
3230
    int len = 1 << (s->f_code + 4);
3231
    const int a= s->sprite_warping_accuracy;
3232
    
3233
    if(s->workaround_bugs & FF_BUG_AMV)
3234
        len >>= s->quarter_sample;
3235

    
3236
    if(s->real_sprite_warping_points==1){
3237
        if(s->divx_version==500 && s->divx_build==413)
3238
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3239
        else
3240
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3241
    }else{
3242
        dx= s->sprite_delta[n][0];
3243
        dy= s->sprite_delta[n][1];
3244
        shift= s->sprite_shift[0];
3245
        if(n) dy -= 1<<(shift + a + 1);
3246
        else  dx -= 1<<(shift + a + 1);
3247
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3248

    
3249
        sum=0;
3250
        for(y=0; y<16; y++){
3251
            int v;
3252
        
3253
            v= mb_v + dy*y;
3254
            //XXX FIXME optimize
3255
            for(x=0; x<16; x++){
3256
                sum+= v>>shift;
3257
                v+= dx;
3258
            }
3259
        }
3260
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3261
    }
3262

    
3263
    if      (sum < -len) sum= -len;
3264
    else if (sum >= len) sum= len-1;
3265

    
3266
    return sum;
3267
}
3268

    
3269
/**
3270
 * decodes first partition.
3271
 * @return number of MBs decoded or <0 if an error occured
3272
 */
3273
static int mpeg4_decode_partition_a(MpegEncContext *s){
3274
    int mb_num;
3275
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3276
    
3277
    /* decode first partition */
3278
    mb_num=0;
3279
    s->first_slice_line=1;
3280
    for(; s->mb_y<s->mb_height; s->mb_y++){
3281
        ff_init_block_index(s);
3282
        for(; s->mb_x<s->mb_width; s->mb_x++){
3283
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3284
            int cbpc;
3285
            int dir=0;
3286
            
3287
            mb_num++;
3288
            ff_update_block_index(s);
3289
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3290
                s->first_slice_line=0;
3291
            
3292
            if(s->pict_type==I_TYPE){
3293
                int i;
3294

    
3295
                do{
3296
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
3297
                        return mb_num-1;
3298
                    }
3299

    
3300
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3301
                    if (cbpc < 0){
3302
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3303
                        return -1;
3304
                    }
3305
                }while(cbpc == 8);
3306
                
3307
                s->cbp_table[xy]= cbpc & 3;
3308
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3309
                s->mb_intra = 1;
3310

    
3311
                if(cbpc & 4) {
3312
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3313
                }
3314
                s->current_picture.qscale_table[xy]= s->qscale;
3315

    
3316
                s->mbintra_table[xy]= 1;
3317
                for(i=0; i<6; i++){
3318
                    int dc_pred_dir;
3319
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3320
                    if(dc < 0){
3321
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3322
                        return -1;
3323
                    }
3324
                    dir<<=1;
3325
                    if(dc_pred_dir) dir|=1;
3326
                }
3327
                s->pred_dir_table[xy]= dir;
3328
            }else{ /* P/S_TYPE */
3329
                int mx, my, pred_x, pred_y, bits;
3330
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3331
                const int stride= s->b8_stride*2;
3332

    
3333
try_again:
3334
                bits= show_bits(&s->gb, 17);
3335
                if(bits==MOTION_MARKER){
3336
                    return mb_num-1;
3337
                }
3338
                skip_bits1(&s->gb);
3339
                if(bits&0x10000){
3340
                    /* skip mb */
3341
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3342
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3343
                        mx= get_amv(s, 0);
3344
                        my= get_amv(s, 1);
3345
                    }else{
3346
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3347
                        mx=my=0;
3348
                    }
3349
                    mot_val[0       ]= mot_val[2       ]=
3350
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3351
                    mot_val[1       ]= mot_val[3       ]=
3352
                    mot_val[1+stride]= mot_val[3+stride]= my;
3353

    
3354
                    if(s->mbintra_table[xy])
3355
                        ff_clean_intra_table_entries(s);
3356
                    continue;
3357
                }
3358

    
3359
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3360
                if (cbpc < 0){
3361
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3362
                    return -1;
3363
                }
3364
                if(cbpc == 20)
3365
                    goto try_again;
3366

    
3367
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3368
    
3369
                s->mb_intra = ((cbpc & 4) != 0);
3370
        
3371
                if(s->mb_intra){
3372
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3373
                    s->mbintra_table[xy]= 1;
3374
                    mot_val[0       ]= mot_val[2       ]= 
3375
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3376
                    mot_val[1       ]= mot_val[3       ]=
3377
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3378
                }else{
3379
                    if(s->mbintra_table[xy])
3380
                        ff_clean_intra_table_entries(s);
3381

    
3382
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3383
                        s->mcsel= get_bits1(&s->gb);
3384
                    else s->mcsel= 0;
3385
        
3386
                    if ((cbpc & 16) == 0) {
3387
                        /* 16x16 motion prediction */
3388

    
3389
                        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3390
                        if(!s->mcsel){
3391
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3392
                            if (mx >= 0xffff)
3393
                                return -1;
3394

    
3395
                            my = h263_decode_motion(s, pred_y, s->f_code);
3396
                            if (my >= 0xffff)
3397
                                return -1;
3398
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3399
                        } else {
3400
                            mx = get_amv(s, 0);
3401
                            my = get_amv(s, 1);
3402
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3403
                        }
3404

    
3405
                        mot_val[0       ]= mot_val[2       ] =
3406
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3407
                        mot_val[1       ]= mot_val[3       ]=
3408
                        mot_val[1+stride]= mot_val[3+stride]= my;
3409
                    } else {
3410
                        int i;
3411
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3412
                        for(i=0;i<4;i++) {
3413
                            int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3414
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3415
                            if (mx >= 0xffff)
3416
                                return -1;
3417
                
3418
                            my = h263_decode_motion(s, pred_y, s->f_code);
3419
                            if (my >= 0xffff)
3420
                                return -1;
3421
                            mot_val[0] = mx;
3422
                            mot_val[1] = my;
3423
                        }
3424
                    }
3425
                }
3426
            }
3427
        }
3428
        s->mb_x= 0;
3429
    }
3430

    
3431
    return mb_num;
3432
}
3433

    
3434
/**
3435
 * decode second partition.
3436
 * @return <0 if an error occured
3437
 */
3438
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3439
    int mb_num=0;
3440
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3441

    
3442
    s->mb_x= s->resync_mb_x;
3443
    s->first_slice_line=1;
3444
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3445
        ff_init_block_index(s);
3446
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3447
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3448

    
3449
            mb_num++;
3450
            ff_update_block_index(s);
3451
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3452
                s->first_slice_line=0;
3453
            
3454
            if(s->pict_type==I_TYPE){
3455
                int ac_pred= get_bits1(&s->gb);
3456
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3457
                if(cbpy<0){
3458
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3459
                    return -1;
3460
                }
3461
                
3462
                s->cbp_table[xy]|= cbpy<<2;
3463
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3464
            }else{ /* P || S_TYPE */
3465
                if(IS_INTRA(s->current_picture.mb_type[xy])){          
3466
                    int dir=0,i;
3467
                    int ac_pred = get_bits1(&s->gb);
3468
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3469

    
3470
                    if(cbpy<0){
3471
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3472
                        return -1;
3473
                    }
3474
                    
3475
                    if(s->cbp_table[xy] & 8) {
3476
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3477
                    }
3478
                    s->current_picture.qscale_table[xy]= s->qscale;
3479

    
3480
                    for(i=0; i<6; i++){
3481
                        int dc_pred_dir;
3482
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3483
                        if(dc < 0){
3484
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3485
                            return -1;
3486
                        }
3487
                        dir<<=1;
3488
                        if(dc_pred_dir) dir|=1;
3489
                    }
3490
                    s->cbp_table[xy]&= 3; //remove dquant
3491
                    s->cbp_table[xy]|= cbpy<<2;
3492
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3493
                    s->pred_dir_table[xy]= dir;
3494
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3495
                    s->current_picture.qscale_table[xy]= s->qscale;
3496
                    s->cbp_table[xy]= 0;
3497
                }else{
3498
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3499

    
3500
                    if(cbpy<0){
3501
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3502
                        return -1;
3503
                    }
3504
                    
3505
                    if(s->cbp_table[xy] & 8) {
3506
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3507
                    }
3508
                    s->current_picture.qscale_table[xy]= s->qscale;
3509

    
3510
                    s->cbp_table[xy]&= 3; //remove dquant
3511
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3512
                }
3513
            }
3514
        }
3515
        if(mb_num >= mb_count) return 0;
3516
        s->mb_x= 0;
3517
    }
3518
    return 0;
3519
}
3520

    
3521
/**
3522
 * decodes the first & second partition
3523
 * @return <0 if error (and sets error type in the error_status_table)
3524
 */
3525
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3526
{
3527
    int mb_num;
3528
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3529
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3530
    
3531
    mb_num= mpeg4_decode_partition_a(s);    
3532
    if(mb_num<0){
3533
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3534
        return -1;
3535
    }
3536
    
3537
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3538
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3539
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3540
        return -1;
3541
    }
3542

    
3543
    s->mb_num_left= mb_num;
3544
        
3545
    if(s->pict_type==I_TYPE){
3546
        while(show_bits(&s->gb, 9) == 1)
3547
            skip_bits(&s->gb, 9);
3548
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3549
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3550
            return -1;
3551
        }
3552
    }else{
3553
        while(show_bits(&s->gb, 10) == 1)
3554
            skip_bits(&s->gb, 10);
3555
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3556
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3557
            return -1;
3558
        }
3559
    }
3560
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3561
    
3562
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3563
        if(s->pict_type==P_TYPE)
3564
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3565
        return -1;
3566
    }else{
3567
        if(s->pict_type==P_TYPE)
3568
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3569
    }
3570

    
3571
    return 0;        
3572
}
3573

    
3574
/**
3575
 * decode partition C of one MB.
3576
 * @return <0 if an error occured
3577
 */
3578
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3579
{
3580
    int cbp, mb_type;
3581
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3582

    
3583
    mb_type= s->current_picture.mb_type[xy];
3584
    cbp = s->cbp_table[xy];
3585

    
3586
    if(s->current_picture.qscale_table[xy] != s->qscale){
3587
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3588
    }
3589
    
3590
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3591
        int i;
3592
        for(i=0; i<4; i++){
3593
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3594
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3595
        }
3596
        s->mb_intra = IS_INTRA(mb_type);
3597

    
3598
        if (IS_SKIP(mb_type)) {
3599
            /* skip mb */
3600
            for(i=0;i<6;i++)
3601
                s->block_last_index[i] = -1;
3602
            s->mv_dir = MV_DIR_FORWARD;
3603
            s->mv_type = MV_TYPE_16X16;
3604
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3605
                s->mcsel=1;
3606
                s->mb_skiped = 0;
3607
            }else{
3608
                s->mcsel=0;
3609
                s->mb_skiped = 1;
3610
            }
3611
        }else if(s->mb_intra){
3612
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3613
        }else if(!s->mb_intra){
3614
//            s->mcsel= 0; //FIXME do we need to init that
3615
            
3616
            s->mv_dir = MV_DIR_FORWARD;
3617
            if (IS_8X8(mb_type)) {
3618
                s->mv_type = MV_TYPE_8X8;
3619
            } else {
3620
                s->mv_type = MV_TYPE_16X16;
3621
            }
3622
        }
3623
    } else { /* I-Frame */
3624
        s->mb_intra = 1;
3625
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3626
    }
3627

    
3628
    if (!IS_SKIP(mb_type)) {
3629
        int i;
3630
        /* decode each block */
3631
        for (i = 0; i < 6; i++) {
3632
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3633
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3634
                return -1;
3635
            }
3636
            cbp+=cbp;
3637
        }
3638
    }
3639

    
3640
    /* per-MB end of slice check */
3641

    
3642
    if(--s->mb_num_left <= 0){
3643
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3644
        if(mpeg4_is_resync(s))
3645
            return SLICE_END;
3646
        else
3647
            return SLICE_NOEND;     
3648
    }else{
3649
        if(mpeg4_is_resync(s)){
3650
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3651
            if(s->cbp_table[xy+delta])
3652
                return SLICE_END;
3653
        }
3654
        return SLICE_OK;
3655
    }
3656
}
3657

    
3658
/**
3659
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3660
 */
3661
static void preview_obmc(MpegEncContext *s){
3662
    GetBitContext gb= s->gb;
3663
    
3664
    int cbpc, i, pred_x, pred_y, mx, my;
3665
    int16_t *mot_val;
3666
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3667
    const int stride= s->b8_stride*2;
3668
    
3669
    for(i=0; i<4; i++)
3670
        s->block_index[i]+= 2;
3671
    for(i=4; i<6; i++)
3672
        s->block_index[i]+= 1;
3673
    s->mb_x++;
3674
    
3675
    assert(s->pict_type == P_TYPE);
3676

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

    
3750
    s->gb= gb;
3751
}
3752

    
3753
static void h263_decode_dquant(MpegEncContext *s){
3754
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3755

    
3756
    if(s->modified_quant){
3757
        if(get_bits1(&s->gb))
3758
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3759
        else
3760
            s->qscale= get_bits(&s->gb, 5);
3761
    }else
3762
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3763
    ff_set_qscale(s, s->qscale);
3764
}
3765

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

    
3836
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3837
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3838
        } else {
3839
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3840
            s->mv_type = MV_TYPE_8X8;
3841
            for(i=0;i<4;i++) {
3842
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3843
                if (s->umvplus)
3844
                  mx = h263p_decode_umotion(s, pred_x);
3845
                else
3846
                  mx = h263_decode_motion(s, pred_x, 1);
3847
                if (mx >= 0xffff)
3848
                    return -1;
3849
                
3850
                if (s->umvplus)
3851
                  my = h263p_decode_umotion(s, pred_y);
3852
                else    
3853
                  my = h263_decode_motion(s, pred_y, 1);
3854
                if (my >= 0xffff)
3855
                    return -1;
3856
                s->mv[0][i][0] = mx;
3857
                s->mv[0][i][1] = my;
3858
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3859
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3860
                mot_val[0] = mx;
3861
                mot_val[1] = my;
3862
            }
3863
        }
3864

    
3865
        /* decode each block */
3866
        for (i = 0; i < 6; i++) {
3867
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3868
                return -1;
3869
            cbp+=cbp;
3870
        }
3871

    
3872
        if(s->obmc){
3873
            if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
3874
                preview_obmc(s);
3875
        }
3876
    } else if(s->pict_type==B_TYPE) {
3877
        int mb_type;
3878
        const int stride= s->b8_stride;
3879
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
3880
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
3881
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3882

    
3883
        //FIXME ugly 
3884
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= 
3885
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= 
3886
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= 
3887
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
3888

    
3889
        do{
3890
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
3891
            if (mb_type < 0){
3892
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
3893
                return -1;
3894
            }
3895

    
3896
            mb_type= h263_mb_type_b_map[ mb_type ];
3897
        }while(!mb_type);
3898

    
3899
        s->mb_intra = IS_INTRA(mb_type);
3900
        if(HAS_CBP(mb_type)){
3901
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
3902
            if(s->mb_intra){
3903
                dquant = IS_QUANT(mb_type);
3904
                goto intra;
3905
            }
3906

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

    
3909
            if (cbpy < 0){
3910
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3911
                return -1;
3912
            }
3913
        
3914
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3915
                cbpy ^= 0xF;
3916
        
3917
            cbp = (cbpc & 3) | (cbpy << 2);
3918
        }else
3919
            cbp=0;
3920
            
3921
        assert(!s->mb_intra);
3922

    
3923
        if(IS_QUANT(mb_type)){
3924
            h263_decode_dquant(s);
3925
        }
3926

    
3927
        if(IS_DIRECT(mb_type)){
3928
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3929
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
3930
        }else{
3931
            s->mv_dir = 0;
3932
            s->mv_type= MV_TYPE_16X16;
3933
//FIXME UMV
3934

    
3935
            if(USES_LIST(mb_type, 0)){
3936
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
3937
                s->mv_dir = MV_DIR_FORWARD;
3938

    
3939
                mx = h263_decode_motion(s, mx, 1);
3940
                my = h263_decode_motion(s, my, 1);
3941
                
3942
                s->mv[0][0][0] = mx;
3943
                s->mv[0][0][1] = my;
3944
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3945
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3946
            }
3947
    
3948
            if(USES_LIST(mb_type, 1)){
3949
                int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
3950
                s->mv_dir |= MV_DIR_BACKWARD;
3951
                
3952
                mx = h263_decode_motion(s, mx, 1);
3953
                my = h263_decode_motion(s, my, 1);
3954

    
3955
                s->mv[1][0][0] = mx;
3956
                s->mv[1][0][1] = my;
3957
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3958
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3959
            }
3960
        }
3961
          
3962
        s->current_picture.mb_type[xy]= mb_type;
3963

    
3964
        /* decode each block */
3965
        for (i = 0; i < 6; i++) {
3966
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3967
                return -1;
3968
            cbp+=cbp;
3969
        }
3970
    } else { /* I-Frame */
3971
        do{
3972
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3973
            if (cbpc < 0){
3974
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3975
                return -1;
3976
            }
3977
        }while(cbpc == 8);
3978

    
3979
        dquant = cbpc & 4;
3980
        s->mb_intra = 1;
3981
intra:
3982
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3983
        if (s->h263_aic) {
3984
            s->ac_pred = get_bits1(&s->gb);
3985
            if(s->ac_pred){
3986
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3987
            
3988
                s->h263_aic_dir = get_bits1(&s->gb);
3989
            }
3990
        }else
3991
            s->ac_pred = 0;
3992
        
3993
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3994
        if(cbpy<0){
3995
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3996
            return -1;
3997
        }
3998
        cbp = (cbpc & 3) | (cbpy << 2);
3999
        if (dquant) {
4000
            h263_decode_dquant(s);
4001
        }
4002

    
4003
        /* decode each block */
4004
        for (i = 0; i < 6; i++) {
4005
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4006
                return -1;
4007
            cbp+=cbp;
4008
        }
4009
    }
4010
end:
4011

    
4012
        /* per-MB end of slice check */
4013
    {
4014
        int v= show_bits(&s->gb, 16);
4015
    
4016
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4017
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4018
        }
4019

    
4020
        if(v==0)
4021
            return SLICE_END;
4022
    }
4023

    
4024
    return SLICE_OK;     
4025
}
4026

    
4027
int ff_mpeg4_decode_mb(MpegEncContext *s,
4028
                      DCTELEM block[6][64])
4029
{
4030
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4031
    int16_t *mot_val;
4032
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4033
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4034
    
4035
    assert(s->h263_pred);
4036
    
4037
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4038
        do{
4039
            if (get_bits1(&s->gb)) {
4040
                /* skip mb */
4041
                s->mb_intra = 0;
4042
                for(i=0;i<6;i++)
4043
                    s->block_last_index[i] = -1;
4044
                s->mv_dir = MV_DIR_FORWARD;
4045
                s->mv_type = MV_TYPE_16X16;
4046
                if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4047
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4048
                    s->mcsel=1;
4049
                    s->mv[0][0][0]= get_amv(s, 0);
4050
                    s->mv[0][0][1]= get_amv(s, 1);
4051

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

    
4101
                s->field_select[0][0]= get_bits1(&s->gb);
4102
                s->field_select[0][1]= get_bits1(&s->gb);
4103

    
4104
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4105
                
4106
                for(i=0; i<2; i++){
4107
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4108
                    if (mx >= 0xffff)
4109
                        return -1;
4110
            
4111
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4112
                    if (my >= 0xffff)
4113
                        return -1;
4114

    
4115
                    s->mv[0][i][0] = mx;
4116
                    s->mv[0][i][1] = my;
4117
                }
4118
            }else{
4119
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
4120
                /* 16x16 motion prediction */
4121
                s->mv_type = MV_TYPE_16X16;
4122
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4123
                mx = h263_decode_motion(s, pred_x, s->f_code);
4124
            
4125
                if (mx >= 0xffff)
4126
                    return -1;
4127
            
4128
                my = h263_decode_motion(s, pred_y, s->f_code);
4129
            
4130
                if (my >= 0xffff)
4131
                    return -1;
4132
                s->mv[0][0][0] = mx;
4133
                s->mv[0][0][1] = my;
4134
            }
4135
        } else {
4136
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
4137
            s->mv_type = MV_TYPE_8X8;
4138
            for(i=0;i<4;i++) {
4139
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4140
                mx = h263_decode_motion(s, pred_x, s->f_code);
4141
                if (mx >= 0xffff)
4142
                    return -1;
4143
                
4144
                my = h263_decode_motion(s, pred_y, s->f_code);
4145
                if (my >= 0xffff)
4146
                    return -1;
4147
                s->mv[0][i][0] = mx;
4148
                s->mv[0][i][1] = my;
4149
                mot_val[0] = mx;
4150
                mot_val[1] = my;
4151
            }
4152
        }
4153
    } else if(s->pict_type==B_TYPE) {
4154
        int modb1; // first bit of modb
4155
        int modb2; // second bit of modb
4156
        int mb_type;
4157

    
4158
        s->mb_intra = 0; //B-frames never contain intra blocks
4159
        s->mcsel=0;      //     ...               true gmc blocks
4160

    
4161
        if(s->mb_x==0){
4162
            for(i=0; i<2; i++){
4163
                s->last_mv[i][0][0]= 
4164
                s->last_mv[i][0][1]= 
4165
                s->last_mv[i][1][0]= 
4166
                s->last_mv[i][1][1]= 0;
4167
            }
4168
        }
4169

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

    
4173
        if(s->mb_skiped){
4174
                /* skip mb */
4175
            for(i=0;i<6;i++)
4176
                s->block_last_index[i] = -1;
4177

    
4178
            s->mv_dir = MV_DIR_FORWARD;
4179
            s->mv_type = MV_TYPE_16X16;
4180
            s->mv[0][0][0] = 0;
4181
            s->mv[0][0][1] = 0;
4182
            s->mv[1][0][0] = 0;
4183
            s->mv[1][0][1] = 0;
4184
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 
4185
            goto end;
4186
        }
4187

    
4188
        modb1= get_bits1(&s->gb); 
4189
        if(modb1){
4190
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4191
            cbp=0;
4192
        }else{
4193
            modb2= get_bits1(&s->gb);
4194
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4195
            if(mb_type<0){
4196
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4197
                return -1;
4198
            }
4199
            mb_type= mb_type_b_map[ mb_type ];
4200
            if(modb2) cbp= 0;
4201
            else      cbp= get_bits(&s->gb, 6);
4202

    
4203
            if ((!IS_DIRECT(mb_type)) && cbp) {
4204
                if(get_bits1(&s->gb)){
4205
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4206
                }
4207
            }
4208

    
4209
            if(!s->progressive_sequence){
4210
                if(cbp)
4211
                    s->interlaced_dct= get_bits1(&s->gb);
4212

    
4213
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4214
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4215
                    mb_type &= ~MB_TYPE_16x16;
4216

    
4217
                    if(USES_LIST(mb_type, 0)){
4218
                        s->field_select[0][0]= get_bits1(&s->gb);
4219
                        s->field_select[0][1]= get_bits1(&s->gb);
4220
                    }
4221
                    if(USES_LIST(mb_type, 1)){
4222
                        s->field_select[1][0]= get_bits1(&s->gb);
4223
                        s->field_select[1][1]= get_bits1(&s->gb);
4224
                    }
4225
                }
4226
            }
4227

    
4228
            s->mv_dir = 0;
4229
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4230
                s->mv_type= MV_TYPE_16X16;
4231

    
4232
                if(USES_LIST(mb_type, 0)){
4233
                    s->mv_dir = MV_DIR_FORWARD;
4234

    
4235
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4236
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4237
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4238
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4239
                }
4240
    
4241
                if(USES_LIST(mb_type, 1)){
4242
                    s->mv_dir |= MV_DIR_BACKWARD;
4243

    
4244
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4245
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4246
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4247
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4248
                }
4249
            }else if(!IS_DIRECT(mb_type)){
4250
                s->mv_type= MV_TYPE_FIELD;
4251

    
4252
                if(USES_LIST(mb_type, 0)){
4253
                    s->mv_dir = MV_DIR_FORWARD;
4254
                
4255
                    for(i=0; i<2; i++){
4256
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4257
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4258
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4259
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4260
                    }
4261
                }
4262
    
4263
                if(USES_LIST(mb_type, 1)){
4264
                    s->mv_dir |= MV_DIR_BACKWARD;
4265

    
4266
                    for(i=0; i<2; i++){
4267
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4268
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4269
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4270
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4271
                    }
4272
                }
4273
            }
4274
        }
4275
          
4276
        if(IS_DIRECT(mb_type)){
4277
            if(IS_SKIP(mb_type))
4278
                mx=my=0;
4279
            else{
4280
                mx = h263_decode_motion(s, 0, 1);
4281
                my = h263_decode_motion(s, 0, 1);
4282
            }
4283
 
4284
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4285
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4286
        }
4287
        s->current_picture.mb_type[xy]= mb_type;
4288
    } else { /* I-Frame */
4289
        do{
4290
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4291
            if (cbpc < 0){
4292
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4293
                return -1;
4294
            }
4295
        }while(cbpc == 8);
4296

    
4297
        dquant = cbpc & 4;
4298
        s->mb_intra = 1;
4299
intra:
4300
        s->ac_pred = get_bits1(&s->gb);
4301
        if(s->ac_pred)
4302
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4303
        else
4304
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4305
        
4306
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4307
        if(cbpy<0){
4308
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4309
            return -1;
4310
        }
4311
        cbp = (cbpc & 3) | (cbpy << 2);
4312
        if (dquant) {
4313
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4314
        }
4315
        
4316
        if(!s->progressive_sequence)
4317
            s->interlaced_dct= get_bits1(&s->gb);
4318

    
4319
        /* decode each block */
4320
        for (i = 0; i < 6; i++) {
4321
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4322
                return -1;
4323
            cbp+=cbp;
4324
        }
4325
        goto end;
4326
    }
4327

    
4328
    /* decode each block */
4329
    for (i = 0; i < 6; i++) {
4330
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4331
            return -1;
4332
        cbp+=cbp;
4333
    }
4334
end:
4335

    
4336
        /* per-MB end of slice check */
4337
    if(s->codec_id==CODEC_ID_MPEG4){
4338
        if(mpeg4_is_resync(s)){
4339
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4340
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4341
                return SLICE_OK;
4342
            return SLICE_END;
4343
        }
4344
    }
4345

    
4346
    return SLICE_OK;     
4347
}
4348

    
4349
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4350
{
4351
    int code, val, sign, shift, l;
4352
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4353

    
4354
    if (code == 0)
4355
        return pred;
4356
    if (code < 0)
4357
        return 0xffff;
4358

    
4359
    sign = get_bits1(&s->gb);
4360
    shift = f_code - 1;
4361
    val = code;
4362
    if (shift) {
4363
        val = (val - 1) << shift;
4364
        val |= get_bits(&s->gb, shift);
4365
        val++;
4366
    }
4367
    if (sign)
4368
        val = -val;
4369
    val += pred;
4370

    
4371
    /* modulo decoding */
4372
    if (!s->h263_long_vectors) {
4373
        l = INT_BIT - 5 - f_code;
4374
        val = (val<<l)>>l;
4375
    } else {
4376
        /* horrible h263 long vector mode */
4377
        if (pred < -31 && val < -63)
4378
            val += 64;
4379
        if (pred > 32 && val > 63)
4380
            val -= 64;
4381
        
4382
    }
4383
    return val;
4384
}
4385

    
4386
/* Decodes RVLC of H.263+ UMV */
4387
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4388
{
4389
   int code = 0, sign;
4390
   
4391
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4392
      return pred;
4393
   
4394
   code = 2 + get_bits1(&s->gb);
4395
   
4396
   while (get_bits1(&s->gb))
4397
   {
4398
      code <<= 1;
4399
      code += get_bits1(&s->gb);
4400
   }
4401
   sign = code & 1;
4402
   code >>= 1;
4403
   
4404
   code = (sign) ? (pred - code) : (pred + code);
4405
#ifdef DEBUG
4406
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
4407
#endif
4408
   return code;   
4409

    
4410
}
4411

    
4412
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4413
                             int n, int coded)
4414
{
4415
    int code, level, i, j, last, run;
4416
    RLTable *rl = &rl_inter;
4417
    const uint8_t *scan_table;
4418
    GetBitContext gb= s->gb;
4419

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

    
4540
/**
4541
 * decodes the dc value.
4542
 * @param n block index (0-3 are luma, 4-5 are chroma)
4543
 * @param dir_ptr the prediction direction will be stored here
4544
 * @return the quantized dc
4545
 */
4546
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4547
{
4548
    int level, code;
4549

    
4550
    if (n < 4) 
4551
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4552
    else 
4553
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4554
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4555
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4556
        return -1;
4557
    }
4558
    if (code == 0) {
4559
        level = 0;
4560
    } else {
4561
        if(IS_3IV1){
4562
            if(code==1)
4563
                level= 2*get_bits1(&s->gb)-1;
4564
            else{
4565
                if(get_bits1(&s->gb))
4566
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4567
                else
4568
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4569
            }
4570
        }else{
4571
            level = get_xbits(&s->gb, code);
4572
        }
4573

    
4574
        if (code > 8){
4575
            if(get_bits1(&s->gb)==0){ /* marker */
4576
                if(s->error_resilience>=2){
4577
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4578
                    return -1;
4579
                }
4580
            }
4581
        }
4582
    }
4583

    
4584
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4585
}
4586

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

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

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

    
4700
                level=  level * qmul + qadd;
4701
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4702
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4703

    
4704
                i+= run + 1;
4705
                if(last) i+=192;
4706
          }else{
4707
            int cache;
4708
            cache= GET_CACHE(re, &s->gb);
4709

    
4710
            if(IS_3IV1) 
4711
                cache ^= 0xC0000000;
4712

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

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

    
4730
                        level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4731

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

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

    
4765
                    if((unsigned)(level + 2048) > 4095){
4766
                        if(s->error_resilience > FF_ER_COMPLIANT){
4767
                            if(level > 2560 || level<-2560){
4768
                                av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4769
                                return -1;
4770
                            }
4771
                        }
4772
                        level= level<0