Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ a2e4c0dd

History | View | Annotate | Download (213 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 file is part of FFmpeg.
9
 *
10
 * FFmpeg is free software; you can redistribute it and/or
11
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13
 * version 2.1 of the License, or (at your option) any later version.
14
 *
15
 * FFmpeg is distributed in the hope that it will be useful,
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19
 *
20
 * You should have received a copy of the GNU Lesser General Public
21
 * License along with FFmpeg; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
 *
24
 * ac prediction encoding, b-frame support, error resilience, optimizations,
25
 * qpel decoding, gmc decoding, interlaced decoding,
26
 * by Michael Niedermayer <michaelni@gmx.at>
27
 */
28

    
29
/**
30
 * @file h263.c
31
 * h263/mpeg4 codec.
32
 */
33

    
34
//#define DEBUG
35
#include <limits.h>
36

    
37
#include "dsputil.h"
38
#include "avcodec.h"
39
#include "mpegvideo.h"
40
#include "h263data.h"
41
#include "mpeg4data.h"
42

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

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

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

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

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

    
89
static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
90
static uint8_t fcode_tab[MAX_MV*2+1];
91
static uint8_t umv_fcode_tab[MAX_MV*2+1];
92

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

    
103
/* mpeg4
104
inter
105
max level: 24/6
106
max run: 53/63
107

108
intra
109
max level: 53/16
110
max run: 29/41
111
*/
112
#endif
113

    
114
static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3];
115

    
116
#if 0 //3IV1 is quite rare and it slows things down a tiny bit
117
#define IS_3IV1 s->codec_tag == ff_get_fourcc("3IV1")
118
#else
119
#define IS_3IV1 0
120
#endif
121

    
122
int h263_get_picture_format(int width, int height)
123
{
124
    int format;
125

    
126
    if (width == 128 && height == 96)
127
        format = 1;
128
    else if (width == 176 && height == 144)
129
        format = 2;
130
    else if (width == 352 && height == 288)
131
        format = 3;
132
    else if (width == 704 && height == 576)
133
        format = 4;
134
    else if (width == 1408 && height == 1152)
135
        format = 5;
136
    else
137
        format = 7;
138
    return format;
139
}
140

    
141
#ifdef CONFIG_ENCODERS
142

    
143
static void aspect_to_info(MpegEncContext * s, AVRational aspect){
144
    int i;
145

    
146
    if(aspect.num==0) aspect= (AVRational){1,1};
147

    
148
    for(i=1; i<6; i++){
149
        if(av_cmp_q(pixel_aspect[i], aspect) == 0){
150
            s->aspect_ratio_info=i;
151
            return;
152
        }
153
    }
154

    
155
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
156
}
157

    
158
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
159
{
160
      int format;
161

    
162
      align_put_bits(&s->pb);
163

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

    
195
      if(s->h263_aic){
196
        s->y_dc_scale_table=
197
          s->c_dc_scale_table= ff_aic_dc_scale_table;
198
      }else{
199
        s->y_dc_scale_table=
200
          s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
201
      }
202
}
203

    
204
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
205
{
206
    int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
207
    int best_clock_code=1;
208
    int best_divisor=60;
209
    int best_error= INT_MAX;
210

    
211
    if(s->h263_plus){
212
        for(i=0; i<2; i++){
213
            int div, error;
214
            div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
215
            div= av_clip(1, div, 127);
216
            error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
217
            if(error < best_error){
218
                best_error= error;
219
                best_divisor= div;
220
                best_clock_code= i;
221
            }
222
        }
223
    }
224
    s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
225
    coded_frame_rate= 1800000;
226
    coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
227

    
228
    align_put_bits(&s->pb);
229

    
230
    /* Update the pointer to last GOB */
231
    s->ptr_lastgob = pbBufPtr(&s->pb);
232
    put_bits(&s->pb, 22, 0x20); /* PSC */
233
    temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
234
                         (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
235
    put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
236

    
237
    put_bits(&s->pb, 1, 1);     /* marker */
238
    put_bits(&s->pb, 1, 0);     /* h263 id */
239
    put_bits(&s->pb, 1, 0);     /* split screen off */
240
    put_bits(&s->pb, 1, 0);     /* camera  off */
241
    put_bits(&s->pb, 1, 0);     /* freeze picture release off */
242

    
243
    format = h263_get_picture_format(s->width, s->height);
244
    if (!s->h263_plus) {
245
        /* H.263v1 */
246
        put_bits(&s->pb, 3, format);
247
        put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
248
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
249
        of H.263v1 UMV implies to check the predicted MV after
250
        calculation of the current MB to see if we're on the limits */
251
        put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
252
        put_bits(&s->pb, 1, 0);         /* SAC: off */
253
        put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
254
        put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
255
        put_bits(&s->pb, 5, s->qscale);
256
        put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
257
    } else {
258
        int ufep=1;
259
        /* H.263v2 */
260
        /* H.263 Plus PTYPE */
261

    
262
        put_bits(&s->pb, 3, 7);
263
        put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
264
        if (format == 7)
265
            put_bits(&s->pb,3,6); /* Custom Source Format */
266
        else
267
            put_bits(&s->pb, 3, format);
268

    
269
        put_bits(&s->pb,1, s->custom_pcf);
270
        put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
271
        put_bits(&s->pb,1,0); /* SAC: off */
272
        put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
273
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
274
        put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
275
        put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
276
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
277
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
278
        put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
279
        put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
280
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
281
        put_bits(&s->pb,3,0); /* Reserved */
282

    
283
        put_bits(&s->pb, 3, s->pict_type == P_TYPE);
284

    
285
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
286
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
287
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
288
        put_bits(&s->pb,2,0); /* Reserved */
289
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
290

    
291
        /* This should be here if PLUSPTYPE */
292
        put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
293

    
294
                if (format == 7) {
295
            /* Custom Picture Format (CPFMT) */
296
            aspect_to_info(s, s->avctx->sample_aspect_ratio);
297

    
298
            put_bits(&s->pb,4,s->aspect_ratio_info);
299
            put_bits(&s->pb,9,(s->width >> 2) - 1);
300
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
301
            put_bits(&s->pb,9,(s->height >> 2));
302
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
303
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
304
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
305
            }
306
        }
307
        if(s->custom_pcf){
308
            if(ufep){
309
                put_bits(&s->pb, 1, best_clock_code);
310
                put_bits(&s->pb, 7, best_divisor);
311
            }
312
            put_bits(&s->pb, 2, (temp_ref>>8)&3);
313
        }
314

    
315
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
316
        if (s->umvplus)
317
//            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
318
//FIXME check actual requested range
319
            put_bits(&s->pb,2,1); /* unlimited */
320
        if(s->h263_slice_structured)
321
            put_bits(&s->pb,2,0); /* no weird submodes */
322

    
323
        put_bits(&s->pb, 5, s->qscale);
324
    }
325

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

    
328
    if(s->h263_slice_structured){
329
        put_bits(&s->pb, 1, 1);
330

    
331
        assert(s->mb_x == 0 && s->mb_y == 0);
332
        ff_h263_encode_mba(s);
333

    
334
        put_bits(&s->pb, 1, 1);
335
    }
336

    
337
    if(s->h263_aic){
338
         s->y_dc_scale_table=
339
         s->c_dc_scale_table= ff_aic_dc_scale_table;
340
    }else{
341
        s->y_dc_scale_table=
342
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
343
    }
344
}
345

    
346
/**
347
 * Encodes a group of blocks header.
348
 */
349
void h263_encode_gob_header(MpegEncContext * s, int mb_line)
350
{
351
    put_bits(&s->pb, 17, 1); /* GBSC */
352

    
353
    if(s->h263_slice_structured){
354
        put_bits(&s->pb, 1, 1);
355

    
356
        ff_h263_encode_mba(s);
357

    
358
        if(s->mb_num > 1583)
359
            put_bits(&s->pb, 1, 1);
360
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
361
        put_bits(&s->pb, 1, 1);
362
        put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
363
    }else{
364
        int gob_number= mb_line / s->gob_index;
365

    
366
        put_bits(&s->pb, 5, gob_number); /* GN */
367
        put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
368
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
369
    }
370
}
371

    
372
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
373
    int last=0;
374
    int j;
375
    int rate=0;
376

    
377
    for(j=1; j<=block_last_index; j++){
378
        const int index= scantable[j];
379
        int level= block[index];
380
        if(level){
381
            level+= 64;
382
            if((level&(~127)) == 0){
383
                if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
384
                else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
385
            }else
386
                rate += s->ac_esc_length;
387
            level-= 64;
388

    
389
            last= j;
390
        }
391
    }
392

    
393
    return rate;
394
}
395

    
396
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
397
{
398
    int score= 0;
399
    int i, n;
400
    int8_t * const qscale_table= s->current_picture.qscale_table;
401

    
402
    memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
403

    
404
    for(n=0; n<6; n++){
405
        int16_t *ac_val, *ac_val1;
406

    
407
        score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
408

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

    
457
        for(i=63; i>0; i--) //FIXME optimize
458
            if(block[n][ st[n][i] ]) break;
459
        s->block_last_index[n]= i;
460

    
461
        score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
462
    }
463

    
464
    return score < 0;
465
}
466

    
467
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
468
{
469
    int i, n;
470
    memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
471

    
472
    for(n=0; n<6; n++){
473
        int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
474

    
475
        st[n]= s->intra_scantable.permutated;
476
        if(dir[n]){
477
            /* top prediction */
478
            for(i=1; i<8; i++){
479
                block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
480
            }
481
        }else{
482
            /* left prediction */
483
            for(i=1; i<8; i++){
484
                block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
485
            }
486
        }
487
    }
488
}
489

    
490
/**
491
 * init s->current_picture.qscale_table from s->lambda_table
492
 */
493
static void ff_init_qscale_tab(MpegEncContext *s){
494
    int8_t * const qscale_table= s->current_picture.qscale_table;
495
    int i;
496

    
497
    for(i=0; i<s->mb_num; i++){
498
        unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ];
499
        int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
500
        qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax);
501
    }
502
}
503

    
504
/**
505
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
506
 */
507
void ff_clean_h263_qscales(MpegEncContext *s){
508
    int i;
509
    int8_t * const qscale_table= s->current_picture.qscale_table;
510

    
511
    ff_init_qscale_tab(s);
512

    
513
    for(i=1; i<s->mb_num; i++){
514
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
515
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
516
    }
517
    for(i=s->mb_num-2; i>=0; i--){
518
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
519
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
520
    }
521

    
522
    if(s->codec_id != CODEC_ID_H263P){
523
        for(i=1; i<s->mb_num; i++){
524
            int mb_xy= s->mb_index2xy[i];
525

    
526
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
527
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
528
            }
529
        }
530
    }
531
}
532

    
533
/**
534
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
535
 */
536
void ff_clean_mpeg4_qscales(MpegEncContext *s){
537
    int i;
538
    int8_t * const qscale_table= s->current_picture.qscale_table;
539

    
540
    ff_clean_h263_qscales(s);
541

    
542
    if(s->pict_type== B_TYPE){
543
        int odd=0;
544
        /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
545

    
546
        for(i=0; i<s->mb_num; i++){
547
            int mb_xy= s->mb_index2xy[i];
548
            odd += qscale_table[mb_xy]&1;
549
        }
550

    
551
        if(2*odd > s->mb_num) odd=1;
552
        else                  odd=0;
553

    
554
        for(i=0; i<s->mb_num; i++){
555
            int mb_xy= s->mb_index2xy[i];
556
            if((qscale_table[mb_xy]&1) != odd)
557
                qscale_table[mb_xy]++;
558
            if(qscale_table[mb_xy] > 31)
559
                qscale_table[mb_xy]= 31;
560
        }
561

    
562
        for(i=1; i<s->mb_num; i++){
563
            int mb_xy= s->mb_index2xy[i];
564
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
565
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
566
            }
567
        }
568
    }
569
}
570

    
571
#endif //CONFIG_ENCODERS
572

    
573
#define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
574
#define tab_bias (tab_size/2)
575

    
576
void ff_mpeg4_init_direct_mv(MpegEncContext *s){
577
    int i;
578
    for(i=0; i<tab_size; i++){
579
        s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
580
        s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
581
    }
582
}
583

    
584
static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
585
    int xy= s->block_index[i];
586
    uint16_t time_pp= s->pp_time;
587
    uint16_t time_pb= s->pb_time;
588
    int p_mx, p_my;
589

    
590
    p_mx= s->next_picture.motion_val[0][xy][0];
591
    if((unsigned)(p_mx + tab_bias) < tab_size){
592
        s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
593
        s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
594
                            : s->direct_scale_mv[1][p_mx + tab_bias];
595
    }else{
596
        s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
597
        s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
598
                            : p_mx*(time_pb - time_pp)/time_pp;
599
    }
600
    p_my= s->next_picture.motion_val[0][xy][1];
601
    if((unsigned)(p_my + tab_bias) < tab_size){
602
        s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
603
        s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
604
                            : s->direct_scale_mv[1][p_my + tab_bias];
605
    }else{
606
        s->mv[0][i][1] = p_my*time_pb/time_pp + my;
607
        s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
608
                            : p_my*(time_pb - time_pp)/time_pp;
609
    }
610
}
611

    
612
#undef tab_size
613
#undef tab_bias
614

    
615
/**
616
 *
617
 * @return the mb_type
618
 */
619
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
620
    const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
621
    const int colocated_mb_type= s->next_picture.mb_type[mb_index];
622
    uint16_t time_pp= s->pp_time;
623
    uint16_t time_pb= s->pb_time;
624
    int i;
625

    
626
    //FIXME avoid divides
627
    // try special case with shifts for 1 and 3 B-frames?
628

    
629
    if(IS_8X8(colocated_mb_type)){
630
        s->mv_type = MV_TYPE_8X8;
631
        for(i=0; i<4; i++){
632
            ff_mpeg4_set_one_direct_mv(s, mx, my, i);
633
        }
634
        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
635
    } else if(IS_INTERLACED(colocated_mb_type)){
636
        s->mv_type = MV_TYPE_FIELD;
637
        for(i=0; i<2; i++){
638
            int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
639
            s->field_select[0][i]= field_select;
640
            s->field_select[1][i]= i;
641
            if(s->top_field_first){
642
                time_pp= s->pp_field_time - field_select + i;
643
                time_pb= s->pb_field_time - field_select + i;
644
            }else{
645
                time_pp= s->pp_field_time + field_select - i;
646
                time_pb= s->pb_field_time + field_select - i;
647
            }
648
            s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
649
            s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
650
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
651
                                : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
652
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
653
                                : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
654
        }
655
        return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
656
    }else{
657
        ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
658
        s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
659
        s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
660
        s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
661
        s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
662
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
663
            s->mv_type= MV_TYPE_16X16;
664
        else
665
            s->mv_type= MV_TYPE_8X8;
666
        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
667
    }
668
}
669

    
670
void ff_h263_update_motion_val(MpegEncContext * s){
671
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
672
               //FIXME a lot of that is only needed for !low_delay
673
    const int wrap = s->b8_stride;
674
    const int xy = s->block_index[0];
675

    
676
    s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
677

    
678
    if(s->mv_type != MV_TYPE_8X8){
679
        int motion_x, motion_y;
680
        if (s->mb_intra) {
681
            motion_x = 0;
682
            motion_y = 0;
683
        } else if (s->mv_type == MV_TYPE_16X16) {
684
            motion_x = s->mv[0][0][0];
685
            motion_y = s->mv[0][0][1];
686
        } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
687
            int i;
688
            motion_x = s->mv[0][0][0] + s->mv[0][1][0];
689
            motion_y = s->mv[0][0][1] + s->mv[0][1][1];
690
            motion_x = (motion_x>>1) | (motion_x&1);
691
            for(i=0; i<2; i++){
692
                s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
693
                s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
694
            }
695
            s->current_picture.ref_index[0][xy           ]=
696
            s->current_picture.ref_index[0][xy        + 1]= s->field_select[0][0];
697
            s->current_picture.ref_index[0][xy + wrap    ]=
698
            s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
699
        }
700

    
701
        /* no update if 8X8 because it has been done during parsing */
702
        s->current_picture.motion_val[0][xy][0] = motion_x;
703
        s->current_picture.motion_val[0][xy][1] = motion_y;
704
        s->current_picture.motion_val[0][xy + 1][0] = motion_x;
705
        s->current_picture.motion_val[0][xy + 1][1] = motion_y;
706
        s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
707
        s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
708
        s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
709
        s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
710
    }
711

    
712
    if(s->encoding){ //FIXME encoding MUST be cleaned up
713
        if (s->mv_type == MV_TYPE_8X8)
714
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
715
        else if(s->mb_intra)
716
            s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
717
        else
718
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
719
    }
720
}
721

    
722
#ifdef CONFIG_ENCODERS
723

    
724
static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
725
    int l, bit_size, code;
726

    
727
    if (val == 0) {
728
        return mvtab[0][1];
729
    } else {
730
        bit_size = f_code - 1;
731
        /* modulo encoding */
732
        l= INT_BIT - 6 - bit_size;
733
        val = (val<<l)>>l;
734
        val--;
735
        code = (val >> bit_size) + 1;
736

    
737
        return mvtab[code][1] + 1 + bit_size;
738
    }
739
}
740

    
741
static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
742
    if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
743
        skip_put_bits(&s->pb,
744
            h263_get_motion_length(s, x, f_code)
745
           +h263_get_motion_length(s, y, f_code));
746
    }else{
747
        ff_h263_encode_motion(s, x, f_code);
748
        ff_h263_encode_motion(s, y, f_code);
749
    }
