Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 9ebb8e11

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
        assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2116
    }else{
2117
        s->last_time_base= s->time_base;
2118
        s->time_base= time_div;
2119
        s->pp_time= s->time - s->last_non_b_time;
2120
        s->last_non_b_time= s->time;
2121
        assert(s->pp_time > 0);
2122
    }
2123
}
2124

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

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

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

    
2152
    ff_mpeg4_stuffing(&s->pb);
2153
}
2154

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

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

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

    
2179
    //FIXME levels
2180

    
2181
    put_bits(&s->pb, 16, 0);
2182
    put_bits(&s->pb, 16, VOS_STARTCODE);
2183

    
2184
    put_bits(&s->pb, 8, profile_and_level_indication);
2185

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

    
2197
    ff_mpeg4_stuffing(&s->pb);
2198
}
2199

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2339
    put_bits(&s->pb, 5, s->qscale);
2340

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

    
2348
#endif //CONFIG_ENCODERS
2349

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

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

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

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

    
2388
    wrap= s->block_wrap[n];
2389
    dc_val = s->dc_val[0] + s->block_index[n];
2390

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

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

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

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

    
2443
    return ret;
2444
}
2445

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

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

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

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

    
2504
}
2505

    
2506
#ifdef CONFIG_ENCODERS
2507

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

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

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

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

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

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

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

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

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

    
2727
#endif
2728

    
2729

    
2730
/***********************************************/
2731
/* decoding */
2732

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

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

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

    
2790
/* init vlcs */
2791

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

    
2797
    if (!done) {
2798
        done = 1;
2799

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

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

    
2855
int ff_h263_decode_mba(MpegEncContext *s)
2856
{
2857
    int i, mb_pos;
2858

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

    
2866
    return mb_pos;
2867
}
2868

    
2869
void ff_h263_encode_mba(MpegEncContext *s)
2870
{
2871
    int i, mb_pos;
2872

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

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

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

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

    
2908
        ff_h263_decode_mba(s);
2909

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

    
2929
    if(s->qscale==0) 
2930
        return -1;
2931

    
2932
    return 0;
2933
}
2934

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

    
2942
#ifdef CONFIG_ENCODERS
2943

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

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

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

    
2974
    flush_put_bits(&s->pb2);
2975
    flush_put_bits(&s->tex_pb);
2976

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

    
2983
#endif //CONFIG_ENCODERS
2984

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

    
2999
#ifdef CONFIG_ENCODERS
3000

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

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

    
3013
#endif //CONFIG_ENCODERS
3014

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

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

    
3044
            s->gb= gb;
3045

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

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

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

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

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

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

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

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

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

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

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

    
3143
    return 0;
3144
}
3145

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

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

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

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

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

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

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

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

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

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

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

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

    
3261
    if      (sum < -len) sum= -len;
3262
    else if (sum >= len) sum= len-1;
3263

    
3264
    return sum;
3265
}
3266

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3429
    return mb_num;
3430
}
3431

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

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

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

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

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

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

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

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

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

    
3569
    return 0;        
3570
}
3571

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

    
3581
    mb_type= s->current_picture.mb_type[xy];
3582
    cbp = s->cbp_table[xy];
3583

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

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

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

    
3638
    /* per-MB end of slice check */
3639

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

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

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

    
3748
    s->gb= gb;
3749
}
3750

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

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

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

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

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

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

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

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

    
3894
            mb_type= h263_mb_type_b_map[ mb_type ];
3895
        }while(!mb_type);
3896

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

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

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

    
3921
        if(IS_QUANT(mb_type)){
3922
            h263_decode_dquant(s);
3923
        }
3924

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

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

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

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

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

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

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

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

    
4018
        if(v==0)
4019
            return SLICE_END;
4020
    }
4021

    
4022
    return SLICE_OK;     
4023
}
4024

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4344
    return SLICE_OK;     
4345
}
4346

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

    
4352
    if (code == 0)
4353
        return pred;
4354
    if (code < 0)
4355
        return 0xffff;
4356

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

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

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

    
4408
}
4409

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

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

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

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

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

    
4582
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4583
}
4584

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

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

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

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

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

    
4708
            if(IS_3IV1) 
4709
                cache ^= 0xC0000000;
4710

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

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

    
4728
                        level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4729

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

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

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