750
}
751

    
752
static inline int get_p_cbp(MpegEncContext * s,
753
                      DCTELEM block[6][64],
754
                      int motion_x, int motion_y){
755
    int cbp, i;
756

    
757
    if(s->flags & CODEC_FLAG_CBP_RD){
758
        int best_cbpy_score= INT_MAX;
759
        int best_cbpc_score= INT_MAX;
760
        int cbpc = (-1), cbpy= (-1);
761
        const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
762
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
763

    
764
        for(i=0; i<4; i++){
765
            int score= inter_MCBPC_bits[i + offset] * lambda;
766
            if(i&1) score += s->coded_score[5];
767
            if(i&2) score += s->coded_score[4];
768

    
769
            if(score < best_cbpc_score){
770
                best_cbpc_score= score;
771
                cbpc= i;
772
            }
773
        }
774

    
775
        for(i=0; i<16; i++){
776
            int score= cbpy_tab[i ^ 0xF][1] * lambda;
777
            if(i&1) score += s->coded_score[3];
778
            if(i&2) score += s->coded_score[2];
779
            if(i&4) score += s->coded_score[1];
780
            if(i&8) score += s->coded_score[0];
781

    
782
            if(score < best_cbpy_score){
783
                best_cbpy_score= score;
784
                cbpy= i;
785
            }
786
        }
787
        cbp= cbpc + 4*cbpy;
788
        if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
789
            if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
790
                cbp= 0;
791
        }
792

    
793
        for (i = 0; i < 6; i++) {
794
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
795
                s->block_last_index[i]= -1;
796
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
797
            }
798
        }
799
    }else{
800
        cbp= 0;
801
        for (i = 0; i < 6; i++) {
802
            if (s->block_last_index[i] >= 0)
803
                cbp |= 1 << (5 - i);
804
        }
805
    }
806
    return cbp;
807
}
808

    
809
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
810
                            int motion_x, int motion_y, int mb_type){
811
    int cbp=0, i;
812

    
813
    if(s->flags & CODEC_FLAG_CBP_RD){
814
        int score=0;
815
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
816

    
817
        for(i=0; i<6; i++){
818
            if(s->coded_score[i] < 0){
819
                score += s->coded_score[i];
820
                cbp |= 1 << (5 - i);
821
            }
822
        }
823

    
824
        if(cbp){
825
            int zero_score= -6;
826
            if ((motion_x | motion_y | s->dquant | mb_type) == 0){
827
                zero_score-= 4; //2*MV + mb_type + cbp bit
828
            }
829

    
830
            zero_score*= lambda;
831
            if(zero_score <= score){
832
                cbp=0;
833
            }
834
        }
835

    
836
        for (i = 0; i < 6; i++) {
837
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
838
                s->block_last_index[i]= -1;
839
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
840
            }
841
        }
842
    }else{
843
        for (i = 0; i < 6; i++) {
844
            if (s->block_last_index[i] >= 0)
845
                cbp |= 1 << (5 - i);
846
        }
847
    }
848
    return cbp;
849
}
850

    
851
static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
852
                               uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
853
    int i;
854

    
855
    if(scan_table){
856
        if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
857
            for (i = 0; i < 6; i++) {
858
                skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
859
            }
860
        }else{
861
            /* encode each block */
862
            for (i = 0; i < 6; i++) {
863
                mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
864
            }
865
        }
866
    }else{
867
        if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
868
            for (i = 0; i < 6; i++) {
869
                skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
870
            }
871
        }else{
872
            /* encode each block */
873
            for (i = 0; i < 6; i++) {
874
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
875
            }
876
        }
877
    }
878
}
879

    
880
void mpeg4_encode_mb(MpegEncContext * s,
881
                    DCTELEM block[6][64],
882
                    int motion_x, int motion_y)
883
{
884
    int cbpc, cbpy, pred_x, pred_y;
885
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
886
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
887
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
888
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
889
    const int dquant_code[5]= {1,0,9,2,3};
890

    
891
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
892
    if (!s->mb_intra) {
893
        int i, cbp;
894

    
895
        if(s->pict_type==B_TYPE){
896
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
897
            int mb_type=  mb_type_table[s->mv_dir];
898

    
899
            if(s->mb_x==0){
900
                for(i=0; i<2; i++){
901
                    s->last_mv[i][0][0]=
902
                    s->last_mv[i][0][1]=
903
                    s->last_mv[i][1][0]=
904
                    s->last_mv[i][1][1]= 0;
905
                }
906
            }
907

    
908
            assert(s->dquant>=-2 && s->dquant<=2);
909
            assert((s->dquant&1)==0);
910
            assert(mb_type>=0);
911

    
912
            /* nothing to do if this MB was skipped in the next P Frame */
913
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
914
                s->skip_count++;
915
                s->mv[0][0][0]=
916
                s->mv[0][0][1]=
917
                s->mv[1][0][0]=
918
                s->mv[1][0][1]= 0;
919
                s->mv_dir= MV_DIR_FORWARD; //doesn't matter
920
                s->qscale -= s->dquant;
921
//                s->mb_skipped=1;
922

    
923
                return;
924
            }
925

    
926
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
927

    
928
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
929
                /* direct MB with MV={0,0} */
930
                assert(s->dquant==0);
931

    
932
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
933

    
934
                if(interleaved_stats){
935
                    s->misc_bits++;
936
                    s->last_bits++;
937
                }
938
                s->skip_count++;
939
                return;
940
            }
941

    
942
            put_bits(&s->pb, 1, 0);     /* mb coded modb1=0 */
943
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
944
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
945
            if(cbp) put_bits(&s->pb, 6, cbp);
946

    
947
            if(cbp && mb_type){
948
                if(s->dquant)
949
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
950
                else
951
                    put_bits(&s->pb, 1, 0);
952
            }else
953
                s->qscale -= s->dquant;
954

    
955
            if(!s->progressive_sequence){
956
                if(cbp)
957
                    put_bits(&s->pb, 1, s->interlaced_dct);
958
                if(mb_type) // not direct mode
959
                    put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
960
            }
961

    
962
            if(interleaved_stats){
963
                s->misc_bits+= get_bits_diff(s);
964
            }
965

    
966
            if(mb_type == 0){
967
                assert(s->mv_dir & MV_DIRECT);
968
                ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
969
                s->b_count++;
970
                s->f_count++;
971
            }else{
972
                assert(mb_type > 0 && mb_type < 4);
973
                if(s->mv_type != MV_TYPE_FIELD){
974
                    if(s->mv_dir & MV_DIR_FORWARD){
975
                        ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
976
                                                        s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
977
                        s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
978
                        s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
979
                        s->f_count++;
980
                    }
981
                    if(s->mv_dir & MV_DIR_BACKWARD){
982
                        ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
983
                                                        s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
984
                        s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
985
                        s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
986
                        s->b_count++;
987
                    }
988
                }else{
989
                    if(s->mv_dir & MV_DIR_FORWARD){
990
                        put_bits(&s->pb, 1, s->field_select[0][0]);
991
                        put_bits(&s->pb, 1, s->field_select[0][1]);
992
                    }
993
                    if(s->mv_dir & MV_DIR_BACKWARD){
994
                        put_bits(&s->pb, 1, s->field_select[1][0]);
995
                        put_bits(&s->pb, 1, s->field_select[1][1]);
996
                    }
997
                    if(s->mv_dir & MV_DIR_FORWARD){
998
                        for(i=0; i<2; i++){
999
                            ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0]  ,
1000
                                                            s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1001
                            s->last_mv[0][i][0]= s->mv[0][i][0];
1002
                            s->last_mv[0][i][1]= s->mv[0][i][1]*2;
1003
                        }
1004
                        s->f_count++;
1005
                    }
1006
                    if(s->mv_dir & MV_DIR_BACKWARD){
1007
                        for(i=0; i<2; i++){
1008
                            ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0]  ,
1009
                                                            s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1010
                            s->last_mv[1][i][0]= s->mv[1][i][0];
1011
                            s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1012
                        }
1013
                        s->b_count++;
1014
                    }
1015
                }
1016
            }
1017

    
1018
            if(interleaved_stats){
1019
                s->mv_bits+= get_bits_diff(s);
1020
            }
1021

    
1022
            mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1023

    
1024
            if(interleaved_stats){
1025
                s->p_tex_bits+= get_bits_diff(s);
1026
            }
1027

    
1028
        }else{ /* s->pict_type==B_TYPE */
1029
            cbp= get_p_cbp(s, block, motion_x, motion_y);
1030

    
1031
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1032
                /* check if the B frames can skip it too, as we must skip it if we skip here
1033
                   why didn't they just compress the skip-mb bits instead of reusing them ?! */
1034
                if(s->max_b_frames>0){
1035
                    int i;
1036
                    int x,y, offset;
1037
                    uint8_t *p_pic;
1038

    
1039
                    x= s->mb_x*16;
1040
                    y= s->mb_y*16;
1041
                    if(x+16 > s->width)  x= s->width-16;
1042
                    if(y+16 > s->height) y= s->height-16;
1043

    
1044
                    offset= x + y*s->linesize;
1045
                    p_pic= s->new_picture.data[0] + offset;
1046

    
1047
                    s->mb_skipped=1;
1048
                    for(i=0; i<s->max_b_frames; i++){
1049
                        uint8_t *b_pic;
1050
                        int diff;
1051
                        Picture *pic= s->reordered_input_picture[i+1];
1052

    
1053
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
1054

    
1055
                        b_pic= pic->data[0] + offset;
1056
                        if(pic->type != FF_BUFFER_TYPE_SHARED)
1057
                            b_pic+= INPLACE_OFFSET;
1058
                        diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1059
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1060
                            s->mb_skipped=0;
1061
                            break;
1062
                        }
1063
                    }
1064
                }else
1065
                    s->mb_skipped=1;
1066

    
1067
                if(s->mb_skipped==1){
1068
                    /* skip macroblock */
1069
                    put_bits(&s->pb, 1, 1);
1070

    
1071
                    if(interleaved_stats){
1072
                        s->misc_bits++;
1073
                        s->last_bits++;
1074
                    }
1075
                    s->skip_count++;
1076

    
1077
                    return;
1078
                }
1079
            }
1080

    
1081
            put_bits(&s->pb, 1, 0);     /* mb coded */
1082
            cbpc = cbp & 3;
1083
            cbpy = cbp >> 2;
1084
            cbpy ^= 0xf;
1085
            if(s->mv_type==MV_TYPE_16X16){
1086
                if(s->dquant) cbpc+= 8;
1087
                put_bits(&s->pb,
1088
                        inter_MCBPC_bits[cbpc],
1089
                        inter_MCBPC_code[cbpc]);
1090

    
1091
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1092
                if(s->dquant)
1093
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
1094

    
1095
                if(!s->progressive_sequence){
1096
                    if(cbp)
1097
                        put_bits(pb2, 1, s->interlaced_dct);
1098
                    put_bits(pb2, 1, 0);
1099
                }
1100

    
1101
                if(interleaved_stats){
1102
                    s->misc_bits+= get_bits_diff(s);
1103
                }
1104

    
1105
                /* motion vectors: 16x16 mode */
1106
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1107

    
1108
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
1109
                                                motion_y - pred_y, s->f_code);
1110
            }else if(s->mv_type==MV_TYPE_FIELD){
1111
                if(s->dquant) cbpc+= 8;
1112
                put_bits(&s->pb,
1113
                        inter_MCBPC_bits[cbpc],
1114
                        inter_MCBPC_code[cbpc]);
1115

    
1116
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1117
                if(s->dquant)
1118
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
1119

    
1120
                assert(!s->progressive_sequence);
1121
                if(cbp)
1122
                    put_bits(pb2, 1, s->interlaced_dct);
1123
                put_bits(pb2, 1, 1);
1124

    
1125
                if(interleaved_stats){
1126
                    s->misc_bits+= get_bits_diff(s);
1127
                }
1128

    
1129
                /* motion vectors: 16x8 interlaced mode */
1130
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1131
                pred_y /=2;
1132

    
1133
                put_bits(&s->pb, 1, s->field_select[0][0]);
1134
                put_bits(&s->pb, 1, s->field_select[0][1]);
1135

    
1136
                ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1137
                                                s->mv[0][0][1] - pred_y, s->f_code);
1138
                ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1139
                                                s->mv[0][1][1] - pred_y, s->f_code);
1140
            }else{
1141
                assert(s->mv_type==MV_TYPE_8X8);
1142
                put_bits(&s->pb,
1143
                        inter_MCBPC_bits[cbpc+16],
1144
                        inter_MCBPC_code[cbpc+16]);
1145
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1146

    
1147
                if(!s->progressive_sequence){
1148
                    if(cbp)
1149
                        put_bits(pb2, 1, s->interlaced_dct);
1150
                }
1151

    
1152
                if(interleaved_stats){
1153
                    s->misc_bits+= get_bits_diff(s);
1154
                }
1155

    
1156
                for(i=0; i<4; i++){
1157
                    /* motion vectors: 8x8 mode*/
1158
                    h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1159

    
1160
                    ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1161
                                                    s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1162
                }
1163
            }
1164

    
1165
            if(interleaved_stats){
1166
                s->mv_bits+= get_bits_diff(s);
1167
            }
1168

    
1169
            mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1170

    
1171
            if(interleaved_stats){
1172
                s->p_tex_bits+= get_bits_diff(s);
1173
            }
1174
            s->f_count++;
1175
        }
1176
    } else {
1177
        int cbp;
1178
        int dc_diff[6];   //dc values with the dc prediction subtracted
1179
        int dir[6];  //prediction direction
1180
        int zigzag_last_index[6];
1181
        uint8_t *scan_table[6];
1182
        int i;
1183

    
1184
        for(i=0; i<6; i++){
1185
            dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1186
        }
1187

    
1188
        if(s->flags & CODEC_FLAG_AC_PRED){
1189
            s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1190
            if(!s->ac_pred)
1191
                restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1192
        }else{
1193
            for(i=0; i<6; i++)
1194
                scan_table[i]= s->intra_scantable.permutated;
1195
        }
1196

    
1197
        /* compute cbp */
1198
        cbp = 0;
1199
        for (i = 0; i < 6; i++) {
1200
            if (s->block_last_index[i] >= 1)
1201
                cbp |= 1 << (5 - i);
1202
        }
1203

    
1204
        cbpc = cbp & 3;
1205
        if (s->pict_type == I_TYPE) {
1206
            if(s->dquant) cbpc+=4;
1207
            put_bits(&s->pb,
1208
                intra_MCBPC_bits[cbpc],
1209
                intra_MCBPC_code[cbpc]);
1210
        } else {
1211
            if(s->dquant) cbpc+=8;
1212
            put_bits(&s->pb, 1, 0);     /* mb coded */
1213
            put_bits(&s->pb,
1214
                inter_MCBPC_bits[cbpc + 4],
1215
                inter_MCBPC_code[cbpc + 4]);
1216
        }
1217
        put_bits(pb2, 1, s->ac_pred);
1218
        cbpy = cbp >> 2;
1219
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1220
        if(s->dquant)
1221
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1222

    
1223
        if(!s->progressive_sequence){
1224
            put_bits(dc_pb, 1, s->interlaced_dct);
1225
        }
1226

    
1227
        if(interleaved_stats){
1228
            s->misc_bits+= get_bits_diff(s);
1229
        }
1230

    
1231
        mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1232

    
1233
        if(interleaved_stats){
1234
            s->i_tex_bits+= get_bits_diff(s);
1235
        }
1236
        s->i_count++;
1237

    
1238
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1239
        if(s->ac_pred)
1240
            restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1241
    }
1242
}
1243

    
1244
void h263_encode_mb(MpegEncContext * s,
1245
                    DCTELEM block[6][64],
1246
                    int motion_x, int motion_y)
1247
{
1248
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
1249
    int16_t pred_dc;
1250
    int16_t rec_intradc[6];
1251
    int16_t *dc_ptr[6];
1252
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1253
    const int dquant_code[5]= {1,0,9,2,3};
1254

    
1255
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1256
    if (!s->mb_intra) {
1257
        /* compute cbp */
1258
        cbp= get_p_cbp(s, block, motion_x, motion_y);
1259

    
1260
        if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1261
            /* skip macroblock */
1262
            put_bits(&s->pb, 1, 1);
1263
            if(interleaved_stats){
1264
                s->misc_bits++;
1265
                s->last_bits++;
1266
            }
1267
            s->skip_count++;
1268

    
1269
            return;
1270
        }
1271
        put_bits(&s->pb, 1, 0);         /* mb coded */
1272

    
1273
        cbpc = cbp & 3;
1274
        cbpy = cbp >> 2;
1275
        if(s->alt_inter_vlc==0 || cbpc!=3)
1276
            cbpy ^= 0xF;
1277
        if(s->dquant) cbpc+= 8;
1278
        if(s->mv_type==MV_TYPE_16X16){
1279
            put_bits(&s->pb,
1280
                    inter_MCBPC_bits[cbpc],
1281
                    inter_MCBPC_code[cbpc]);
1282

    
1283
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1284
            if(s->dquant)
1285
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1286

    
1287
            if(interleaved_stats){
1288
                s->misc_bits+= get_bits_diff(s);
1289
            }
1290

    
1291
            /* motion vectors: 16x16 mode */
1292
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1293

    
1294
            if (!s->umvplus) {
1295
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
1296
                                                motion_y - pred_y, 1);
1297
            }
1298
            else {
1299
                h263p_encode_umotion(s, motion_x - pred_x);
1300
                h263p_encode_umotion(s, motion_y - pred_y);
1301
                if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1302
                    /* To prevent Start Code emulation */
1303
                    put_bits(&s->pb,1,1);
1304
            }
1305
        }else{
1306
            put_bits(&s->pb,
1307
                    inter_MCBPC_bits[cbpc+16],
1308
                    inter_MCBPC_code[cbpc+16]);
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
            for(i=0; i<4; i++){
1318
                /* motion vectors: 8x8 mode*/
1319
                h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1320

    
1321
                motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1322
                motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1323
                if (!s->umvplus) {
1324
                    ff_h263_encode_motion_vector(s, motion_x - pred_x,
1325
                                                    motion_y - pred_y, 1);
1326
                }
1327
                else {
1328
                    h263p_encode_umotion(s, motion_x - pred_x);
1329
                    h263p_encode_umotion(s, motion_y - pred_y);
1330
                    if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1331
                        /* To prevent Start Code emulation */
1332
                        put_bits(&s->pb,1,1);
1333
                }
1334
            }
1335
        }
1336

    
1337
        if(interleaved_stats){
1338
            s->mv_bits+= get_bits_diff(s);
1339
        }
1340
    } else {
1341
        assert(s->mb_intra);
1342

    
1343
        cbp = 0;
1344
        if (s->h263_aic) {
1345
            /* Predict DC */
1346
            for(i=0; i<6; i++) {
1347
                int16_t level = block[i][0];
1348
                int scale;
1349

    
1350
                if(i<4) scale= s->y_dc_scale;
1351
                else    scale= s->c_dc_scale;
1352

    
1353
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1354
                level -= pred_dc;
1355
                /* Quant */
1356
                if (level >= 0)
1357
                    level = (level + (scale>>1))/scale;
1358
                else
1359
                    level = (level - (scale>>1))/scale;
1360

    
1361
                /* AIC can change CBP */
1362
                if (level == 0 && s->block_last_index[i] == 0)
1363
                    s->block_last_index[i] = -1;
1364

    
1365
                if(!s->modified_quant){
1366
                    if (level < -127)
1367
                        level = -127;
1368
                    else if (level > 127)
1369
                        level = 127;
1370
                }
1371

    
1372
                block[i][0] = level;
1373
                /* Reconstruction */
1374
                rec_intradc[i] = scale*level + pred_dc;
1375
                /* Oddify */
1376
                rec_intradc[i] |= 1;
1377
                //if ((rec_intradc[i] % 2) == 0)
1378
                //    rec_intradc[i]++;
1379
                /* Clipping */
1380
                if (rec_intradc[i] < 0)
1381
                    rec_intradc[i] = 0;
1382
                else if (rec_intradc[i] > 2047)
1383
                    rec_intradc[i] = 2047;
1384

    
1385
                /* Update AC/DC tables */
1386
                *dc_ptr[i] = rec_intradc[i];
1387
                if (s->block_last_index[i] >= 0)
1388
                    cbp |= 1 << (5 - i);
1389
            }
1390
        }else{
1391
            for(i=0; i<6; i++) {
1392
                /* compute cbp */
1393
                if (s->block_last_index[i] >= 1)
1394
                    cbp |= 1 << (5 - i);
1395
            }
1396
        }
1397

    
1398
        cbpc = cbp & 3;
1399
        if (s->pict_type == I_TYPE) {
1400
            if(s->dquant) cbpc+=4;
1401
            put_bits(&s->pb,
1402
                intra_MCBPC_bits[cbpc],
1403
                intra_MCBPC_code[cbpc]);
1404
        } else {
1405
            if(s->dquant) cbpc+=8;
1406
            put_bits(&s->pb, 1, 0);     /* mb coded */
1407
            put_bits(&s->pb,
1408
                inter_MCBPC_bits[cbpc + 4],
1409
                inter_MCBPC_code[cbpc + 4]);
1410
        }
1411
        if (s->h263_aic) {
1412
            /* XXX: currently, we do not try to use ac prediction */
1413
            put_bits(&s->pb, 1, 0);     /* no AC prediction */
1414
        }
1415
        cbpy = cbp >> 2;
1416
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1417
        if(s->dquant)
1418
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1419

    
1420
        if(interleaved_stats){
1421
            s->misc_bits+= get_bits_diff(s);
1422
        }
1423
    }
1424

    
1425
    for(i=0; i<6; i++) {
1426
        /* encode each block */
1427
        h263_encode_block(s, block[i], i);
1428

    
1429
        /* Update INTRADC for decoding */
1430
        if (s->h263_aic && s->mb_intra) {
1431
            block[i][0] = rec_intradc[i];
1432

    
1433
        }
1434
    }
1435

    
1436
    if(interleaved_stats){
1437
        if (!s->mb_intra) {
1438
            s->p_tex_bits+= get_bits_diff(s);
1439
            s->f_count++;
1440
        }else{
1441
            s->i_tex_bits+= get_bits_diff(s);
1442
            s->i_count++;
1443
        }
1444
    }
1445
}
1446
#endif
1447

    
1448
void ff_h263_loop_filter(MpegEncContext * s){
1449
    int qp_c;
1450
    const int linesize  = s->linesize;
1451
    const int uvlinesize= s->uvlinesize;
1452
    const int xy = s->mb_y * s->mb_stride + s->mb_x;
1453
    uint8_t *dest_y = s->dest[0];
1454
    uint8_t *dest_cb= s->dest[1];
1455
    uint8_t *dest_cr= s->dest[2];
1456

    
1457
//    if(s->pict_type==B_TYPE && !s->readable) return;
1458

    
1459
    /*
1460
       Diag Top
1461
       Left Center
1462
    */
1463
    if(!IS_SKIP(s->current_picture.mb_type[xy])){
1464
        qp_c= s->qscale;
1465
        s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
1466
        s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1467
    }else
1468
        qp_c= 0;
1469

    
1470
    if(s->mb_y){
1471
        int qp_dt, qp_t, qp_tc;
1472

    
1473
        if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1474
            qp_t=0;
1475
        else
1476
            qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1477

    
1478
        if(qp_c)
1479
            qp_tc= qp_c;
1480
        else
1481
            qp_tc= qp_t;
1482

    
1483
        if(qp_tc){
1484
            const int chroma_qp= s->chroma_qscale_table[qp_tc];
1485
            s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
1486
            s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
1487

    
1488
            s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1489
            s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1490
        }
1491

    
1492
        if(qp_t)
1493
            s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_t);
1494

    
1495
        if(s->mb_x){
1496
            if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1497
                qp_dt= qp_t;
1498
            else
1499
                qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1500

    
1501
            if(qp_dt){
1502
                const int chroma_qp= s->chroma_qscale_table[qp_dt];
1503
                s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
1504
                s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1505
                s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1506
            }
1507
        }
1508
    }
1509

    
1510
    if(qp_c){
1511
        s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
1512
        if(s->mb_y + 1 == s->mb_height)
1513
            s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
1514
    }
1515

    
1516
    if(s->mb_x){
1517
        int qp_lc;
1518
        if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1519
            qp_lc= qp_c;
1520
        else
1521
            qp_lc= s->current_picture.qscale_table[xy-1];
1522

    
1523
        if(qp_lc){
1524
            s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
1525
            if(s->mb_y + 1 == s->mb_height){
1526
                const int chroma_qp= s->chroma_qscale_table[qp_lc];
1527
                s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
1528
                s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
1529
                s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
1530
            }
1531
        }
1532
    }
1533
}
1534

    
1535
#ifdef CONFIG_ENCODERS
1536
static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1537
{
1538
    int x, y, wrap, a, c, pred_dc, scale;
1539
    int16_t *dc_val;
1540

    
1541
    /* find prediction */
1542
    if (n < 4) {
1543
        x = 2 * s->mb_x + (n & 1);
1544
        y = 2 * s->mb_y + ((n & 2) >> 1);
1545
        wrap = s->b8_stride;
1546
        dc_val = s->dc_val[0];
1547
        scale = s->y_dc_scale;
1548
    } else {
1549
        x = s->mb_x;
1550
        y = s->mb_y;
1551
        wrap = s->mb_stride;
1552
        dc_val = s->dc_val[n - 4 + 1];
1553
        scale = s->c_dc_scale;
1554
    }
1555
    /* B C
1556
     * A X
1557
     */
1558
    a = dc_val[(x - 1) + (y) * wrap];
1559
    c = dc_val[(x) + (y - 1) * wrap];
1560

    
1561
    /* No prediction outside GOB boundary */
1562
    if(s->first_slice_line && n!=3){
1563
        if(n!=2) c= 1024;
1564
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1565
    }
1566
    pred_dc = 1024;
1567
    /* just DC prediction */
1568
    if (a != 1024 && c != 1024)
1569
        pred_dc = (a + c) >> 1;
1570
    else if (a != 1024)
1571
        pred_dc = a;
1572
    else
1573
        pred_dc = c;
1574

    
1575
    /* we assume pred is positive */
1576
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1577
    *dc_val_ptr = &dc_val[x + y * wrap];
1578
    return pred_dc;
1579
}
1580
#endif /* CONFIG_ENCODERS */
1581

    
1582
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1583
{
1584
    int x, y, wrap, a, c, pred_dc, scale, i;
1585
    int16_t *dc_val, *ac_val, *ac_val1;
1586

    
1587
    /* find prediction */
1588
    if (n < 4) {
1589
        x = 2 * s->mb_x + (n & 1);
1590
        y = 2 * s->mb_y + (n>> 1);
1591
        wrap = s->b8_stride;
1592
        dc_val = s->dc_val[0];
1593
        ac_val = s->ac_val[0][0];
1594
        scale = s->y_dc_scale;
1595
    } else {
1596
        x = s->mb_x;
1597
        y = s->mb_y;
1598
        wrap = s->mb_stride;
1599
        dc_val = s->dc_val[n - 4 + 1];
1600
        ac_val = s->ac_val[n - 4 + 1][0];
1601
        scale = s->c_dc_scale;
1602
    }
1603

    
1604
    ac_val += ((y) * wrap + (x)) * 16;
1605
    ac_val1 = ac_val;
1606

    
1607
    /* B C
1608
     * A X
1609
     */
1610
    a = dc_val[(x - 1) + (y) * wrap];
1611
    c = dc_val[(x) + (y - 1) * wrap];
1612

    
1613
    /* No prediction outside GOB boundary */
1614
    if(s->first_slice_line && n!=3){
1615
        if(n!=2) c= 1024;
1616
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1617
    }
1618

    
1619
    if (s->ac_pred) {
1620
        pred_dc = 1024;
1621
        if (s->h263_aic_dir) {
1622
            /* left prediction */
1623
            if (a != 1024) {
1624
                ac_val -= 16;
1625
                for(i=1;i<8;i++) {
1626
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1627
                }
1628
                pred_dc = a;
1629
            }
1630
        } else {
1631
            /* top prediction */
1632
            if (c != 1024) {
1633
                ac_val -= 16 * wrap;
1634
                for(i=1;i<8;i++) {
1635
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1636
                }
1637
                pred_dc = c;
1638
            }
1639
        }
1640
    } else {
1641
        /* just DC prediction */
1642
        if (a != 1024 && c != 1024)
1643
            pred_dc = (a + c) >> 1;
1644
        else if (a != 1024)
1645
            pred_dc = a;
1646
        else
1647
            pred_dc = c;
1648
    }
1649

    
1650
    /* we assume pred is positive */
1651
    block[0]=block[0]*scale + pred_dc;
1652

    
1653
    if (block[0] < 0)
1654
        block[0] = 0;
1655
    else
1656
        block[0] |= 1;
1657

    
1658
    /* Update AC/DC tables */
1659
    dc_val[(x) + (y) * wrap] = block[0];
1660

    
1661
    /* left copy */
1662
    for(i=1;i<8;i++)
1663
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1664
    /* top copy */
1665
    for(i=1;i<8;i++)
1666
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1667
}
1668

    
1669
int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1670
                        int *px, int *py)
1671
{
1672
    int wrap;
1673
    int16_t *A, *B, *C, (*mot_val)[2];
1674
    static const int off[4]= {2, 1, 1, -1};
1675

    
1676
    wrap = s->b8_stride;
1677
    mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1678

    
1679
    A = mot_val[ - 1];
1680
    /* special case for first (slice) line */
1681
    if (s->first_slice_line && block<3) {
1682
        // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1683
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1684
        if(block==0){ //most common case
1685
            if(s->mb_x  == s->resync_mb_x){ //rare
1686
                *px= *py = 0;
1687
            }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1688
                C = mot_val[off[block] - wrap];
1689
                if(s->mb_x==0){
1690
                    *px = C[0];
1691
                    *py = C[1];
1692
                }else{
1693
                    *px = mid_pred(A[0], 0, C[0]);
1694
                    *py = mid_pred(A[1], 0, C[1]);
1695
                }
1696
            }else{
1697
                *px = A[0];
1698
                *py = A[1];
1699
            }
1700
        }else if(block==1){
1701
            if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1702
                C = mot_val[off[block] - wrap];
1703
                *px = mid_pred(A[0], 0, C[0]);
1704
                *py = mid_pred(A[1], 0, C[1]);
1705
            }else{
1706
                *px = A[0];
1707
                *py = A[1];
1708
            }
1709
        }else{ /* block==2*/
1710
            B = mot_val[ - wrap];
1711
            C = mot_val[off[block] - wrap];
1712
            if(s->mb_x == s->resync_mb_x) //rare
1713
                A[0]=A[1]=0;
1714

    
1715
            *px = mid_pred(A[0], B[0], C[0]);
1716
            *py = mid_pred(A[1], B[1], C[1]);
1717
        }
1718
    } else {
1719
        B = mot_val[ - wrap];
1720
        C = mot_val[off[block] - wrap];
1721
        *px = mid_pred(A[0], B[0], C[0]);
1722
        *py = mid_pred(A[1], B[1], C[1]);
1723
    }
1724
    return *mot_val;
1725
}
1726

    
1727
#ifdef CONFIG_ENCODERS
1728
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1729
{
1730
    int range, l, bit_size, sign, code, bits;
1731

    
1732
    if (val == 0) {
1733
        /* zero vector */
1734
        code = 0;
1735
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1736
    } else {
1737
        bit_size = f_code - 1;
1738
        range = 1 << bit_size;
1739
        /* modulo encoding */
1740
        l= INT_BIT - 6 - bit_size;
1741
        val = (val<<l)>>l;
1742
        sign = val>>31;
1743
        val= (val^sign)-sign;
1744
        sign&=1;
1745

    
1746
        val--;
1747
        code = (val >> bit_size) + 1;
1748
        bits = val & (range - 1);
1749

    
1750
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1751
        if (bit_size > 0) {
1752
            put_bits(&s->pb, bit_size, bits);
1753
        }
1754
    }
1755
}
1756

    
1757
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1758
static void h263p_encode_umotion(MpegEncContext * s, int val)
1759
{
1760
    short sval = 0;
1761
    short i = 0;
1762
    short n_bits = 0;
1763
    short temp_val;
1764
    int code = 0;
1765
    int tcode;
1766

    
1767
    if ( val == 0)
1768
        put_bits(&s->pb, 1, 1);
1769
    else if (val == 1)
1770
        put_bits(&s->pb, 3, 0);
1771
    else if (val == -1)
1772
        put_bits(&s->pb, 3, 2);
1773
    else {
1774

    
1775
        sval = ((val < 0) ? (short)(-val):(short)val);
1776
        temp_val = sval;
1777

    
1778
        while (temp_val != 0) {
1779
            temp_val = temp_val >> 1;
1780
            n_bits++;
1781
        }
1782

    
1783
        i = n_bits - 1;
1784
        while (i > 0) {
1785
            tcode = (sval & (1 << (i-1))) >> (i-1);
1786
            tcode = (tcode << 1) | 1;
1787
            code = (code << 2) | tcode;
1788
            i--;
1789
        }
1790
        code = ((code << 1) | (val < 0)) << 1;
1791
        put_bits(&s->pb, (2*n_bits)+1, code);
1792
        //printf("\nVal = %d\tCode = %d", sval, code);
1793
    }
1794
}
1795

    
1796
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1797
{
1798
    int f_code;
1799
    int mv;
1800

    
1801
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1802
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1803
            int len;
1804

    
1805
            if(mv==0) len= mvtab[0][1];
1806
            else{
1807
                int val, bit_size, range, code;
1808

    
1809
                bit_size = f_code - 1;
1810
                range = 1 << bit_size;
1811

    
1812
                val=mv;
1813
                if (val < 0)
1814
                    val = -val;
1815
                val--;
1816
                code = (val >> bit_size) + 1;
1817
                if(code<33){
1818
                    len= mvtab[code][1] + 1 + bit_size;
1819
                }else{
1820
                    len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1821
                }
1822
            }
1823

    
1824
            mv_penalty[f_code][mv+MAX_MV]= len;
1825
        }
1826
    }
1827

    
1828
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1829
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1830
            fcode_tab[mv+MAX_MV]= f_code;
1831
        }
1832
    }
1833

    
1834
    for(mv=0; mv<MAX_MV*2+1; mv++){
1835
        umv_fcode_tab[mv]= 1;
1836
    }
1837
}
1838
#endif
1839

    
1840
#ifdef CONFIG_ENCODERS
1841

    
1842
static void init_uni_dc_tab(void)
1843
{
1844
    int level, uni_code, uni_len;
1845

    
1846
    for(level=-256; level<256; level++){
1847
        int size, v, l;
1848
        /* find number of bits */
1849
        size = 0;
1850
        v = abs(level);
1851
        while (v) {
1852
            v >>= 1;
1853
            size++;
1854
        }
1855

    
1856
        if (level < 0)
1857
            l= (-level) ^ ((1 << size) - 1);
1858
        else
1859
            l= level;
1860

    
1861
        /* luminance */
1862
        uni_code= DCtab_lum[size][0];
1863
        uni_len = DCtab_lum[size][1];
1864

    
1865
        if (size > 0) {
1866
            uni_code<<=size; uni_code|=l;
1867
            uni_len+=size;
1868
            if (size > 8){
1869
                uni_code<<=1; uni_code|=1;
1870
                uni_len++;
1871
            }
1872
        }
1873
        uni_DCtab_lum_bits[level+256]= uni_code;
1874
        uni_DCtab_lum_len [level+256]= uni_len;
1875

    
1876
        /* chrominance */
1877
        uni_code= DCtab_chrom[size][0];
1878
        uni_len = DCtab_chrom[size][1];
1879

    
1880
        if (size > 0) {
1881
            uni_code<<=size; uni_code|=l;
1882
            uni_len+=size;
1883
            if (size > 8){
1884
                uni_code<<=1; uni_code|=1;
1885
                uni_len++;
1886
            }
1887
        }
1888
        uni_DCtab_chrom_bits[level+256]= uni_code;
1889
        uni_DCtab_chrom_len [level+256]= uni_len;
1890

    
1891
    }
1892
}
1893

    
1894
#endif //CONFIG_ENCODERS
1895

    
1896
#ifdef CONFIG_ENCODERS
1897
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1898
    int slevel, run, last;
1899

    
1900
    assert(MAX_LEVEL >= 64);
1901
    assert(MAX_RUN   >= 63);
1902

    
1903
    for(slevel=-64; slevel<64; slevel++){
1904
        if(slevel==0) continue;
1905
        for(run=0; run<64; run++){
1906
            for(last=0; last<=1; last++){
1907
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1908
                int level= slevel < 0 ? -slevel : slevel;
1909
                int sign= slevel < 0 ? 1 : 0;
1910
                int bits, len, code;
1911
                int level1, run1;
1912

    
1913
                len_tab[index]= 100;
1914

    
1915
                /* ESC0 */
1916
                code= get_rl_index(rl, last, run, level);
1917
                bits= rl->table_vlc[code][0];
1918
                len=  rl->table_vlc[code][1];
1919
                bits=bits*2+sign; len++;
1920

    
1921
                if(code!=rl->n && len < len_tab[index]){
1922
                    bits_tab[index]= bits;
1923
                    len_tab [index]= len;
1924
                }
1925
#if 1
1926
                /* ESC1 */
1927
                bits= rl->table_vlc[rl->n][0];
1928
                len=  rl->table_vlc[rl->n][1];
1929
                bits=bits*2;    len++; //esc1
1930
                level1= level - rl->max_level[last][run];
1931
                if(level1>0){
1932
                    code= get_rl_index(rl, last, run, level1);
1933
                    bits<<= rl->table_vlc[code][1];
1934
                    len  += rl->table_vlc[code][1];
1935
                    bits += rl->table_vlc[code][0];
1936
                    bits=bits*2+sign; len++;
1937

    
1938
                    if(code!=rl->n && len < len_tab[index]){
1939
                        bits_tab[index]= bits;
1940
                        len_tab [index]= len;
1941
                    }
1942
                }
1943
#endif
1944
#if 1
1945
                /* ESC2 */
1946
                bits= rl->table_vlc[rl->n][0];
1947
                len=  rl->table_vlc[rl->n][1];
1948
                bits=bits*4+2;    len+=2; //esc2
1949
                run1 = run - rl->max_run[last][level] - 1;
1950
                if(run1>=0){
1951
                    code= get_rl_index(rl, last, run1, level);
1952
                    bits<<= rl->table_vlc[code][1];
1953
                    len  += rl->table_vlc[code][1];
1954
                    bits += rl->table_vlc[code][0];
1955
                    bits=bits*2+sign; len++;
1956

    
1957
                    if(code!=rl->n && len < len_tab[index]){
1958
                        bits_tab[index]= bits;
1959
                        len_tab [index]= len;
1960
                    }
1961
                }
1962
#endif
1963
                /* ESC3 */
1964
                bits= rl->table_vlc[rl->n][0];
1965
                len = rl->table_vlc[rl->n][1];
1966
                bits=bits*4+3;    len+=2; //esc3
1967
                bits=bits*2+last; len++;
1968
                bits=bits*64+run; len+=6;
1969
                bits=bits*2+1;    len++;  //marker
1970
                bits=bits*4096+(slevel&0xfff); len+=12;
1971
                bits=bits*2+1;    len++;  //marker
1972

    
1973
                if(len < len_tab[index]){
1974
                    bits_tab[index]= bits;
1975
                    len_tab [index]= len;
1976
                }
1977
            }
1978
        }
1979
    }
1980
}
1981

    
1982
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1983
    int slevel, run, last;
1984

    
1985
    assert(MAX_LEVEL >= 64);
1986
    assert(MAX_RUN   >= 63);
1987

    
1988
    for(slevel=-64; slevel<64; slevel++){
1989
        if(slevel==0) continue;
1990
        for(run=0; run<64; run++){
1991
            for(last=0; last<=1; last++){
1992
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1993
                int level= slevel < 0 ? -slevel : slevel;
1994
                int sign= slevel < 0 ? 1 : 0;
1995
                int bits, len, code;
1996

    
1997
                len_tab[index]= 100;
1998

    
1999
                /* ESC0 */
2000
                code= get_rl_index(rl, last, run, level);
2001
                bits= rl->table_vlc[code][0];
2002
                len=  rl->table_vlc[code][1];
2003
                bits=bits*2+sign; len++;
2004

    
2005
                if(code!=rl->n && len < len_tab[index]){
2006
                    if(bits_tab) bits_tab[index]= bits;
2007
                    len_tab [index]= len;
2008
                }
2009
                /* ESC */
2010
                bits= rl->table_vlc[rl->n][0];
2011
                len = rl->table_vlc[rl->n][1];
2012
                bits=bits*2+last; len++;
2013
                bits=bits*64+run; len+=6;
2014
                bits=bits*256+(level&0xff); len+=8;
2015

    
2016
                if(len < len_tab[index]){
2017
                    if(bits_tab) bits_tab[index]= bits;
2018
                    len_tab [index]= len;
2019
                }
2020
            }
2021
        }
2022
    }
2023
}
2024

    
2025
void h263_encode_init(MpegEncContext *s)
2026
{
2027
    static int done = 0;
2028

    
2029
    if (!done) {
2030
        done = 1;
2031

    
2032
        init_uni_dc_tab();
2033

    
2034
        init_rl(&rl_inter, static_rl_table_store[0]);
2035
        init_rl(&rl_intra, static_rl_table_store[1]);
2036
        init_rl(&rl_intra_aic, static_rl_table_store[2]);
2037

    
2038
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2039
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2040

    
2041
        init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2042
        init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
2043

    
2044
        init_mv_penalty_and_fcode(s);
2045
    }
2046
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2047

    
2048
    s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
2049
    s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2050
    if(s->h263_aic){
2051
        s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
2052
        s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2053
    }
2054
    s->ac_esc_length= 7+1+6+8;
2055

    
2056
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2057
    switch(s->codec_id){
2058
    case CODEC_ID_MPEG4:
2059
        s->fcode_tab= fcode_tab;
2060
        s->min_qcoeff= -2048;
2061
        s->max_qcoeff=  2047;
2062
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
2063
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2064
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
2065
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2066
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
2067
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2068
        s->ac_esc_length= 7+2+1+6+1+12+1;
2069
        s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2070
        s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2071

    
2072
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2073

    
2074
            s->avctx->extradata= av_malloc(1024);
2075
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
2076

    
2077
            if(!(s->workaround_bugs & FF_BUG_MS))
2078
                mpeg4_encode_visual_object_header(s);
2079
            mpeg4_encode_vol_header(s, 0, 0);
2080

    
2081
//            ff_mpeg4_stuffing(&s->pb); ?
2082
            flush_put_bits(&s->pb);
2083
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2084
        }
2085

    
2086
        break;
2087
    case CODEC_ID_H263P:
2088
        if(s->umvplus)
2089
            s->fcode_tab= umv_fcode_tab;
2090
        if(s->modified_quant){
2091
            s->min_qcoeff= -2047;
2092
            s->max_qcoeff=  2047;
2093
        }else{
2094
            s->min_qcoeff= -127;
2095
            s->max_qcoeff=  127;
2096
        }
2097
        break;
2098
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2099
    case CODEC_ID_FLV1:
2100
        if (s->h263_flv > 1) {
2101
            s->min_qcoeff= -1023;
2102
            s->max_qcoeff=  1023;
2103
        } else {
2104
            s->min_qcoeff= -127;
2105
            s->max_qcoeff=  127;
2106
        }
2107
        s->y_dc_scale_table=
2108
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2109
        break;
2110
    default: //nothing needed - default table already set in mpegvideo.c
2111
        s->min_qcoeff= -127;
2112
        s->max_qcoeff=  127;
2113
        s->y_dc_scale_table=
2114
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2115
    }
2116
}
2117

    
2118
/**
2119
 * encodes a 8x8 block.
2120
 * @param block the 8x8 block
2121
 * @param n block index (0-3 are luma, 4-5 are chroma)
2122
 */
2123
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2124
{
2125
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2126
    RLTable *rl;
2127

    
2128
    rl = &rl_inter;
2129
    if (s->mb_intra && !s->h263_aic) {
2130
        /* DC coef */
2131
        level = block[0];
2132
        /* 255 cannot be represented, so we clamp */
2133
        if (level > 254) {
2134
            level = 254;
2135
            block[0] = 254;
2136
        }
2137
        /* 0 cannot be represented also */
2138
        else if (level < 1) {
2139
            level = 1;
2140
            block[0] = 1;
2141
        }
2142
        if (level == 128) //FIXME check rv10
2143
            put_bits(&s->pb, 8, 0xff);
2144
        else
2145
            put_bits(&s->pb, 8, level);
2146
        i = 1;
2147
    } else {
2148
        i = 0;
2149
        if (s->h263_aic && s->mb_intra)
2150
            rl = &rl_intra_aic;
2151

    
2152
        if(s->alt_inter_vlc && !s->mb_intra){
2153
            int aic_vlc_bits=0;
2154
            int inter_vlc_bits=0;
2155
            int wrong_pos=-1;
2156
            int aic_code;
2157

    
2158
            last_index = s->block_last_index[n];
2159
            last_non_zero = i - 1;
2160
            for (; i <= last_index; i++) {
2161
                j = s->intra_scantable.permutated[i];
2162
                level = block[j];
2163
                if (level) {
2164
                    run = i - last_non_zero - 1;
2165
                    last = (i == last_index);
2166

    
2167
                    if(level<0) level= -level;
2168

    
2169
                    code = get_rl_index(rl, last, run, level);
2170
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2171
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2172
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2173

    
2174
                    if (code == rl->n) {
2175
                        inter_vlc_bits += 1+6+8-1;
2176
                    }
2177
                    if (aic_code == rl_intra_aic.n) {
2178
                        aic_vlc_bits += 1+6+8-1;
2179
                        wrong_pos += run + 1;
2180
                    }else
2181
                        wrong_pos += wrong_run[aic_code];
2182
                    last_non_zero = i;
2183
                }
2184
            }
2185
            i = 0;
2186
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2187
                rl = &rl_intra_aic;
2188
        }
2189
    }
2190

    
2191
    /* AC coefs */
2192
    last_index = s->block_last_index[n];
2193
    last_non_zero = i - 1;
2194
    for (; i <= last_index; i++) {
2195
        j = s->intra_scantable.permutated[i];
2196
        level = block[j];
2197
        if (level) {
2198
            run = i - last_non_zero - 1;
2199
            last = (i == last_index);
2200
            sign = 0;
2201
            slevel = level;
2202
            if (level < 0) {
2203
                sign = 1;
2204
                level = -level;
2205
            }
2206
            code = get_rl_index(rl, last, run, level);
2207
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2208
            if (code == rl->n) {
2209
              if(s->h263_flv <= 1){
2210
                put_bits(&s->pb, 1, last);
2211
                put_bits(&s->pb, 6, run);
2212

    
2213
                assert(slevel != 0);
2214

    
2215
                if(level < 128)
2216
                    put_bits(&s->pb, 8, slevel & 0xff);
2217
                else{
2218
                    put_bits(&s->pb, 8, 128);
2219
                    put_bits(&s->pb, 5, slevel & 0x1f);
2220
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2221
                }
2222
              }else{
2223
                if(level < 64) { // 7-bit level
2224
                        put_bits(&s->pb, 1, 0);
2225
                        put_bits(&s->pb, 1, last);
2226
                        put_bits(&s->pb, 6, run);
2227

    
2228
                        put_bits(&s->pb, 7, slevel & 0x7f);
2229
                    } else {
2230
                        /* 11-bit level */
2231
                        put_bits(&s->pb, 1, 1);
2232
                        put_bits(&s->pb, 1, last);
2233
                        put_bits(&s->pb, 6, run);
2234

    
2235
                        put_bits(&s->pb, 11, slevel & 0x7ff);
2236
                    }
2237
              }
2238
            } else {
2239
                put_bits(&s->pb, 1, sign);
2240
            }
2241
            last_non_zero = i;
2242
        }
2243
    }
2244
}
2245
#endif
2246

    
2247
#ifdef CONFIG_ENCODERS
2248

    
2249
/***************************************************/
2250
/**
2251
 * add mpeg4 stuffing bits (01...1)
2252
 */
2253
void ff_mpeg4_stuffing(PutBitContext * pbc)
2254
{
2255
    int length;
2256
    put_bits(pbc, 1, 0);
2257
    length= (-put_bits_count(pbc))&7;
2258
    if(length) put_bits(pbc, length, (1<<length)-1);
2259
}
2260

    
2261
/* must be called before writing the header */
2262
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2263
    int time_div, time_mod;
2264

    
2265
    assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2266
    s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2267

    
2268
    time_div= s->time/s->avctx->time_base.den;
2269
    time_mod= s->time%s->avctx->time_base.den;
2270

    
2271
    if(s->pict_type==B_TYPE){
2272
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2273
        assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2274
        ff_mpeg4_init_direct_mv(s);
2275
    }else{
2276
        s->last_time_base= s->time_base;
2277
        s->time_base= time_div;
2278
        s->pp_time= s->time - s->last_non_b_time;
2279
        s->last_non_b_time= s->time;
2280
        assert(picture_number==0 || s->pp_time > 0);
2281
    }
2282
}
2283

    
2284
static void mpeg4_encode_gop_header(MpegEncContext * s){
2285
    int hours, minutes, seconds;
2286
    int64_t time;
2287

    
2288
    put_bits(&s->pb, 16, 0);
2289
    put_bits(&s->pb, 16, GOP_STARTCODE);
2290

    
2291
    time= s->current_picture_ptr->pts;
2292
    if(s->reordered_input_picture[1])
2293
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2294
    time= time*s->avctx->time_base.num;
2295

    
2296
    seconds= time/s->avctx->time_base.den;
2297
    minutes= seconds/60; seconds %= 60;
2298
    hours= minutes/60; minutes %= 60;
2299
    hours%=24;
2300

    
2301
    put_bits(&s->pb, 5, hours);
2302
    put_bits(&s->pb, 6, minutes);
2303
    put_bits(&s->pb, 1, 1);
2304
    put_bits(&s->pb, 6, seconds);
2305

    
2306
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2307
    put_bits(&s->pb, 1, 0); //broken link == NO
2308

    
2309
    s->last_time_base= time / s->avctx->time_base.den;
2310

    
2311
    ff_mpeg4_stuffing(&s->pb);
2312
}
2313

    
2314
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2315
    int profile_and_level_indication;
2316
    int vo_ver_id;
2317

    
2318
    if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2319
        profile_and_level_indication = s->avctx->profile << 4;
2320
    }else if(s->max_b_frames || s->quarter_sample){
2321
        profile_and_level_indication= 0xF0; // adv simple
2322
    }else{
2323
        profile_and_level_indication= 0x00; // simple
2324
    }
2325

    
2326
    if(s->avctx->level != FF_LEVEL_UNKNOWN){
2327
        profile_and_level_indication |= s->avctx->level;
2328
    }else{
2329
        profile_and_level_indication |= 1; //level 1
2330
    }
2331

    
2332
    if(profile_and_level_indication>>4 == 0xF){
2333
        vo_ver_id= 5;
2334
    }else{
2335
        vo_ver_id= 1;
2336
    }
2337

    
2338
    //FIXME levels
2339

    
2340
    put_bits(&s->pb, 16, 0);
2341
    put_bits(&s->pb, 16, VOS_STARTCODE);
2342

    
2343
    put_bits(&s->pb, 8, profile_and_level_indication);
2344

    
2345
    put_bits(&s->pb, 16, 0);
2346
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2347

    
2348
    put_bits(&s->pb, 1, 1);
2349
        put_bits(&s->pb, 4, vo_ver_id);
2350
        put_bits(&s->pb, 3, 1); //priority
2351

    
2352
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
2353

    
2354
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2355

    
2356
    ff_mpeg4_stuffing(&s->pb);
2357
}
2358

    
2359
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2360
{
2361
    int vo_ver_id;
2362

    
2363
    if(s->max_b_frames || s->quarter_sample){
2364
        vo_ver_id= 5;
2365
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2366
    }else{
2367
        vo_ver_id= 1;
2368
        s->vo_type= SIMPLE_VO_TYPE;
2369
    }
2370

    
2371
    put_bits(&s->pb, 16, 0);
2372
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2373
    put_bits(&s->pb, 16, 0);
2374
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2375

    
2376
    put_bits(&s->pb, 1, 0);             /* random access vol */
2377
    put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
2378
    if(s->workaround_bugs & FF_BUG_MS) {
2379
        put_bits(&s->pb, 1, 0);         /* is obj layer id= no */
2380
    } else {
2381
        put_bits(&s->pb, 1, 1);         /* is obj layer id= yes */
2382
        put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2383
        put_bits(&s->pb, 3, 1);         /* is obj layer priority */
2384
    }
2385

    
2386
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2387

    
2388
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2389
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2390
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2391
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2392
    }
2393

    
2394
    if(s->workaround_bugs & FF_BUG_MS) { //
2395
        put_bits(&s->pb, 1, 0);         /* vol control parameters= no @@@ */
2396
    } else {
2397
        put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
2398
        put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
2399
        put_bits(&s->pb, 1, s->low_delay);
2400
        put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
2401
    }
2402

    
2403
    put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2404
    put_bits(&s->pb, 1, 1);             /* marker bit */
2405

    
2406
    put_bits(&s->pb, 16, s->avctx->time_base.den);
2407
    if (s->time_increment_bits < 1)
2408
        s->time_increment_bits = 1;
2409
    put_bits(&s->pb, 1, 1);             /* marker bit */
2410
    put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
2411
    put_bits(&s->pb, 1, 1);             /* marker bit */
2412
    put_bits(&s->pb, 13, s->width);     /* vol width */
2413
    put_bits(&s->pb, 1, 1);             /* marker bit */
2414
    put_bits(&s->pb, 13, s->height);    /* vol height */
2415
    put_bits(&s->pb, 1, 1);             /* marker bit */
2416
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2417
    put_bits(&s->pb, 1, 1);             /* obmc disable */
2418
    if (vo_ver_id == 1) {
2419
        put_bits(&s->pb, 1, s->vol_sprite_usage);       /* sprite enable */
2420
    }else{
2421
        put_bits(&s->pb, 2, s->vol_sprite_usage);       /* sprite enable */
2422
    }
2423

    
2424
    put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
2425
    put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2426

    
2427
    if(s->mpeg_quant){
2428
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2429
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2430
    }
2431

    
2432
    if (vo_ver_id != 1)
2433
        put_bits(&s->pb, 1, s->quarter_sample);
2434
    put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
2435
    s->resync_marker= s->rtp_mode;
2436
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2437
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2438
    if(s->data_partitioning){
2439
        put_bits(&s->pb, 1, 0);         /* no rvlc */
2440
    }
2441

    
2442
    if (vo_ver_id != 1){
2443
        put_bits(&s->pb, 1, 0);         /* newpred */
2444
        put_bits(&s->pb, 1, 0);         /* reduced res vop */
2445
    }
2446
    put_bits(&s->pb, 1, 0);             /* scalability */
2447

    
2448
    ff_mpeg4_stuffing(&s->pb);
2449

    
2450
    /* user data */
2451
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2452
        put_bits(&s->pb, 16, 0);
2453
        put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2454
        ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2455
    }
2456
}
2457

    
2458
/* write mpeg4 VOP header */
2459
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2460
{
2461
    int time_incr;
2462
    int time_div, time_mod;
2463

    
2464
    if(s->pict_type==I_TYPE){
2465
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2466
            if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2467
                mpeg4_encode_visual_object_header(s);
2468
            if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2469
                mpeg4_encode_vol_header(s, 0, 0);
2470
        }
2471
        if(!(s->workaround_bugs & FF_BUG_MS))
2472
            mpeg4_encode_gop_header(s);
2473
    }
2474

    
2475
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2476

    
2477
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2478

    
2479
    put_bits(&s->pb, 16, 0);                /* vop header */
2480
    put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
2481
    put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
2482

    
2483
    assert(s->time>=0);
2484
    time_div= s->time/s->avctx->time_base.den;
2485
    time_mod= s->time%s->avctx->time_base.den;
2486
    time_incr= time_div - s->last_time_base;
2487
    assert(time_incr >= 0);
2488
    while(time_incr--)
2489
        put_bits(&s->pb, 1, 1);
2490

    
2491
    put_bits(&s->pb, 1, 0);
2492

    
2493
    put_bits(&s->pb, 1, 1);                             /* marker */
2494
    put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2495
    put_bits(&s->pb, 1, 1);                             /* marker */
2496
    put_bits(&s->pb, 1, 1);                             /* vop coded */
2497
    if (    s->pict_type == P_TYPE
2498
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2499
        put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2500
    }
2501
    put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2502
    if(!s->progressive_sequence){
2503
         put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2504
         put_bits(&s->pb, 1, s->alternate_scan);
2505
    }
2506
    //FIXME sprite stuff
2507

    
2508
    put_bits(&s->pb, 5, s->qscale);
2509

    
2510
    if (s->pict_type != I_TYPE)
2511
        put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2512
    if (s->pict_type == B_TYPE)
2513
        put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2514
    //    printf("****frame %d\n", picture_number);
2515
}
2516

    
2517
#endif //CONFIG_ENCODERS
2518

    
2519
/**
2520
 * set qscale and update qscale dependent variables.
2521
 */
2522
void ff_set_qscale(MpegEncContext * s, int qscale)
2523
{
2524
    if (qscale < 1)
2525
        qscale = 1;
2526
    else if (qscale > 31)
2527
        qscale = 31;
2528

    
2529
    s->qscale = qscale;
2530
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2531

    
2532
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2533
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2534
}
2535

    
2536
/**
2537
 * predicts the dc.
2538
 * encoding quantized level -> quantized diff
2539
 * decoding quantized diff -> quantized level
2540
 * @param n block index (0-3 are luma, 4-5 are chroma)
2541
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2542
 */
2543
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2544
{
2545
    int a, b, c, wrap, pred, scale, ret;
2546
    int16_t *dc_val;
2547

    
2548
    /* find prediction */
2549
    if (n < 4) {
2550
        scale = s->y_dc_scale;
2551
    } else {
2552
        scale = s->c_dc_scale;
2553
    }
2554
    if(IS_3IV1)
2555
        scale= 8;
2556

    
2557
    wrap= s->block_wrap[n];
2558
    dc_val = s->dc_val[0] + s->block_index[n];
2559

    
2560
    /* B C
2561
     * A X
2562
     */
2563
    a = dc_val[ - 1];
2564
    b = dc_val[ - 1 - wrap];
2565
    c = dc_val[ - wrap];
2566

    
2567
    /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2568
    if(s->first_slice_line && n!=3){
2569
        if(n!=2) b=c= 1024;
2570
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2571
    }
2572
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2573
        if(n==0 || n==4 || n==5)
2574
            b=1024;
2575
    }
2576

    
2577
    if (abs(a - b) < abs(b - c)) {
2578
        pred = c;
2579
        *dir_ptr = 1; /* top */
2580
    } else {
2581
        pred = a;
2582
        *dir_ptr = 0; /* left */
2583
    }
2584
    /* we assume pred is positive */
2585
    pred = FASTDIV((pred + (scale >> 1)), scale);
2586

    
2587
    if(encoding){
2588
        ret = level - pred;
2589
    }else{
2590
        level += pred;
2591
        ret= level;
2592
        if(s->error_resilience>=3){
2593
            if(level<0){
2594
                av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2595
                return -1;
2596
            }
2597
            if(level*scale > 2048 + scale){
2598
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2599
                return -1;
2600
            }
2601
        }
2602
    }
2603
    level *=scale;
2604
    if(level&(~2047)){
2605
        if(level<0)
2606
            level=0;
2607
        else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2608
            level=2047;
2609
    }
2610
    dc_val[0]= level;
2611

    
2612
    return ret;
2613
}
2614

    
2615
/**
2616
 * predicts the ac.
2617
 * @param n block index (0-3 are luma, 4-5 are chroma)
2618
 * @param dir the ac prediction direction
2619
 */
2620
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2621
                   int dir)
2622
{
2623
    int i;
2624
    int16_t *ac_val, *ac_val1;
2625
    int8_t * const qscale_table= s->current_picture.qscale_table;
2626

    
2627
    /* find prediction */
2628
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2629
    ac_val1 = ac_val;
2630
    if (s->ac_pred) {
2631
        if (dir == 0) {
2632
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2633
            /* left prediction */
2634
            ac_val -= 16;
2635

    
2636
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2637
                /* same qscale */
2638
                for(i=1;i<8;i++) {
2639
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2640
                }
2641
            }else{
2642
                /* different qscale, we must rescale */
2643
                for(i=1;i<8;i++) {
2644
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2645
                }
2646
            }
2647
        } else {
2648
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2649
            /* top prediction */
2650
            ac_val -= 16 * s->block_wrap[n];
2651

    
2652
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2653
                /* same qscale */
2654
                for(i=1;i<8;i++) {
2655
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2656
                }
2657
            }else{
2658
                /* different qscale, we must rescale */
2659
                for(i=1;i<8;i++) {
2660
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2661
                }
2662
            }
2663
        }
2664
    }
2665
    /* left copy */
2666
    for(i=1;i<8;i++)
2667
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2668

    
2669
    /* top copy */
2670
    for(i=1;i<8;i++)
2671
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2672

    
2673
}
2674

    
2675
#ifdef CONFIG_ENCODERS
2676

    
2677
/**
2678
 * encodes the dc value.
2679
 * @param n block index (0-3 are luma, 4-5 are chroma)
2680
 */
2681
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2682
{
2683
#if 1
2684
//    if(level<-255 || level>255) printf("dc overflow\n");
2685
    level+=256;
2686
    if (n < 4) {
2687
        /* luminance */
2688
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2689
    } else {
2690
        /* chrominance */
2691
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2692
    }
2693
#else
2694
    int size, v;
2695
    /* find number of bits */
2696
    size = 0;
2697
    v = abs(level);
2698
    while (v) {
2699
        v >>= 1;
2700
        size++;
2701
    }
2702

    
2703
    if (n < 4) {
2704
        /* luminance */
2705
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2706
    } else {
2707
        /* chrominance */
2708
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2709
    }
2710

    
2711
    /* encode remaining bits */
2712
    if (size > 0) {
2713
        if (level < 0)
2714
            level = (-level) ^ ((1 << size) - 1);
2715
        put_bits(&s->pb, size, level);
2716
        if (size > 8)
2717
            put_bits(&s->pb, 1, 1);
2718
    }
2719
#endif
2720
}
2721

    
2722
static inline int mpeg4_get_dc_length(int level, int n){
2723
    if (n < 4) {
2724
        return uni_DCtab_lum_len[level + 256];
2725
    } else {
2726
        return uni_DCtab_chrom_len[level + 256];
2727
    }
2728
}
2729

    
2730
/**
2731
 * encodes a 8x8 block
2732
 * @param n block index (0-3 are luma, 4-5 are chroma)
2733
 */
2734
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2735
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2736
{
2737
    int i, last_non_zero;
2738
#if 0 //variables for the outcommented version
2739
    int code, sign, last;
2740
#endif
2741
    const RLTable *rl;
2742
    uint32_t *bits_tab;
2743
    uint8_t *len_tab;
2744
    const int last_index = s->block_last_index[n];
2745

    
2746
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2747
        /* mpeg4 based DC predictor */
2748
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2749
        if(last_index<1) return;
2750
        i = 1;
2751
        rl = &rl_intra;
2752
        bits_tab= uni_mpeg4_intra_rl_bits;
2753
        len_tab = uni_mpeg4_intra_rl_len;
2754
    } else {
2755
        if(last_index<0) return;
2756
        i = 0;
2757
        rl = &rl_inter;
2758
        bits_tab= uni_mpeg4_inter_rl_bits;
2759
        len_tab = uni_mpeg4_inter_rl_len;
2760
    }
2761

    
2762
    /* AC coefs */
2763
    last_non_zero = i - 1;
2764
#if 1
2765
    for (; i < last_index; i++) {
2766
        int level = block[ scan_table[i] ];
2767
        if (level) {
2768
            int run = i - last_non_zero - 1;
2769
            level+=64;
2770
            if((level&(~127)) == 0){
2771
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2772
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2773
            }else{ //ESC3
2774
                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);
2775
            }
2776
            last_non_zero = i;
2777
        }
2778
    }
2779
    /*if(i<=last_index)*/{
2780
        int level = block[ scan_table[i] ];
2781
        int run = i - last_non_zero - 1;
2782
        level+=64;
2783
        if((level&(~127)) == 0){
2784
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2785
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2786
        }else{ //ESC3
2787
            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);
2788
        }
2789
    }
2790
#else
2791
    for (; i <= last_index; i++) {
2792
        const int slevel = block[ scan_table[i] ];
2793
        if (slevel) {
2794
            int level;
2795
            int run = i - last_non_zero - 1;
2796
            last = (i == last_index);
2797
            sign = 0;
2798
            level = slevel;
2799
            if (level < 0) {
2800
                sign = 1;
2801
                level = -level;
2802
            }
2803
            code = get_rl_index(rl, last, run, level);
2804
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2805
            if (code == rl->n) {
2806
                int level1, run1;
2807
                level1 = level - rl->max_level[last][run];
2808
                if (level1 < 1)
2809
                    goto esc2;
2810
                code = get_rl_index(rl, last, run, level1);
2811
                if (code == rl->n) {
2812
                esc2:
2813
                    put_bits(ac_pb, 1, 1);
2814
                    if (level > MAX_LEVEL)
2815
                        goto esc3;
2816
                    run1 = run - rl->max_run[last][level] - 1;
2817
                    if (run1 < 0)
2818
                        goto esc3;
2819
                    code = get_rl_index(rl, last, run1, level);
2820
                    if (code == rl->n) {
2821
                    esc3:
2822
                        /* third escape */
2823
                        put_bits(ac_pb, 1, 1);
2824
                        put_bits(ac_pb, 1, last);
2825
                        put_bits(ac_pb, 6, run);
2826
                        put_bits(ac_pb, 1, 1);
2827
                        put_bits(ac_pb, 12, slevel & 0xfff);
2828
                        put_bits(ac_pb, 1, 1);
2829
                    } else {
2830
                        /* second escape */
2831
                        put_bits(ac_pb, 1, 0);
2832
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2833
                        put_bits(ac_pb, 1, sign);
2834
                    }
2835
                } else {
2836
                    /* first escape */
2837
                    put_bits(ac_pb, 1, 0);
2838
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2839
                    put_bits(ac_pb, 1, sign);
2840
                }
2841
            } else {
2842
                put_bits(ac_pb, 1, sign);
2843
            }
2844
            last_non_zero = i;
2845
        }
2846
    }
2847
#endif
2848
}
2849

    
2850
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2851
                               uint8_t *scan_table)
2852
{
2853
    int i, last_non_zero;
2854
    const RLTable *rl;
2855
    uint8_t *len_tab;
2856
    const int last_index = s->block_last_index[n];
2857
    int len=0;
2858

    
2859
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2860
        /* mpeg4 based DC predictor */
2861
        len += mpeg4_get_dc_length(intra_dc, n);
2862
        if(last_index<1) return len;
2863
        i = 1;
2864
        rl = &rl_intra;
2865
        len_tab = uni_mpeg4_intra_rl_len;
2866
    } else {
2867
        if(last_index<0) return 0;
2868
        i = 0;
2869
        rl = &rl_inter;
2870
        len_tab = uni_mpeg4_inter_rl_len;
2871
    }
2872

    
2873
    /* AC coefs */
2874
    last_non_zero = i - 1;
2875
    for (; i < last_index; i++) {
2876
        int level = block[ scan_table[i] ];
2877
        if (level) {
2878
            int run = i - last_non_zero - 1;
2879
            level+=64;
2880
            if((level&(~127)) == 0){
2881
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2882
                len += len_tab[index];
2883
            }else{ //ESC3
2884
                len += 7+2+1+6+1+12+1;
2885
            }
2886
            last_non_zero = i;
2887
        }
2888
    }
2889
    /*if(i<=last_index)*/{
2890
        int level = block[ scan_table[i] ];
2891
        int run = i - last_non_zero - 1;
2892
        level+=64;
2893
        if((level&(~127)) == 0){
2894
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2895
            len += len_tab[index];
2896
        }else{ //ESC3
2897
            len += 7+2+1+6+1+12+1;
2898
        }
2899
    }
2900

    
2901
    return len;
2902
}
2903

    
2904
#endif
2905

    
2906

    
2907
/***********************************************/
2908
/* decoding */
2909

    
2910
static VLC intra_MCBPC_vlc;
2911
static VLC inter_MCBPC_vlc;
2912
static VLC cbpy_vlc;
2913
static VLC mv_vlc;
2914
static VLC dc_lum, dc_chrom;
2915
static VLC sprite_trajectory;
2916
static VLC mb_type_b_vlc;
2917
static VLC h263_mbtype_b_vlc;
2918
static VLC cbpc_b_vlc;
2919

    
2920
void init_vlc_rl(RLTable *rl, int use_static)
2921
{
2922
    int i, q;
2923

    
2924
    /* Return if static table is already initialized */
2925
    if(use_static && rl->rl_vlc[0])
2926
        return;
2927

    
2928
    init_vlc(&rl->vlc, 9, rl->n + 1,
2929
             &rl->table_vlc[0][1], 4, 2,
2930
             &rl->table_vlc[0][0], 4, 2, use_static);
2931

    
2932

    
2933
    for(q=0; q<32; q++){
2934
        int qmul= q*2;
2935
        int qadd= (q-1)|1;
2936

    
2937
        if(q==0){
2938
            qmul=1;
2939
            qadd=0;
2940
        }
2941
        if(use_static)
2942
            rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2943
        else
2944
            rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2945
        for(i=0; i<rl->vlc.table_size; i++){
2946
            int code= rl->vlc.table[i][0];
2947
            int len = rl->vlc.table[i][1];
2948
            int level, run;
2949

    
2950
            if(len==0){ // illegal code
2951
                run= 66;
2952
                level= MAX_LEVEL;
2953
            }else if(len<0){ //more bits needed
2954
                run= 0;
2955
                level= code;
2956
            }else{
2957
                if(code==rl->n){ //esc
2958
                    run= 66;
2959
                    level= 0;
2960
                }else{
2961
                    run=   rl->table_run  [code] + 1;
2962
                    level= rl->table_level[code] * qmul + qadd;
2963
                    if(code >= rl->last) run+=192;
2964
                }
2965
            }
2966
            rl->rl_vlc[q][i].len= len;
2967
            rl->rl_vlc[q][i].level= level;
2968
            rl->rl_vlc[q][i].run= run;
2969
        }
2970
    }
2971
}
2972

    
2973
/* init vlcs */
2974

    
2975
/* XXX: find a better solution to handle static init */
2976
void h263_decode_init_vlc(MpegEncContext *s)
2977
{
2978
    static int done = 0;
2979

    
2980
    if (!done) {
2981
        done = 1;
2982

    
2983
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2984
                 intra_MCBPC_bits, 1, 1,
2985
                 intra_MCBPC_code, 1, 1, 1);
2986
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2987
                 inter_MCBPC_bits, 1, 1,
2988
                 inter_MCBPC_code, 1, 1, 1);
2989
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2990
                 &cbpy_tab[0][1], 2, 1,
2991
                 &cbpy_tab[0][0], 2, 1, 1);
2992
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2993
                 &mvtab[0][1], 2, 1,
2994
                 &mvtab[0][0], 2, 1, 1);
2995
        init_rl(&rl_inter, static_rl_table_store[0]);
2996
        init_rl(&rl_intra, static_rl_table_store[1]);
2997
        init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2998
        init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2999
        init_rl(&rl_intra_aic, static_rl_table_store[2]);
3000
        init_vlc_rl(&rl_inter, 1);
3001
        init_vlc_rl(&rl_intra, 1);
3002
        init_vlc_rl(&rvlc_rl_inter, 1);
3003
        init_vlc_rl(&rvlc_rl_intra, 1);
3004
        init_vlc_rl(&rl_intra_aic, 1);
3005
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
3006
                 &DCtab_lum[0][1], 2, 1,
3007
                 &DCtab_lum[0][0], 2, 1, 1);
3008
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
3009
                 &DCtab_chrom[0][1], 2, 1,
3010
                 &DCtab_chrom[0][0], 2, 1, 1);
3011
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
3012
                 &sprite_trajectory_tab[0][1], 4, 2,
3013
                 &sprite_trajectory_tab[0][0], 4, 2, 1);
3014
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
3015
                 &mb_type_b_tab[0][1], 2, 1,
3016
                 &mb_type_b_tab[0][0], 2, 1, 1);
3017
        init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
3018
                 &h263_mbtype_b_tab[0][1], 2, 1,
3019
                 &h263_mbtype_b_tab[0][0], 2, 1, 1);
3020
        init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
3021
                 &cbpc_b_tab[0][1], 2, 1,
3022
                 &cbpc_b_tab[0][0], 2, 1, 1);
3023
    }
3024
}
3025

    
3026
/**
3027
 * Get the GOB height based on picture height.
3028
 */
3029
int ff_h263_get_gob_height(MpegEncContext *s){
3030
    if (s->height <= 400)
3031
        return 1;
3032
    else if (s->height <= 800)
3033
        return  2;
3034
    else
3035
        return 4;
3036
}
3037

    
3038
int ff_h263_decode_mba(MpegEncContext *s)
3039
{
3040
    int i, mb_pos;
3041

    
3042
    for(i=0; i<6; i++){
3043
        if(s->mb_num-1 <= ff_mba_max[i]) break;
3044
    }
3045
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
3046
    s->mb_x= mb_pos % s->mb_width;
3047
    s->mb_y= mb_pos / s->mb_width;
3048

    
3049
    return mb_pos;
3050
}
3051

    
3052
void ff_h263_encode_mba(MpegEncContext *s)
3053
{
3054
    int i, mb_pos;
3055

    
3056
    for(i=0; i<6; i++){
3057
        if(s->mb_num-1 <= ff_mba_max[i]) break;
3058
    }
3059
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
3060
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
3061
}
3062

    
3063
/**
3064
 * decodes the group of blocks header or slice header.
3065
 * @return <0 if an error occured
3066
 */
3067
static int h263_decode_gob_header(MpegEncContext *s)
3068
{
3069
    unsigned int val, gfid, gob_number;
3070
    int left;
3071

    
3072
    /* Check for GOB Start Code */
3073
    val = show_bits(&s->gb, 16);
3074
    if(val)
3075
        return -1;
3076

    
3077
        /* We have a GBSC probably with GSTUFF */
3078
    skip_bits(&s->gb, 16); /* Drop the zeros */
3079
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3080
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3081
    for(;left>13; left--){
3082
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3083
    }
3084
    if(left<=13)
3085
        return -1;
3086

    
3087
    if(s->h263_slice_structured){
3088
        if(get_bits1(&s->gb)==0)
3089
            return -1;
3090

    
3091
        ff_h263_decode_mba(s);
3092

    
3093
        if(s->mb_num > 1583)
3094
            if(get_bits1(&s->gb)==0)
3095
                return -1;
3096

    
3097
        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3098
        if(get_bits1(&s->gb)==0)
3099
            return -1;
3100
        gfid = get_bits(&s->gb, 2); /* GFID */
3101
    }else{
3102
        gob_number = get_bits(&s->gb, 5); /* GN */
3103
        s->mb_x= 0;
3104
        s->mb_y= s->gob_index* gob_number;
3105
        gfid = get_bits(&s->gb, 2); /* GFID */
3106
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3107
    }
3108

    
3109
    if(s->mb_y >= s->mb_height)
3110
        return -1;
3111

    
3112
    if(s->qscale==0)
3113
        return -1;
3114

    
3115
    return 0;
3116
}
3117

    
3118
static inline void memsetw(short *tab, int val, int n)
3119
{
3120
    int i;
3121
    for(i=0;i<n;i++)
3122
        tab[i] = val;
3123
}
3124

    
3125
#ifdef CONFIG_ENCODERS
3126

    
3127
void ff_mpeg4_init_partitions(MpegEncContext *s)
3128
{
3129
    uint8_t *start= pbBufPtr(&s->pb);
3130
    uint8_t *end= s->pb.buf_end;
3131
    int size= end - start;
3132
    int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3133
    int tex_size= (size - 2*pb_size)&(~3);
3134

    
3135
    set_put_bits_buffer_size(&s->pb, pb_size);
3136
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3137
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3138
}
3139

    
3140
void ff_mpeg4_merge_partitions(MpegEncContext *s)
3141
{
3142
    const int pb2_len   = put_bits_count(&s->pb2   );
3143
    const int tex_pb_len= put_bits_count(&s->tex_pb);
3144
    const int bits= put_bits_count(&s->pb);
3145

    
3146
    if(s->pict_type==I_TYPE){
3147
        put_bits(&s->pb, 19, DC_MARKER);
3148
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3149
        s->i_tex_bits+= tex_pb_len;
3150
    }else{
3151
        put_bits(&s->pb, 17, MOTION_MARKER);
3152
        s->misc_bits+=17 + pb2_len;
3153
        s->mv_bits+= bits - s->last_bits;
3154
        s->p_tex_bits+= tex_pb_len;
3155
    }
3156

    
3157
    flush_put_bits(&s->pb2);
3158
    flush_put_bits(&s->tex_pb);
3159

    
3160
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3161
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3162
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3163
    s->last_bits= put_bits_count(&s->pb);
3164
}
3165

    
3166
#endif //CONFIG_ENCODERS
3167

    
3168
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3169
    switch(s->pict_type){
3170
        case I_TYPE:
3171
            return 16;
3172
        case P_TYPE:
3173
        case S_TYPE:
3174
            return s->f_code+15;
3175
        case B_TYPE:
3176
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3177
        default:
3178
            return -1;
3179
    }
3180
}
3181

    
3182
#ifdef CONFIG_ENCODERS
3183

    
3184
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3185
{
3186
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3187

    
3188
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3189
    put_bits(&s->pb, 1, 1);
3190

    
3191
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3192
    put_bits(&s->pb, s->quant_precision, s->qscale);
3193
    put_bits(&s->pb, 1, 0); /* no HEC */
3194
}
3195

    
3196
#endif //CONFIG_ENCODERS
3197

    
3198
/**
3199
 * check if the next stuff is a resync marker or the end.
3200
 * @return 0 if not
3201
 */
3202
static inline int mpeg4_is_resync(MpegEncContext *s){
3203
    int bits_count= get_bits_count(&s->gb);
3204
    int v= show_bits(&s->gb, 16);
3205

    
3206
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3207
        return 0;
3208
    }
3209

    
3210
    while(v<=0xFF){
3211
        if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3212
            break;
3213
        skip_bits(&s->gb, 8+s->pict_type);
3214
        bits_count+= 8+s->pict_type;
3215
        v= show_bits(&s->gb, 16);
3216
    }
3217

    
3218
    if(bits_count + 8 >= s->gb.size_in_bits){
3219
        v>>=8;
3220
        v|= 0x7F >> (7-(bits_count&7));
3221

    
3222
        if(v==0x7F)
3223
            return 1;
3224
    }else{
3225
        if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3226
            int len;
3227
            GetBitContext gb= s->gb;
3228

    
3229
            skip_bits(&s->gb, 1);
3230
            align_get_bits(&s->gb);
3231

    
3232
            for(len=0; len<32; len++){
3233
                if(get_bits1(&s->gb)) break;
3234
            }
3235

    
3236
            s->gb= gb;
3237

    
3238
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3239
                return 1;
3240
        }
3241
    }
3242
    return 0;
3243
}
3244

    
3245
/**
3246
 * decodes the next video packet.
3247
 * @return <0 if something went wrong
3248
 */
3249
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3250
{
3251
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3252
    int header_extension=0, mb_num, len;
3253

    
3254
    /* is there enough space left for a video packet + header */
3255
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3256

    
3257
    for(len=0; len<32; len++){
3258
        if(get_bits1(&s->gb)) break;
3259
    }
3260

    
3261
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3262
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3263
        return -1;
3264
    }
3265

    
3266
    if(s->shape != RECT_SHAPE){
3267
        header_extension= get_bits1(&s->gb);
3268
        //FIXME more stuff here
3269
    }
3270

    
3271
    mb_num= get_bits(&s->gb, mb_num_bits);
3272
    if(mb_num>=s->mb_num){
3273
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3274
        return -1;
3275
    }
3276
    if(s->pict_type == B_TYPE){
3277
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3278
        if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3279
    }
3280

    
3281
    s->mb_x= mb_num % s->mb_width;
3282
    s->mb_y= mb_num / s->mb_width;
3283

    
3284
    if(s->shape != BIN_ONLY_SHAPE){
3285
        int qscale= get_bits(&s->gb, s->quant_precision);
3286
        if(qscale)
3287
            s->chroma_qscale=s->qscale= qscale;
3288
    }
3289

    
3290
    if(s->shape == RECT_SHAPE){
3291
        header_extension= get_bits1(&s->gb);
3292
    }
3293
    if(header_extension){
3294
        int time_increment;
3295
        int time_incr=0;
3296

    
3297
        while (get_bits1(&s->gb) != 0)
3298
            time_incr++;
3299

    
3300
        check_marker(&s->gb, "before time_increment in video packed header");
3301
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3302
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3303

    
3304
        skip_bits(&s->gb, 2); /* vop coding type */
3305
        //FIXME not rect stuff here
3306

    
3307
        if(s->shape != BIN_ONLY_SHAPE){
3308
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3309
//FIXME don't just ignore everything
3310
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3311
                mpeg4_decode_sprite_trajectory(s, &s->gb);
3312
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3313
            }
3314

    
3315
            //FIXME reduced res stuff here
3316

    
3317
            if (s->pict_type != I_TYPE) {
3318
                int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3319
                if(f_code==0){
3320
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3321
                }
3322
            }
3323
            if (s->pict_type == B_TYPE) {
3324
                int b_code = get_bits(&s->gb, 3);
3325
                if(b_code==0){
3326
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3327
                }
3328
            }
3329
        }
3330
    }
3331
    //FIXME new-pred stuff
3332

    
3333
//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));
3334

    
3335
    return 0;
3336
}
3337

    
3338
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3339
{
3340
    int c_wrap, c_xy, l_wrap, l_xy;
3341

    
3342
    l_wrap= s->b8_stride;
3343
    l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3344
    c_wrap= s->mb_stride;
3345
    c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3346

    
3347
#if 0
3348
    /* clean DC */
3349
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3350
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3351
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3352
#endif
3353

    
3354
    /* clean AC */
3355
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3356
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3357
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3358

    
3359
    /* clean MV */
3360
    // we can't clear the MVs as they might be needed by a b frame
3361
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3362
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3363
    s->last_mv[0][0][0]=
3364
    s->last_mv[0][0][1]=
3365
    s->last_mv[1][0][0]=
3366
    s->last_mv[1][0][1]= 0;
3367
}
3368

    
3369
/**
3370
 * decodes the group of blocks / video packet header.
3371
 * @return <0 if no resync found
3372
 */
3373
int ff_h263_resync(MpegEncContext *s){
3374
    int left, ret;
3375

    
3376
    if(s->codec_id==CODEC_ID_MPEG4){
3377
        skip_bits1(&s->gb);
3378
        align_get_bits(&s->gb);
3379
    }
3380

    
3381
    if(show_bits(&s->gb, 16)==0){
3382
        if(s->codec_id==CODEC_ID_MPEG4)
3383
            ret= mpeg4_decode_video_packet_header(s);
3384
        else
3385
            ret= h263_decode_gob_header(s);
3386
        if(ret>=0)
3387
            return 0;
3388
    }
3389
    //ok, it's not where its supposed to be ...
3390
    s->gb= s->last_resync_gb;
3391
    align_get_bits(&s->gb);
3392
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3393

    
3394
    for(;left>16+1+5+5; left-=8){
3395
        if(show_bits(&s->gb, 16)==0){
3396
            GetBitContext bak= s->gb;
3397

    
3398
            if(s->codec_id==CODEC_ID_MPEG4)
3399
                ret= mpeg4_decode_video_packet_header(s);
3400
            else
3401
                ret= h263_decode_gob_header(s);
3402
            if(ret>=0)
3403
                return 0;
3404

    
3405
            s->gb= bak;
3406
        }
3407
        skip_bits(&s->gb, 8);
3408
    }
3409

    
3410
    return -1;
3411
}
3412

    
3413
/**
3414
 * gets the average motion vector for a GMC MB.
3415
 * @param n either 0 for the x component or 1 for y
3416
 * @returns the average MV for a GMC MB
3417
 */
3418
static inline int get_amv(MpegEncContext *s, int n){
3419
    int x, y, mb_v, sum, dx, dy, shift;
3420
    int len = 1 << (s->f_code + 4);
3421
    const int a= s->sprite_warping_accuracy;
3422

    
3423
    if(s->workaround_bugs & FF_BUG_AMV)
3424
        len >>= s->quarter_sample;
3425

    
3426
    if(s->real_sprite_warping_points==1){
3427
        if(s->divx_version==500 && s->divx_build==413)
3428
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3429
        else
3430
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3431
    }else{
3432
        dx= s->sprite_delta[n][0];
3433
        dy= s->sprite_delta[n][1];
3434
        shift= s->sprite_shift[0];
3435
        if(n) dy -= 1<<(shift + a + 1);
3436
        else  dx -= 1<<(shift + a + 1);
3437
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3438

    
3439
        sum=0;
3440
        for(y=0; y<16; y++){
3441
            int v;
3442

    
3443
            v= mb_v + dy*y;
3444
            //XXX FIXME optimize
3445
            for(x=0; x<16; x++){
3446
                sum+= v>>shift;
3447
                v+= dx;
3448
            }
3449
        }
3450
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3451
    }
3452

    
3453
    if      (sum < -len) sum= -len;
3454
    else if (sum >= len) sum= len-1;
3455

    
3456
    return sum;
3457
}
3458

    
3459
/**
3460
 * decodes first partition.
3461
 * @return number of MBs decoded or <0 if an error occured
3462
 */
3463
static int mpeg4_decode_partition_a(MpegEncContext *s){
3464
    int mb_num;
3465
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3466

    
3467
    /* decode first partition */
3468
    mb_num=0;
3469
    s->first_slice_line=1;
3470
    for(; s->mb_y<s->mb_height; s->mb_y++){
3471
        ff_init_block_index(s);
3472
        for(; s->mb_x<s->mb_width; s->mb_x++){
3473
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3474
            int cbpc;
3475
            int dir=0;
3476

    
3477
            mb_num++;
3478
            ff_update_block_index(s);
3479
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3480
                s->first_slice_line=0;
3481

    
3482
            if(s->pict_type==I_TYPE){
3483
                int i;
3484

    
3485
                do{
3486
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
3487
                        return mb_num-1;
3488
                    }
3489

    
3490
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3491
                    if (cbpc < 0){
3492
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3493
                        return -1;
3494
                    }
3495
                }while(cbpc == 8);
3496

    
3497
                s->cbp_table[xy]= cbpc & 3;
3498
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3499
                s->mb_intra = 1;
3500

    
3501
                if(cbpc & 4) {
3502
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3503
                }
3504
                s->current_picture.qscale_table[xy]= s->qscale;
3505

    
3506
                s->mbintra_table[xy]= 1;
3507
                for(i=0; i<6; i++){
3508
                    int dc_pred_dir;
3509
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3510
                    if(dc < 0){
3511
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3512
                        return -1;
3513
                    }
3514
                    dir<<=1;
3515
                    if(dc_pred_dir) dir|=1;
3516
                }
3517
                s->pred_dir_table[xy]= dir;
3518
            }else{ /* P/S_TYPE */
3519
                int mx, my, pred_x, pred_y, bits;
3520
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3521
                const int stride= s->b8_stride*2;
3522

    
3523
try_again:
3524
                bits= show_bits(&s->gb, 17);
3525
                if(bits==MOTION_MARKER){
3526
                    return mb_num-1;
3527
                }
3528
                skip_bits1(&s->gb);
3529
                if(bits&0x10000){
3530
                    /* skip mb */
3531
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3532
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3533
                        mx= get_amv(s, 0);
3534
                        my= get_amv(s, 1);
3535
                    }else{
3536
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3537
                        mx=my=0;
3538
                    }
3539
                    mot_val[0       ]= mot_val[2       ]=
3540
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3541
                    mot_val[1       ]= mot_val[3       ]=
3542
                    mot_val[1+stride]= mot_val[3+stride]= my;
3543

    
3544
                    if(s->mbintra_table[xy])
3545
                        ff_clean_intra_table_entries(s);
3546
                    continue;
3547
                }
3548

    
3549
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3550
                if (cbpc < 0){
3551
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3552
                    return -1;
3553
                }
3554
                if(cbpc == 20)
3555
                    goto try_again;
3556

    
3557
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3558

    
3559
                s->mb_intra = ((cbpc & 4) != 0);
3560

    
3561
                if(s->mb_intra){
3562
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3563
                    s->mbintra_table[xy]= 1;
3564
                    mot_val[0       ]= mot_val[2       ]=
3565
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3566
                    mot_val[1       ]= mot_val[3       ]=
3567
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3568
                }else{
3569
                    if(s->mbintra_table[xy])
3570
                        ff_clean_intra_table_entries(s);
3571

    
3572
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3573
                        s->mcsel= get_bits1(&s->gb);
3574
                    else s->mcsel= 0;
3575

    
3576
                    if ((cbpc & 16) == 0) {
3577
                        /* 16x16 motion prediction */
3578

    
3579
                        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3580
                        if(!s->mcsel){
3581
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3582
                            if (mx >= 0xffff)
3583
                                return -1;
3584

    
3585
                            my = h263_decode_motion(s, pred_y, s->f_code);
3586
                            if (my >= 0xffff)
3587
                                return -1;
3588
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3589
                        } else {
3590
                            mx = get_amv(s, 0);
3591
                            my = get_amv(s, 1);
3592
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3593
                        }
3594

    
3595
                        mot_val[0       ]= mot_val[2       ] =
3596
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3597
                        mot_val[1       ]= mot_val[3       ]=
3598
                        mot_val[1+stride]= mot_val[3+stride]= my;
3599
                    } else {
3600
                        int i;
3601
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3602
                        for(i=0;i<4;i++) {
3603
                            int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3604
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3605
                            if (mx >= 0xffff)
3606
                                return -1;
3607

    
3608
                            my = h263_decode_motion(s, pred_y, s->f_code);
3609
                            if (my >= 0xffff)
3610
                                return -1;
3611
                            mot_val[0] = mx;
3612
                            mot_val[1] = my;
3613
                        }
3614
                    }
3615
                }
3616
            }
3617
        }
3618
        s->mb_x= 0;
3619
    }
3620

    
3621
    return mb_num;
3622
}
3623

    
3624
/**
3625
 * decode second partition.
3626
 * @return <0 if an error occured
3627
 */
3628
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3629
    int mb_num=0;
3630
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3631

    
3632
    s->mb_x= s->resync_mb_x;
3633
    s->first_slice_line=1;
3634
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3635
        ff_init_block_index(s);
3636
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3637
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3638

    
3639
            mb_num++;
3640
            ff_update_block_index(s);
3641
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3642
                s->first_slice_line=0;
3643

    
3644
            if(s->pict_type==I_TYPE){
3645
                int ac_pred= get_bits1(&s->gb);
3646
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3647
                if(cbpy<0){
3648
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3649
                    return -1;
3650
                }
3651

    
3652
                s->cbp_table[xy]|= cbpy<<2;
3653
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3654
            }else{ /* P || S_TYPE */
3655
                if(IS_INTRA(s->current_picture.mb_type[xy])){
3656
                    int dir=0,i;
3657
                    int ac_pred = get_bits1(&s->gb);
3658
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3659

    
3660
                    if(cbpy<0){
3661
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3662
                        return -1;
3663
                    }
3664

    
3665
                    if(s->cbp_table[xy] & 8) {
3666
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3667
                    }
3668
                    s->current_picture.qscale_table[xy]= s->qscale;
3669

    
3670
                    for(i=0; i<6; i++){
3671
                        int dc_pred_dir;
3672
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3673
                        if(dc < 0){
3674
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3675
                            return -1;
3676
                        }
3677
                        dir<<=1;
3678
                        if(dc_pred_dir) dir|=1;
3679
                    }
3680
                    s->cbp_table[xy]&= 3; //remove dquant
3681
                    s->cbp_table[xy]|= cbpy<<2;
3682
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3683
                    s->pred_dir_table[xy]= dir;
3684
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3685
                    s->current_picture.qscale_table[xy]= s->qscale;
3686
                    s->cbp_table[xy]= 0;
3687
                }else{
3688
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3689

    
3690
                    if(cbpy<0){
3691
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3692
                        return -1;
3693
                    }
3694

    
3695
                    if(s->cbp_table[xy] & 8) {
3696
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3697
                    }
3698
                    s->current_picture.qscale_table[xy]= s->qscale;
3699

    
3700
                    s->cbp_table[xy]&= 3; //remove dquant
3701
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3702
                }
3703
            }
3704
        }
3705
        if(mb_num >= mb_count) return 0;
3706
        s->mb_x= 0;
3707
    }
3708
    return 0;
3709
}
3710

    
3711
/**
3712
 * decodes the first & second partition
3713
 * @return <0 if error (and sets error type in the error_status_table)
3714
 */
3715
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3716
{
3717
    int mb_num;
3718
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3719
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3720

    
3721
    mb_num= mpeg4_decode_partition_a(s);
3722
    if(mb_num<0){
3723
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3724
        return -1;
3725
    }
3726

    
3727
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3728
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3729
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3730
        return -1;
3731
    }
3732

    
3733
    s->mb_num_left= mb_num;
3734

    
3735
    if(s->pict_type==I_TYPE){
3736
        while(show_bits(&s->gb, 9) == 1)
3737
            skip_bits(&s->gb, 9);
3738
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3739
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3740
            return -1;
3741
        }
3742
    }else{
3743
        while(show_bits(&s->gb, 10) == 1)
3744
            skip_bits(&s->gb, 10);
3745
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3746
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3747
            return -1;
3748
        }
3749
    }
3750
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3751

    
3752
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3753
        if(s->pict_type==P_TYPE)
3754
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3755
        return -1;
3756
    }else{
3757
        if(s->pict_type==P_TYPE)
3758
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3759
    }
3760

    
3761
    return 0;
3762
}
3763

    
3764
/**
3765
 * decode partition C of one MB.
3766
 * @return <0 if an error occured
3767
 */
3768
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3769
{
3770
    int cbp, mb_type;
3771
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3772

    
3773
    mb_type= s->current_picture.mb_type[xy];
3774
    cbp = s->cbp_table[xy];
3775

    
3776
    s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3777

    
3778
    if(s->current_picture.qscale_table[xy] != s->qscale){
3779
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3780
    }
3781

    
3782
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3783
        int i;
3784
        for(i=0; i<4; i++){
3785
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3786
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3787
        }
3788
        s->mb_intra = IS_INTRA(mb_type);
3789

    
3790
        if (IS_SKIP(mb_type)) {
3791
            /* skip mb */
3792
            for(i=0;i<6;i++)
3793
                s->block_last_index[i] = -1;
3794
            s->mv_dir = MV_DIR_FORWARD;
3795
            s->mv_type = MV_TYPE_16X16;
3796
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3797
                s->mcsel=1;
3798
                s->mb_skipped = 0;
3799
            }else{
3800
                s->mcsel=0;
3801
                s->mb_skipped = 1;
3802
            }
3803
        }else if(s->mb_intra){
3804
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3805
        }else if(!s->mb_intra){
3806
//            s->mcsel= 0; //FIXME do we need to init that
3807

    
3808
            s->mv_dir = MV_DIR_FORWARD;
3809
            if (IS_8X8(mb_type)) {
3810
                s->mv_type = MV_TYPE_8X8;
3811
            } else {
3812
                s->mv_type = MV_TYPE_16X16;
3813
            }
3814
        }
3815
    } else { /* I-Frame */
3816
        s->mb_intra = 1;
3817
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3818
    }
3819

    
3820
    if (!IS_SKIP(mb_type)) {
3821
        int i;
3822
        s->dsp.clear_blocks(s->block[0]);
3823
        /* decode each block */
3824
        for (i = 0; i < 6; i++) {
3825
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3826
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3827
                return -1;
3828
            }
3829
            cbp+=cbp;
3830
        }
3831
    }
3832

    
3833
    /* per-MB end of slice check */
3834

    
3835
    if(--s->mb_num_left <= 0){
3836
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3837
        if(mpeg4_is_resync(s))
3838
            return SLICE_END;
3839
        else
3840
            return SLICE_NOEND;
3841
    }else{
3842
        if(mpeg4_is_resync(s)){
3843
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3844
            if(s->cbp_table[xy+delta])
3845
                return SLICE_END;
3846
        }
3847
        return SLICE_OK;
3848
    }
3849
}
3850

    
3851
/**
3852
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3853
 */
3854
static void preview_obmc(MpegEncContext *s){
3855
    GetBitContext gb= s->gb;
3856

    
3857
    int cbpc, i, pred_x, pred_y, mx, my;
3858
    int16_t *mot_val;
3859
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3860
    const int stride= s->b8_stride*2;
3861

    
3862
    for(i=0; i<4; i++)
3863
        s->block_index[i]+= 2;
3864
    for(i=4; i<6; i++)
3865
        s->block_index[i]+= 1;
3866
    s->mb_x++;
3867

    
3868
    assert(s->pict_type == P_TYPE);
3869

    
3870
    do{
3871
        if (get_bits1(&s->gb)) {
3872
            /* skip mb */
3873
            mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3874
            mot_val[0       ]= mot_val[2       ]=
3875
            mot_val[0+stride]= mot_val[2+stride]= 0;
3876
            mot_val[1       ]= mot_val[3       ]=
3877
            mot_val[1+stride]= mot_val[3+stride]= 0;
3878

    
3879
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3880
            goto end;
3881
        }
3882
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3883
    }while(cbpc == 20);
3884

    
3885
    if(cbpc & 4){
3886
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3887
    }else{
3888
        get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3889
        if (cbpc & 8) {
3890
            if(s->modified_quant){
3891
                if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3892
                else                  skip_bits(&s->gb, 5);
3893
            }else
3894
                skip_bits(&s->gb, 2);
3895
        }
3896

    
3897
        if ((cbpc & 16) == 0) {
3898
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3899
                /* 16x16 motion prediction */
3900
                mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3901
                if (s->umvplus)
3902
                   mx = h263p_decode_umotion(s, pred_x);
3903
                else
3904
                   mx = h263_decode_motion(s, pred_x, 1);
3905

    
3906
                if (s->umvplus)
3907
                   my = h263p_decode_umotion(s, pred_y);
3908
                else
3909
                   my = h263_decode_motion(s, pred_y, 1);
3910

    
3911
                mot_val[0       ]= mot_val[2       ]=
3912
                mot_val[0+stride]= mot_val[2+stride]= mx;
3913
                mot_val[1       ]= mot_val[3       ]=
3914
                mot_val[1+stride]= mot_val[3+stride]= my;
3915
        } else {
3916
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3917
            for(i=0;i<4;i++) {
3918
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3919
                if (s->umvplus)
3920
                  mx = h263p_decode_umotion(s, pred_x);
3921
                else
3922
                  mx = h263_decode_motion(s, pred_x, 1);
3923

    
3924
                if (s->umvplus)
3925
                  my = h263p_decode_umotion(s, pred_y);
3926
                else
3927
                  my = h263_decode_motion(s, pred_y, 1);
3928
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3929
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3930
                mot_val[0] = mx;
3931
                mot_val[1] = my;
3932
            }
3933
        }
3934
    }
3935
end:
3936

    
3937
    for(i=0; i<4; i++)
3938
        s->block_index[i]-= 2;
3939
    for(i=4; i<6; i++)
3940
        s->block_index[i]-= 1;
3941
    s->mb_x--;
3942

    
3943
    s->gb= gb;
3944
}
3945

    
3946
static void h263_decode_dquant(MpegEncContext *s){
3947
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3948

    
3949
    if(s->modified_quant){
3950
        if(get_bits1(&s->gb))
3951
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3952
        else
3953
            s->qscale= get_bits(&s->gb, 5);
3954
    }else
3955
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3956
    ff_set_qscale(s, s->qscale);
3957
}
3958

    
3959
int ff_h263_decode_mb(MpegEncContext *s,
3960
                      DCTELEM block[6][64])
3961
{
3962
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3963
    int16_t *mot_val;
3964
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3965

    
3966
    assert(!s->h263_pred);
3967

    
3968
    if (s->pict_type == P_TYPE) {
3969
        do{
3970
            if (get_bits1(&s->gb)) {
3971
                /* skip mb */
3972
                s->mb_intra = 0;
3973
                for(i=0;i<6;i++)
3974
                    s->block_last_index[i] = -1;
3975
                s->mv_dir = MV_DIR_FORWARD;
3976
                s->mv_type = MV_TYPE_16X16;
3977
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3978
                s->mv[0][0][0] = 0;
3979
                s->mv[0][0][1] = 0;
3980
                s->mb_skipped = !(s->obmc | s->loop_filter);
3981
                goto end;
3982
            }
3983
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3984
            //fprintf(stderr, "\tCBPC: %d", cbpc);
3985
            if (cbpc < 0){
3986
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3987
                return -1;
3988
            }
3989
        }while(cbpc == 20);
3990

    
3991
        s->dsp.clear_blocks(s->block[0]);
3992

    
3993
        dquant = cbpc & 8;
3994
        s->mb_intra = ((cbpc & 4) != 0);
3995
        if (s->mb_intra) goto intra;
3996

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

    
3999
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4000
            cbpy ^= 0xF;
4001

    
4002
        cbp = (cbpc & 3) | (cbpy << 2);
4003
        if (dquant) {
4004
            h263_decode_dquant(s);
4005
        }
4006

    
4007
        s->mv_dir = MV_DIR_FORWARD;
4008
        if ((cbpc & 16) == 0) {
4009
            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4010
            /* 16x16 motion prediction */
4011
            s->mv_type = MV_TYPE_16X16;
4012
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4013
            if (s->umvplus)
4014
               mx = h263p_decode_umotion(s, pred_x);
4015
            else
4016
               mx = h263_decode_motion(s, pred_x, 1);
4017

    
4018
            if (mx >= 0xffff)
4019
                return -1;
4020

    
4021
            if (s->umvplus)
4022
               my = h263p_decode_umotion(s, pred_y);
4023
            else
4024
               my = h263_decode_motion(s, pred_y, 1);
4025

    
4026
            if (my >= 0xffff)
4027
                return -1;
4028
            s->mv[0][0][0] = mx;
4029
            s->mv[0][0][1] = my;
4030

    
4031
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4032
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4033
        } else {
4034
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4035
            s->mv_type = MV_TYPE_8X8;
4036
            for(i=0;i<4;i++) {
4037
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4038
                if (s->umvplus)
4039
                  mx = h263p_decode_umotion(s, pred_x);
4040
                else
4041
                  mx = h263_decode_motion(s, pred_x, 1);
4042
                if (mx >= 0xffff)
4043
                    return -1;
4044

    
4045
                if (s->umvplus)
4046
                  my = h263p_decode_umotion(s, pred_y);
4047
                else
4048
                  my = h263_decode_motion(s, pred_y, 1);
4049
                if (my >= 0xffff)
4050
                    return -1;
4051
                s->mv[0][i][0] = mx;
4052
                s->mv[0][i][1] = my;
4053
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4054
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4055
                mot_val[0] = mx;
4056
                mot_val[1] = my;
4057
            }
4058
        }
4059

    
4060
        /* decode each block */
4061
        for (i = 0; i < 6; i++) {
4062
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4063
                return -1;
4064
            cbp+=cbp;
4065
        }
4066

    
4067
        if(s->obmc){
4068
            if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4069
                preview_obmc(s);
4070
        }
4071
    } else if(s->pict_type==B_TYPE) {
4072
        int mb_type;
4073
        const int stride= s->b8_stride;
4074
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4075
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4076
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4077

    
4078
        //FIXME ugly
4079
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4080
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4081
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4082
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4083

    
4084
        do{
4085
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4086
            if (mb_type < 0){
4087
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4088
                return -1;
4089
            }
4090

    
4091
            mb_type= h263_mb_type_b_map[ mb_type ];
4092
        }while(!mb_type);
4093

    
4094
        s->mb_intra = IS_INTRA(mb_type);
4095
        if(HAS_CBP(mb_type)){
4096
            s->dsp.clear_blocks(s->block[0]);
4097
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4098
            if(s->mb_intra){
4099
                dquant = IS_QUANT(mb_type);
4100
                goto intra;
4101
            }
4102

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

    
4105
            if (cbpy < 0){
4106
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4107
                return -1;
4108
            }
4109

    
4110
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4111
                cbpy ^= 0xF;
4112

    
4113
            cbp = (cbpc & 3) | (cbpy << 2);
4114
        }else
4115
            cbp=0;
4116

    
4117
        assert(!s->mb_intra);
4118

    
4119
        if(IS_QUANT(mb_type)){
4120
            h263_decode_dquant(s);
4121
        }
4122

    
4123
        if(IS_DIRECT(mb_type)){
4124
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4125
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4126
        }else{
4127
            s->mv_dir = 0;
4128
            s->mv_type= MV_TYPE_16X16;
4129
//FIXME UMV
4130

    
4131
            if(USES_LIST(mb_type, 0)){
4132
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4133
                s->mv_dir = MV_DIR_FORWARD;
4134

    
4135
                mx = h263_decode_motion(s, mx, 1);
4136
                my = h263_decode_motion(s, my, 1);
4137

    
4138
                s->mv[0][0][0] = mx;
4139
                s->mv[0][0][1] = my;
4140
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4141
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4142
            }
4143

    
4144
            if(USES_LIST(mb_type, 1)){
4145
                int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4146
                s->mv_dir |= MV_DIR_BACKWARD;
4147

    
4148
                mx = h263_decode_motion(s, mx, 1);
4149
                my = h263_decode_motion(s, my, 1);
4150

    
4151
                s->mv[1][0][0] = mx;
4152
                s->mv[1][0][1] = my;
4153
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4154
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4155
            }
4156
        }
4157

    
4158
        s->current_picture.mb_type[xy]= mb_type;
4159

    
4160
        /* decode each block */
4161
        for (i = 0; i < 6; i++) {
4162
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4163
                return -1;
4164
            cbp+=cbp;
4165
        }
4166
    } else { /* I-Frame */
4167
        do{
4168
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4169
            if (cbpc < 0){
4170
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4171
                return -1;
4172
            }
4173
        }while(cbpc == 8);
4174

    
4175
        s->dsp.clear_blocks(s->block[0]);
4176

    
4177
        dquant = cbpc & 4;
4178
        s->mb_intra = 1;
4179
intra:
4180
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4181
        if (s->h263_aic) {
4182
            s->ac_pred = get_bits1(&s->gb);
4183
            if(s->ac_pred){
4184
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4185

    
4186
                s->h263_aic_dir = get_bits1(&s->gb);
4187
            }
4188
        }else
4189
            s->ac_pred = 0;
4190

    
4191
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4192
        if(cbpy<0){
4193
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4194
            return -1;
4195
        }
4196
        cbp = (cbpc & 3) | (cbpy << 2);
4197
        if (dquant) {
4198
            h263_decode_dquant(s);
4199
        }
4200

    
4201
        /* decode each block */
4202
        for (i = 0; i < 6; i++) {
4203
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4204
                return -1;
4205
            cbp+=cbp;
4206
        }
4207
    }
4208
end:
4209

    
4210
        /* per-MB end of slice check */
4211
    {
4212
        int v= show_bits(&s->gb, 16);
4213

    
4214
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4215
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4216
        }
4217

    
4218
        if(v==0)
4219
            return SLICE_END;
4220
    }
4221

    
4222
    return SLICE_OK;
4223
}
4224

    
4225
int ff_mpeg4_decode_mb(MpegEncContext *s,
4226
                      DCTELEM block[6][64])
4227
{
4228
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4229
    int16_t *mot_val;
4230
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4231
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4232

    
4233
    assert(s->h263_pred);
4234

    
4235
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4236
        do{
4237
            if (get_bits1(&s->gb)) {
4238
                /* skip mb */
4239
                s->mb_intra = 0;
4240
                for(i=0;i<6;i++)
4241
                    s->block_last_index[i] = -1;
4242
                s->mv_dir = MV_DIR_FORWARD;
4243
                s->mv_type = MV_TYPE_16X16;
4244
                if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4245
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4246
                    s->mcsel=1;
4247
                    s->mv[0][0][0]= get_amv(s, 0);
4248
                    s->mv[0][0][1]= get_amv(s, 1);
4249

    
4250
                    s->mb_skipped = 0;
4251
                }else{
4252
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4253
                    s->mcsel=0;
4254
                    s->mv[0][0][0] = 0;
4255
                    s->mv[0][0][1] = 0;
4256
                    s->mb_skipped = 1;
4257
                }
4258
                goto end;
4259
            }
4260
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4261
            //fprintf(stderr, "\tCBPC: %d", cbpc);
4262
            if (cbpc < 0){
4263
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4264
                return -1;
4265
            }
4266
        }while(cbpc == 20);
4267

    
4268
        s->dsp.clear_blocks(s->block[0]);
4269
        dquant = cbpc & 8;
4270
        s->mb_intra = ((cbpc & 4) != 0);
4271
        if (s->mb_intra) goto intra;
4272

    
4273
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4274
            s->mcsel= get_bits1(&s->gb);
4275
        else s->mcsel= 0;
4276
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4277

    
4278
        cbp = (cbpc & 3) | (cbpy << 2);
4279
        if (dquant) {
4280
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4281
        }
4282
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4283
            s->interlaced_dct= get_bits1(&s->gb);
4284

    
4285
        s->mv_dir = MV_DIR_FORWARD;
4286
        if ((cbpc & 16) == 0) {
4287
            if(s->mcsel){
4288
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4289
                /* 16x16 global motion prediction */
4290
                s->mv_type = MV_TYPE_16X16;
4291
                mx= get_amv(s, 0);
4292
                my= get_amv(s, 1);
4293
                s->mv[0][0][0] = mx;
4294
                s->mv[0][0][1] = my;
4295
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4296
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4297
                /* 16x8 field motion prediction */
4298
                s->mv_type= MV_TYPE_FIELD;
4299

    
4300
                s->field_select[0][0]= get_bits1(&s->gb);
4301
                s->field_select[0][1]= get_bits1(&s->gb);
4302

    
4303
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4304

    
4305
                for(i=0; i<2; i++){
4306
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4307
                    if (mx >= 0xffff)
4308
                        return -1;
4309

    
4310
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4311
                    if (my >= 0xffff)
4312
                        return -1;
4313

    
4314
                    s->mv[0][i][0] = mx;
4315
                    s->mv[0][i][1] = my;
4316
                }
4317
            }else{
4318
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4319
                /* 16x16 motion prediction */
4320
                s->mv_type = MV_TYPE_16X16;
4321
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4322
                mx = h263_decode_motion(s, pred_x, s->f_code);
4323

    
4324
                if (mx >= 0xffff)
4325
                    return -1;
4326

    
4327
                my = h263_decode_motion(s, pred_y, s->f_code);
4328

    
4329
                if (my >= 0xffff)
4330
                    return -1;
4331
                s->mv[0][0][0] = mx;
4332
                s->mv[0][0][1] = my;
4333
            }
4334
        } else {
4335
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4336
            s->mv_type = MV_TYPE_8X8;
4337
            for(i=0;i<4;i++) {
4338
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4339
                mx = h263_decode_motion(s, pred_x, s->f_code);
4340
                if (mx >= 0xffff)
4341
                    return -1;
4342

    
4343
                my = h263_decode_motion(s, pred_y, s->f_code);
4344
                if (my >= 0xffff)
4345
                    return -1;
4346
                s->mv[0][i][0] = mx;
4347
                s->mv[0][i][1] = my;
4348
                mot_val[0] = mx;
4349
                mot_val[1] = my;
4350
            }
4351
        }
4352
    } else if(s->pict_type==B_TYPE) {
4353
        int modb1; // first bit of modb
4354
        int modb2; // second bit of modb
4355
        int mb_type;
4356

    
4357
        s->mb_intra = 0; //B-frames never contain intra blocks
4358
        s->mcsel=0;      //     ...               true gmc blocks
4359

    
4360
        if(s->mb_x==0){
4361
            for(i=0; i<2; i++){
4362
                s->last_mv[i][0][0]=
4363
                s->last_mv[i][0][1]=
4364
                s->last_mv[i][1][0]=
4365
                s->last_mv[i][1][1]= 0;
4366
            }
4367
        }
4368

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

    
4372
        if(s->mb_skipped){
4373
                /* skip mb */
4374
            for(i=0;i<6;i++)
4375
                s->block_last_index[i] = -1;
4376

    
4377
            s->mv_dir = MV_DIR_FORWARD;
4378
            s->mv_type = MV_TYPE_16X16;
4379
            s->mv[0][0][0] = 0;
4380
            s->mv[0][0][1] = 0;
4381
            s->mv[1][0][0] = 0;
4382
            s->mv[1][0][1] = 0;
4383
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4384
            goto end;
4385
        }
4386

    
4387
        modb1= get_bits1(&s->gb);
4388
        if(modb1){
4389
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4390
            cbp=0;
4391
        }else{
4392
            modb2= get_bits1(&s->gb);
4393
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4394
            if(mb_type<0){
4395
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4396
                return -1;
4397
            }
4398
            mb_type= mb_type_b_map[ mb_type ];
4399
            if(modb2) cbp= 0;
4400
            else{
4401
                s->dsp.clear_blocks(s->block[0]);
4402
                cbp= get_bits(&s->gb, 6);
4403
            }
4404

    
4405
            if ((!IS_DIRECT(mb_type)) && cbp) {
4406
                if(get_bits1(&s->gb)){
4407
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4408
                }
4409
            }
4410

    
4411
            if(!s->progressive_sequence){
4412
                if(cbp)
4413
                    s->interlaced_dct= get_bits1(&s->gb);
4414

    
4415
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4416
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4417
                    mb_type &= ~MB_TYPE_16x16;
4418

    
4419
                    if(USES_LIST(mb_type, 0)){
4420
                        s->field_select[0][0]= get_bits1(&s->gb);
4421
                        s->field_select[0][1]= get_bits1(&s->gb);
4422
                    }
4423
                    if(USES_LIST(mb_type, 1)){
4424
                        s->field_select[1][0]= get_bits1(&s->gb);
4425
                        s->field_select[1][1]= get_bits1(&s->gb);
4426
                    }
4427
                }
4428
            }
4429

    
4430
            s->mv_dir = 0;
4431
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4432
                s->mv_type= MV_TYPE_16X16;
4433

    
4434
                if(USES_LIST(mb_type, 0)){
4435
                    s->mv_dir = MV_DIR_FORWARD;
4436

    
4437
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4438
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4439
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4440
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4441
                }
4442

    
4443
                if(USES_LIST(mb_type, 1)){
4444
                    s->mv_dir |= MV_DIR_BACKWARD;
4445

    
4446
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4447
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4448
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4449
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4450
                }
4451
            }else if(!IS_DIRECT(mb_type)){
4452
                s->mv_type= MV_TYPE_FIELD;
4453

    
4454
                if(USES_LIST(mb_type, 0)){
4455
                    s->mv_dir = MV_DIR_FORWARD;
4456

    
4457
                    for(i=0; i<2; i++){
4458
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4459
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4460
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4461
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4462
                    }
4463
                }
4464

    
4465
                if(USES_LIST(mb_type, 1)){
4466
                    s->mv_dir |= MV_DIR_BACKWARD;
4467

    
4468
                    for(i=0; i<2; i++){
4469
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4470
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4471
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4472
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4473
                    }
4474
                }
4475
            }
4476
        }
4477

    
4478
        if(IS_DIRECT(mb_type)){
4479
            if(IS_SKIP(mb_type))
4480
                mx=my=0;
4481
            else{
4482
                mx = h263_decode_motion(s, 0, 1);
4483
                my = h263_decode_motion(s, 0, 1);
4484
            }
4485

    
4486
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4487
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4488
        }
4489
        s->current_picture.mb_type[xy]= mb_type;
4490
    } else { /* I-Frame */
4491
        do{
4492
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4493
            if (cbpc < 0){
4494
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4495
                return -1;
4496
            }
4497
        }while(cbpc == 8);
4498

    
4499
        dquant = cbpc & 4;
4500
        s->mb_intra = 1;
4501
intra:
4502
        s->ac_pred = get_bits1(&s->gb);
4503
        if(s->ac_pred)
4504
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4505
        else
4506
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4507

    
4508
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4509
        if(cbpy<0){
4510
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4511
            return -1;
4512
        }
4513
        cbp = (cbpc & 3) | (cbpy << 2);
4514

    
4515
        s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4516

    
4517
        if (dquant) {
4518
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4519
        }
4520

    
4521
        if(!s->progressive_sequence)
4522
            s->interlaced_dct= get_bits1(&s->gb);
4523

    
4524
        s->dsp.clear_blocks(s->block[0]);
4525
        /* decode each block */
4526
        for (i = 0; i < 6; i++) {
4527
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4528
                return -1;
4529
            cbp+=cbp;
4530
        }
4531
        goto end;
4532
    }
4533

    
4534
    /* decode each block */
4535
    for (i = 0; i < 6; i++) {
4536
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4537
            return -1;
4538
        cbp+=cbp;
4539
    }
4540
end:
4541

    
4542
        /* per-MB end of slice check */
4543
    if(s->codec_id==CODEC_ID_MPEG4){
4544
        if(mpeg4_is_resync(s)){
4545
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4546
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4547
                return SLICE_OK;
4548
            return SLICE_END;
4549
        }
4550
    }
4551

    
4552
    return SLICE_OK;
4553
}
4554

    
4555
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4556
{
4557
    int code, val, sign, shift, l;
4558
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4559

    
4560
    if (code == 0)
4561
        return pred;
4562
    if (code < 0)
4563
        return 0xffff;
4564

    
4565
    sign = get_bits1(&s->gb);
4566
    shift = f_code - 1;
4567
    val = code;
4568
    if (shift) {
4569
        val = (val - 1) << shift;
4570
        val |= get_bits(&s->gb, shift);
4571
        val++;
4572
    }
4573
    if (sign)
4574
        val = -val;
4575
    val += pred;
4576

    
4577
    /* modulo decoding */
4578
    if (!s->h263_long_vectors) {
4579
        l = INT_BIT - 5 - f_code;
4580
        val = (val<<l)>>l;
4581
    } else {
4582
        /* horrible h263 long vector mode */
4583
        if (pred < -31 && val < -63)
4584
            val += 64;
4585
        if (pred > 32 && val > 63)
4586
            val -= 64;
4587

    
4588
    }
4589
    return val;
4590
}
4591

    
4592
/* Decodes RVLC of H.263+ UMV */
4593
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4594
{
4595
   int code = 0, sign;
4596

    
4597
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4598
      return pred;
4599

    
4600
   code = 2 + get_bits1(&s->gb);
4601

    
4602
   while (get_bits1(&s->gb))
4603
   {
4604
      code <<= 1;
4605
      code += get_bits1(&s->gb);
4606
   }
4607
   sign = code & 1;
4608
   code >>= 1;
4609

    
4610
   code = (sign) ? (pred - code) : (pred + code);
4611
#ifdef DEBUG
4612
   av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4613
#endif
4614
   return code;
4615

    
4616
}
4617

    
4618
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4619
                             int n, int coded)
4620
{
4621
    int code, level, i, j, last, run;
4622
    RLTable *rl = &rl_inter;
4623
    const uint8_t *scan_table;
4624
    GetBitContext gb= s->gb;
4625

    
4626
    scan_table = s->intra_scantable.permutated;
4627
    if (s->h263_aic && s->mb_intra) {
4628
        rl = &rl_intra_aic;
4629
        i = 0;
4630
        if (s->ac_pred) {
4631
            if (s->h263_aic_dir)
4632
                scan_table = s->intra_v_scantable.permutated; /* left */
4633
            else
4634
                scan_table = s->intra_h_scantable.permutated; /* top */
4635
        }
4636
    } else if (s->mb_intra) {
4637
        /* DC coef */
4638
        if(s->codec_id == CODEC_ID_RV10){
4639
#ifdef CONFIG_RV10_DECODER
4640
          if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4641
            int component, diff;
4642
            component = (n <= 3 ? 0 : n - 4 + 1);
4643
            level = s->last_dc[component];
4644
            if (s->rv10_first_dc_coded[component]) {
4645
                diff = rv_decode_dc(s, n);
4646
                if (diff == 0xffff)
4647
                    return -1;
4648
                level += diff;
4649
                level = level & 0xff; /* handle wrap round */
4650
                s->last_dc[component] = level;
4651
            } else {
4652
                s->rv10_first_dc_coded[component] = 1;
4653
            }
4654
          } else {
4655
                level = get_bits(&s->gb, 8);
4656
                if (level == 255)
4657
                    level = 128;
4658
          }
4659
#endif
4660
        }else{
4661
            level = get_bits(&s->gb, 8);
4662
            if((level&0x7F) == 0){
4663
                av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4664
                if(s->error_resilience >= FF_ER_COMPLIANT)
4665
                    return -1;
4666
            }
4667
            if (level == 255)
4668
                level = 128;
4669
        }
4670
        block[0] = level;
4671
        i = 1;
4672
    } else {
4673
        i = 0;
4674
    }
4675
    if (!coded) {
4676
        if (s->mb_intra && s->h263_aic)
4677
            goto not_coded;
4678
        s->block_last_index[n] = i - 1;
4679
        return 0;
4680
    }
4681
retry:
4682
    for(;;) {
4683
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4684
        if (code < 0){
4685
            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4686
            return -1;
4687
        }
4688
        if (code == rl->n) {
4689
            /* escape */
4690
            if (s->h263_flv > 1) {
4691
                int is11 = get_bits1(&s->gb);
4692
                last = get_bits1(&s->gb);
4693
                run = get_bits(&s->gb, 6);
4694
                if(is11){
4695
                    level = get_sbits(&s->gb, 11);
4696
                } else {
4697
                    level = get_sbits(&s->gb, 7);
4698
                }
4699
            } else {
4700
                last = get_bits1(&s->gb);
4701
                run = get_bits(&s->gb, 6);
4702
                level = (int8_t)get_bits(&s->gb, 8);
4703
                if(level == -128){
4704
                    if (s->codec_id == CODEC_ID_RV10) {
4705
                        /* XXX: should patch encoder too */
4706
                        level = get_sbits(&s->gb, 12);
4707
                    }else{
4708
                        level = get_bits(&s->gb, 5);
4709
                        level |= get_sbits(&s->gb, 6)<<5;
4710
                    }
4711
                }
4712
            }
4713
        } else {
4714
            run = rl->table_run[code];
4715
            level = rl->table_level[code];
4716
            last = code >= rl->last;
4717
            if (get_bits1(&s->gb))
4718
                level = -level;
4719
        }
4720
        i += run;
4721
        if (i >= 64){
4722
            if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4723
                //looks like a hack but no, it's the way its supposed to work ...
4724
                rl = &rl_intra_aic;
4725
                i = 0;
4726
                s->gb= gb;
4727
                memset(block, 0, sizeof(DCTELEM)*64);
4728
                goto retry;
4729
            }
4730
            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4731
            return -1;
4732
        }
4733
        j = scan_table[i];
4734
        block[j] = level;
4735
        if (last)
4736
            break;
4737
        i++;
4738
    }
4739
not_coded:
4740
    if (s->mb_intra && s->h263_aic) {
4741
        h263_pred_acdc(s, block, n);
4742
        i = 63;
4743
    }
4744
    s->block_last_index[n] = i;
4745
    return 0;
4746
}
4747

    
4748
/**
4749
 * decodes the dc value.
4750
 * @param n block index (0-3 are luma, 4-5 are chroma)
4751
 * @param dir_ptr the prediction direction will be stored here
4752
 * @return the quantized dc
4753
 */
4754
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4755
{
4756
    int level, code;
4757

    
4758
    if (n < 4)
4759
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4760
    else
4761
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4762
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4763
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4764
        return -1;
4765
    }
4766
    if (code == 0) {
4767
        level = 0;
4768
    } else {
4769
        if(IS_3IV1){
4770
            if(code==1)
4771
                level= 2*get_bits1(&s->gb)-1;
4772
            else{
4773
                if(get_bits1(&s->gb))
4774
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4775
                else
4776
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4777
            }
4778
        }else{
4779
            level = get_xbits(&s->gb, code);
4780
        }
4781

    
4782
        if (code > 8){
4783
            if(get_bits1(&s->gb)==0){ /* marker */
4784
                if(s->error_resilience>=2){
4785
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4786
                    return -1;
4787
                }
4788
            }
4789
        }
4790