Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ b5ca0c6f

History | View | Annotate | Download (212 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 "common.h"
38
#include "dsputil.h"
39
#include "avcodec.h"
40
#include "mpegvideo.h"
41
#include "h263data.h"
42
#include "mpeg4data.h"
43

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

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

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

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

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

    
90
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
91
static uint8_t fcode_tab[MAX_MV*2+1];
92
static uint8_t umv_fcode_tab[MAX_MV*2+1];
93

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

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

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

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

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

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

    
140
#ifdef CONFIG_ENCODERS
141

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

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

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

    
154
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
155
}
156

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

    
161
      align_put_bits(&s->pb);
162

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

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

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

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

    
227
    align_put_bits(&s->pb);
228

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
355
        ff_h263_encode_mba(s);
356

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

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

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

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

    
388
            last= j;
389
        }
390
    }
391

    
392
    return rate;
393
}
394

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

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

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

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

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

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

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

    
463
    return score < 0;
464
}
465

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

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

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

    
489
/**
490
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
491
 */
492
void ff_clean_h263_qscales(MpegEncContext *s){
493
    int i;
494
    int8_t * const qscale_table= s->current_picture.qscale_table;
495

    
496
    for(i=1; i<s->mb_num; i++){
497
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
498
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
499
    }
500
    for(i=s->mb_num-2; i>=0; i--){
501
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
502
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
503
    }
504

    
505
    if(s->codec_id != CODEC_ID_H263P){
506
        for(i=1; i<s->mb_num; i++){
507
            int mb_xy= s->mb_index2xy[i];
508

    
509
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
510
                s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
511
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
512
            }
513
        }
514
    }
515
}
516

    
517
/**
518
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
519
 */
520
void ff_clean_mpeg4_qscales(MpegEncContext *s){
521
    int i;
522
    int8_t * const qscale_table= s->current_picture.qscale_table;
523

    
524
    ff_clean_h263_qscales(s);
525

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

    
530
        for(i=0; i<s->mb_num; i++){
531
            int mb_xy= s->mb_index2xy[i];
532
            odd += qscale_table[mb_xy]&1;
533
        }
534

    
535
        if(2*odd > s->mb_num) odd=1;
536
        else                  odd=0;
537

    
538
        for(i=0; i<s->mb_num; i++){
539
            int mb_xy= s->mb_index2xy[i];
540
            if((qscale_table[mb_xy]&1) != odd)
541
                qscale_table[mb_xy]++;
542
            if(qscale_table[mb_xy] > 31)
543
                qscale_table[mb_xy]= 31;
544
        }
545

    
546
        for(i=1; i<s->mb_num; i++){
547
            int mb_xy= s->mb_index2xy[i];
548
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
549
                s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
550
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
551
            }
552
        }
553
    }
554
}
555

    
556
#endif //CONFIG_ENCODERS
557

    
558
#define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
559
#define tab_bias (tab_size/2)
560

    
561
void ff_mpeg4_init_direct_mv(MpegEncContext *s){
562
    int i;
563
    for(i=0; i<tab_size; i++){
564
        s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
565
        s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
566
    }
567
}
568

    
569
static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
570
    int xy= s->block_index[i];
571
    uint16_t time_pp= s->pp_time;
572
    uint16_t time_pb= s->pb_time;
573
    int p_mx, p_my;
574

    
575
    p_mx= s->next_picture.motion_val[0][xy][0];
576
    if((unsigned)(p_mx + tab_bias) < tab_size){
577
        s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
578
        s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
579
                            : s->direct_scale_mv[1][p_mx + tab_bias];
580
    }else{
581
        s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
582
        s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
583
                            : p_mx*(time_pb - time_pp)/time_pp;
584
    }
585
    p_my= s->next_picture.motion_val[0][xy][1];
586
    if((unsigned)(p_my + tab_bias) < tab_size){
587
        s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
588
        s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
589
                            : s->direct_scale_mv[1][p_my + tab_bias];
590
    }else{
591
        s->mv[0][i][1] = p_my*time_pb/time_pp + my;
592
        s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
593
                            : p_my*(time_pb - time_pp)/time_pp;
594
    }
595
}
596

    
597
#undef tab_size
598
#undef tab_bias
599

    
600
/**
601
 *
602
 * @return the mb_type
603
 */
604
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
605
    const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
606
    const int colocated_mb_type= s->next_picture.mb_type[mb_index];
607
    uint16_t time_pp= s->pp_time;
608
    uint16_t time_pb= s->pb_time;
609
    int i;
610

    
611
    //FIXME avoid divides
612
    // try special case with shifts for 1 and 3 B-frames?
613

    
614
    if(IS_8X8(colocated_mb_type)){
615
        s->mv_type = MV_TYPE_8X8;
616
        for(i=0; i<4; i++){
617
            ff_mpeg4_set_one_direct_mv(s, mx, my, i);
618
        }
619
        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
620
    } else if(IS_INTERLACED(colocated_mb_type)){
621
        s->mv_type = MV_TYPE_FIELD;
622
        for(i=0; i<2; i++){
623
            int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
624
            s->field_select[0][i]= field_select;
625
            s->field_select[1][i]= i;
626
            if(s->top_field_first){
627
                time_pp= s->pp_field_time - field_select + i;
628
                time_pb= s->pb_field_time - field_select + i;
629
            }else{
630
                time_pp= s->pp_field_time + field_select - i;
631
                time_pb= s->pb_field_time + field_select - i;
632
            }
633
            s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
634
            s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
635
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
636
                                : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
637
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
638
                                : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
639
        }
640
        return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
641
    }else{
642
        ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
643
        s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
644
        s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
645
        s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
646
        s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
647
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
648
            s->mv_type= MV_TYPE_16X16;
649
        else
650
            s->mv_type= MV_TYPE_8X8;
651
        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
652
    }
653
}
654

    
655
void ff_h263_update_motion_val(MpegEncContext * s){
656
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
657
               //FIXME a lot of that is only needed for !low_delay
658
    const int wrap = s->b8_stride;
659
    const int xy = s->block_index[0];
660

    
661
    s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
662

    
663
    if(s->mv_type != MV_TYPE_8X8){
664
        int motion_x, motion_y;
665
        if (s->mb_intra) {
666
            motion_x = 0;
667
            motion_y = 0;
668
        } else if (s->mv_type == MV_TYPE_16X16) {
669
            motion_x = s->mv[0][0][0];
670
            motion_y = s->mv[0][0][1];
671
        } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
672
            int i;
673
            motion_x = s->mv[0][0][0] + s->mv[0][1][0];
674
            motion_y = s->mv[0][0][1] + s->mv[0][1][1];
675
            motion_x = (motion_x>>1) | (motion_x&1);
676
            for(i=0; i<2; i++){
677
                s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
678
                s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
679
            }
680
            s->current_picture.ref_index[0][xy           ]=
681
            s->current_picture.ref_index[0][xy        + 1]= s->field_select[0][0];
682
            s->current_picture.ref_index[0][xy + wrap    ]=
683
            s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
684
        }
685

    
686
        /* no update if 8X8 because it has been done during parsing */
687
        s->current_picture.motion_val[0][xy][0] = motion_x;
688
        s->current_picture.motion_val[0][xy][1] = motion_y;
689
        s->current_picture.motion_val[0][xy + 1][0] = motion_x;
690
        s->current_picture.motion_val[0][xy + 1][1] = motion_y;
691
        s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
692
        s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
693
        s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
694
        s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
695
    }
696

    
697
    if(s->encoding){ //FIXME encoding MUST be cleaned up
698
        if (s->mv_type == MV_TYPE_8X8)
699
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
700
        else if(s->mb_intra)
701
            s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
702
        else
703
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
704
    }
705
}
706

    
707
#ifdef CONFIG_ENCODERS
708

    
709
static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
710
    int l, bit_size, code;
711

    
712
    if (val == 0) {
713
        return mvtab[0][1];
714
    } else {
715
        bit_size = f_code - 1;
716
        /* modulo encoding */
717
        l= INT_BIT - 6 - bit_size;
718
        val = (val<<l)>>l;
719
        val--;
720
        code = (val >> bit_size) + 1;
721

    
722
        return mvtab[code][1] + 1 + bit_size;
723
    }
724
}
725

    
726
static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
727
    if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
728
        skip_put_bits(&s->pb,
729
            h263_get_motion_length(s, x, f_code)
730
           +h263_get_motion_length(s, y, f_code));
731
    }else{
732
        ff_h263_encode_motion(s, x, f_code);
733
        ff_h263_encode_motion(s, y, f_code);
734
    }
735
}
736

    
737
static inline int get_p_cbp(MpegEncContext * s,
738
                      DCTELEM block[6][64],
739
                      int motion_x, int motion_y){
740
    int cbp, i;
741

    
742
    if(s->flags & CODEC_FLAG_CBP_RD){
743
        int best_cbpy_score= INT_MAX;
744
        int best_cbpc_score= INT_MAX;
745
        int cbpc = (-1), cbpy= (-1);
746
        const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
747
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
748

    
749
        for(i=0; i<4; i++){
750
            int score= inter_MCBPC_bits[i + offset] * lambda;
751
            if(i&1) score += s->coded_score[5];
752
            if(i&2) score += s->coded_score[4];
753

    
754
            if(score < best_cbpc_score){
755
                best_cbpc_score= score;
756
                cbpc= i;
757
            }
758
        }
759

    
760
        for(i=0; i<16; i++){
761
            int score= cbpy_tab[i ^ 0xF][1] * lambda;
762
            if(i&1) score += s->coded_score[3];
763
            if(i&2) score += s->coded_score[2];
764
            if(i&4) score += s->coded_score[1];
765
            if(i&8) score += s->coded_score[0];
766

    
767
            if(score < best_cbpy_score){
768
                best_cbpy_score= score;
769
                cbpy= i;
770
            }
771
        }
772
        cbp= cbpc + 4*cbpy;
773
        if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
774
            if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
775
                cbp= 0;
776
        }
777

    
778
        for (i = 0; i < 6; i++) {
779
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
780
                s->block_last_index[i]= -1;
781
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
782
            }
783
        }
784
    }else{
785
        cbp= 0;
786
        for (i = 0; i < 6; i++) {
787
            if (s->block_last_index[i] >= 0)
788
                cbp |= 1 << (5 - i);
789
        }
790
    }
791
    return cbp;
792
}
793

    
794
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
795
                            int motion_x, int motion_y, int mb_type){
796
    int cbp=0, i;
797

    
798
    if(s->flags & CODEC_FLAG_CBP_RD){
799
        int score=0;
800
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
801

    
802
        for(i=0; i<6; i++){
803
            if(s->coded_score[i] < 0){
804
                score += s->coded_score[i];
805
                cbp |= 1 << (5 - i);
806
            }
807
        }
808

    
809
        if(cbp){
810
            int zero_score= -6;
811
            if ((motion_x | motion_y | s->dquant | mb_type) == 0){
812
                zero_score-= 4; //2*MV + mb_type + cbp bit
813
            }
814

    
815
            zero_score*= lambda;
816
            if(zero_score <= score){
817
                cbp=0;
818
            }
819
        }
820

    
821
        for (i = 0; i < 6; i++) {
822
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
823
                s->block_last_index[i]= -1;
824
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
825
            }
826
        }
827
    }else{
828
        for (i = 0; i < 6; i++) {
829
            if (s->block_last_index[i] >= 0)
830
                cbp |= 1 << (5 - i);
831
        }
832
    }
833
    return cbp;
834
}
835

    
836
static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
837
                               uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
838
    int i;
839

    
840
    if(scan_table){
841
        if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
842
            for (i = 0; i < 6; i++) {
843
                skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
844
            }
845
        }else{
846
            /* encode each block */
847
            for (i = 0; i < 6; i++) {
848
                mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
849
            }
850
        }
851
    }else{
852
        if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
853
            for (i = 0; i < 6; i++) {
854
                skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
855
            }
856
        }else{
857
            /* encode each block */
858
            for (i = 0; i < 6; i++) {
859
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
860
            }
861
        }
862
    }
863
}
864

    
865
void mpeg4_encode_mb(MpegEncContext * s,
866
                    DCTELEM block[6][64],
867
                    int motion_x, int motion_y)
868
{
869
    int cbpc, cbpy, pred_x, pred_y;
870
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
871
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
872
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
873
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
874
    const int dquant_code[5]= {1,0,9,2,3};
875

    
876
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
877
    if (!s->mb_intra) {
878
        int i, cbp;
879

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

    
884
            if(s->mb_x==0){
885
                for(i=0; i<2; i++){
886
                    s->last_mv[i][0][0]=
887
                    s->last_mv[i][0][1]=
888
                    s->last_mv[i][1][0]=
889
                    s->last_mv[i][1][1]= 0;
890
                }
891
            }
892

    
893
            assert(s->dquant>=-2 && s->dquant<=2);
894
            assert((s->dquant&1)==0);
895
            assert(mb_type>=0);
896

    
897
            /* nothing to do if this MB was skipped in the next P Frame */
898
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
899
                s->skip_count++;
900
                s->mv[0][0][0]=
901
                s->mv[0][0][1]=
902
                s->mv[1][0][0]=
903
                s->mv[1][0][1]= 0;
904
                s->mv_dir= MV_DIR_FORWARD; //doesn't matter
905
                s->qscale -= s->dquant;
906
//                s->mb_skipped=1;
907

    
908
                return;
909
            }
910

    
911
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
912

    
913
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
914
                /* direct MB with MV={0,0} */
915
                assert(s->dquant==0);
916

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

    
919
                if(interleaved_stats){
920
                    s->misc_bits++;
921
                    s->last_bits++;
922
                }
923
                s->skip_count++;
924
                return;
925
            }
926

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

    
932
            if(cbp && mb_type){
933
                if(s->dquant)
934
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
935
                else
936
                    put_bits(&s->pb, 1, 0);
937
            }else
938
                s->qscale -= s->dquant;
939

    
940
            if(!s->progressive_sequence){
941
                if(cbp)
942
                    put_bits(&s->pb, 1, s->interlaced_dct);
943
                if(mb_type) // not direct mode
944
                    put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
945
            }
946

    
947
            if(interleaved_stats){
948
                s->misc_bits+= get_bits_diff(s);
949
            }
950

    
951
            if(mb_type == 0){
952
                assert(s->mv_dir & MV_DIRECT);
953
                ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
954
                s->b_count++;
955
                s->f_count++;
956
            }else{
957
                assert(mb_type > 0 && mb_type < 4);
958
                if(s->mv_type != MV_TYPE_FIELD){
959
                    if(s->mv_dir & MV_DIR_FORWARD){
960
                        ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
961
                                                        s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
962
                        s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
963
                        s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
964
                        s->f_count++;
965
                    }
966
                    if(s->mv_dir & MV_DIR_BACKWARD){
967
                        ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
968
                                                        s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
969
                        s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
970
                        s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
971
                        s->b_count++;
972
                    }
973
                }else{
974
                    if(s->mv_dir & MV_DIR_FORWARD){
975
                        put_bits(&s->pb, 1, s->field_select[0][0]);
976
                        put_bits(&s->pb, 1, s->field_select[0][1]);
977
                    }
978
                    if(s->mv_dir & MV_DIR_BACKWARD){
979
                        put_bits(&s->pb, 1, s->field_select[1][0]);
980
                        put_bits(&s->pb, 1, s->field_select[1][1]);
981
                    }
982
                    if(s->mv_dir & MV_DIR_FORWARD){
983
                        for(i=0; i<2; i++){
984
                            ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0]  ,
985
                                                            s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
986
                            s->last_mv[0][i][0]= s->mv[0][i][0];
987
                            s->last_mv[0][i][1]= s->mv[0][i][1]*2;
988
                        }
989
                        s->f_count++;
990
                    }
991
                    if(s->mv_dir & MV_DIR_BACKWARD){
992
                        for(i=0; i<2; i++){
993
                            ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0]  ,
994
                                                            s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
995
                            s->last_mv[1][i][0]= s->mv[1][i][0];
996
                            s->last_mv[1][i][1]= s->mv[1][i][1]*2;
997
                        }
998
                        s->b_count++;
999
                    }
1000
                }
1001
            }
1002

    
1003
            if(interleaved_stats){
1004
                s->mv_bits+= get_bits_diff(s);
1005
            }
1006

    
1007
            mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1008

    
1009
            if(interleaved_stats){
1010
                s->p_tex_bits+= get_bits_diff(s);
1011
            }
1012

    
1013
        }else{ /* s->pict_type==B_TYPE */
1014
            cbp= get_p_cbp(s, block, motion_x, motion_y);
1015

    
1016
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1017
                /* check if the B frames can skip it too, as we must skip it if we skip here
1018
                   why didn't they just compress the skip-mb bits instead of reusing them ?! */
1019
                if(s->max_b_frames>0){
1020
                    int i;
1021
                    int x,y, offset;
1022
                    uint8_t *p_pic;
1023

    
1024
                    x= s->mb_x*16;
1025
                    y= s->mb_y*16;
1026
                    if(x+16 > s->width)  x= s->width-16;
1027
                    if(y+16 > s->height) y= s->height-16;
1028

    
1029
                    offset= x + y*s->linesize;
1030
                    p_pic= s->new_picture.data[0] + offset;
1031

    
1032
                    s->mb_skipped=1;
1033
                    for(i=0; i<s->max_b_frames; i++){
1034
                        uint8_t *b_pic;
1035
                        int diff;
1036
                        Picture *pic= s->reordered_input_picture[i+1];
1037

    
1038
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
1039

    
1040
                        b_pic= pic->data[0] + offset;
1041
                        if(pic->type != FF_BUFFER_TYPE_SHARED)
1042
                            b_pic+= INPLACE_OFFSET;
1043
                        diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1044
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1045
                            s->mb_skipped=0;
1046
                            break;
1047
                        }
1048
                    }
1049
                }else
1050
                    s->mb_skipped=1;
1051

    
1052
                if(s->mb_skipped==1){
1053
                    /* skip macroblock */
1054
                    put_bits(&s->pb, 1, 1);
1055

    
1056
                    if(interleaved_stats){
1057
                        s->misc_bits++;
1058
                        s->last_bits++;
1059
                    }
1060
                    s->skip_count++;
1061

    
1062
                    return;
1063
                }
1064
            }
1065

    
1066
            put_bits(&s->pb, 1, 0);     /* mb coded */
1067
            cbpc = cbp & 3;
1068
            cbpy = cbp >> 2;
1069
            cbpy ^= 0xf;
1070
            if(s->mv_type==MV_TYPE_16X16){
1071
                if(s->dquant) cbpc+= 8;
1072
                put_bits(&s->pb,
1073
                        inter_MCBPC_bits[cbpc],
1074
                        inter_MCBPC_code[cbpc]);
1075

    
1076
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1077
                if(s->dquant)
1078
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
1079

    
1080
                if(!s->progressive_sequence){
1081
                    if(cbp)
1082
                        put_bits(pb2, 1, s->interlaced_dct);
1083
                    put_bits(pb2, 1, 0);
1084
                }
1085

    
1086
                if(interleaved_stats){
1087
                    s->misc_bits+= get_bits_diff(s);
1088
                }
1089

    
1090
                /* motion vectors: 16x16 mode */
1091
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1092

    
1093
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
1094
                                                motion_y - pred_y, s->f_code);
1095
            }else if(s->mv_type==MV_TYPE_FIELD){
1096
                if(s->dquant) cbpc+= 8;
1097
                put_bits(&s->pb,
1098
                        inter_MCBPC_bits[cbpc],
1099
                        inter_MCBPC_code[cbpc]);
1100

    
1101
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1102
                if(s->dquant)
1103
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
1104

    
1105
                assert(!s->progressive_sequence);
1106
                if(cbp)
1107
                    put_bits(pb2, 1, s->interlaced_dct);
1108
                put_bits(pb2, 1, 1);
1109

    
1110
                if(interleaved_stats){
1111
                    s->misc_bits+= get_bits_diff(s);
1112
                }
1113

    
1114
                /* motion vectors: 16x8 interlaced mode */
1115
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1116
                pred_y /=2;
1117

    
1118
                put_bits(&s->pb, 1, s->field_select[0][0]);
1119
                put_bits(&s->pb, 1, s->field_select[0][1]);
1120

    
1121
                ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1122
                                                s->mv[0][0][1] - pred_y, s->f_code);
1123
                ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1124
                                                s->mv[0][1][1] - pred_y, s->f_code);
1125
            }else{
1126
                assert(s->mv_type==MV_TYPE_8X8);
1127
                put_bits(&s->pb,
1128
                        inter_MCBPC_bits[cbpc+16],
1129
                        inter_MCBPC_code[cbpc+16]);
1130
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1131

    
1132
                if(!s->progressive_sequence){
1133
                    if(cbp)
1134
                        put_bits(pb2, 1, s->interlaced_dct);
1135
                }
1136

    
1137
                if(interleaved_stats){
1138
                    s->misc_bits+= get_bits_diff(s);
1139
                }
1140

    
1141
                for(i=0; i<4; i++){
1142
                    /* motion vectors: 8x8 mode*/
1143
                    h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1144

    
1145
                    ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1146
                                                    s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1147
                }
1148
            }
1149

    
1150
            if(interleaved_stats){
1151
                s->mv_bits+= get_bits_diff(s);
1152
            }
1153

    
1154
            mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1155

    
1156
            if(interleaved_stats){
1157
                s->p_tex_bits+= get_bits_diff(s);
1158
            }
1159
            s->f_count++;
1160
        }
1161
    } else {
1162
        int cbp;
1163
        int dc_diff[6];   //dc values with the dc prediction subtracted
1164
        int dir[6];  //prediction direction
1165
        int zigzag_last_index[6];
1166
        uint8_t *scan_table[6];
1167
        int i;
1168

    
1169
        for(i=0; i<6; i++){
1170
            dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1171
        }
1172

    
1173
        if(s->flags & CODEC_FLAG_AC_PRED){
1174
            s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1175
            if(!s->ac_pred)
1176
                restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1177
        }else{
1178
            for(i=0; i<6; i++)
1179
                scan_table[i]= s->intra_scantable.permutated;
1180
        }
1181

    
1182
        /* compute cbp */
1183
        cbp = 0;
1184
        for (i = 0; i < 6; i++) {
1185
            if (s->block_last_index[i] >= 1)
1186
                cbp |= 1 << (5 - i);
1187
        }
1188

    
1189
        cbpc = cbp & 3;
1190
        if (s->pict_type == I_TYPE) {
1191
            if(s->dquant) cbpc+=4;
1192
            put_bits(&s->pb,
1193
                intra_MCBPC_bits[cbpc],
1194
                intra_MCBPC_code[cbpc]);
1195
        } else {
1196
            if(s->dquant) cbpc+=8;
1197
            put_bits(&s->pb, 1, 0);     /* mb coded */
1198
            put_bits(&s->pb,
1199
                inter_MCBPC_bits[cbpc + 4],
1200
                inter_MCBPC_code[cbpc + 4]);
1201
        }
1202
        put_bits(pb2, 1, s->ac_pred);
1203
        cbpy = cbp >> 2;
1204
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1205
        if(s->dquant)
1206
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1207

    
1208
        if(!s->progressive_sequence){
1209
            put_bits(dc_pb, 1, s->interlaced_dct);
1210
        }
1211

    
1212
        if(interleaved_stats){
1213
            s->misc_bits+= get_bits_diff(s);
1214
        }
1215

    
1216
        mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1217

    
1218
        if(interleaved_stats){
1219
            s->i_tex_bits+= get_bits_diff(s);
1220
        }
1221
        s->i_count++;
1222

    
1223
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1224
        if(s->ac_pred)
1225
            restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1226
    }
1227
}
1228

    
1229
void h263_encode_mb(MpegEncContext * s,
1230
                    DCTELEM block[6][64],
1231
                    int motion_x, int motion_y)
1232
{
1233
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
1234
    int16_t pred_dc;
1235
    int16_t rec_intradc[6];
1236
    int16_t *dc_ptr[6];
1237
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1238
    const int dquant_code[5]= {1,0,9,2,3};
1239

    
1240
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1241
    if (!s->mb_intra) {
1242
        /* compute cbp */
1243
        cbp= get_p_cbp(s, block, motion_x, motion_y);
1244

    
1245
        if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1246
            /* skip macroblock */
1247
            put_bits(&s->pb, 1, 1);
1248
            if(interleaved_stats){
1249
                s->misc_bits++;
1250
                s->last_bits++;
1251
            }
1252
            s->skip_count++;
1253

    
1254
            return;
1255
        }
1256
        put_bits(&s->pb, 1, 0);         /* mb coded */
1257

    
1258
        cbpc = cbp & 3;
1259
        cbpy = cbp >> 2;
1260
        if(s->alt_inter_vlc==0 || cbpc!=3)
1261
            cbpy ^= 0xF;
1262
        if(s->dquant) cbpc+= 8;
1263
        if(s->mv_type==MV_TYPE_16X16){
1264
            put_bits(&s->pb,
1265
                    inter_MCBPC_bits[cbpc],
1266
                    inter_MCBPC_code[cbpc]);
1267

    
1268
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1269
            if(s->dquant)
1270
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1271

    
1272
            if(interleaved_stats){
1273
                s->misc_bits+= get_bits_diff(s);
1274
            }
1275

    
1276
            /* motion vectors: 16x16 mode */
1277
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1278

    
1279
            if (!s->umvplus) {
1280
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
1281
                                                motion_y - pred_y, 1);
1282
            }
1283
            else {
1284
                h263p_encode_umotion(s, motion_x - pred_x);
1285
                h263p_encode_umotion(s, motion_y - pred_y);
1286
                if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1287
                    /* To prevent Start Code emulation */
1288
                    put_bits(&s->pb,1,1);
1289
            }
1290
        }else{
1291
            put_bits(&s->pb,
1292
                    inter_MCBPC_bits[cbpc+16],
1293
                    inter_MCBPC_code[cbpc+16]);
1294
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1295
            if(s->dquant)
1296
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1297

    
1298
            if(interleaved_stats){
1299
                s->misc_bits+= get_bits_diff(s);
1300
            }
1301

    
1302
            for(i=0; i<4; i++){
1303
                /* motion vectors: 8x8 mode*/
1304
                h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1305

    
1306
                motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1307
                motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1308
                if (!s->umvplus) {
1309
                    ff_h263_encode_motion_vector(s, motion_x - pred_x,
1310
                                                    motion_y - pred_y, 1);
1311
                }
1312
                else {
1313
                    h263p_encode_umotion(s, motion_x - pred_x);
1314
                    h263p_encode_umotion(s, motion_y - pred_y);
1315
                    if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1316
                        /* To prevent Start Code emulation */
1317
                        put_bits(&s->pb,1,1);
1318
                }
1319
            }
1320
        }
1321

    
1322
        if(interleaved_stats){
1323
            s->mv_bits+= get_bits_diff(s);
1324
        }
1325
    } else {
1326
        assert(s->mb_intra);
1327

    
1328
        cbp = 0;
1329
        if (s->h263_aic) {
1330
            /* Predict DC */
1331
            for(i=0; i<6; i++) {
1332
                int16_t level = block[i][0];
1333
                int scale;
1334

    
1335
                if(i<4) scale= s->y_dc_scale;
1336
                else    scale= s->c_dc_scale;
1337

    
1338
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1339
                level -= pred_dc;
1340
                /* Quant */
1341
                if (level >= 0)
1342
                    level = (level + (scale>>1))/scale;
1343
                else
1344
                    level = (level - (scale>>1))/scale;
1345

    
1346
                /* AIC can change CBP */
1347
                if (level == 0 && s->block_last_index[i] == 0)
1348
                    s->block_last_index[i] = -1;
1349

    
1350
                if(!s->modified_quant){
1351
                    if (level < -127)
1352
                        level = -127;
1353
                    else if (level > 127)
1354
                        level = 127;
1355
                }
1356

    
1357
                block[i][0] = level;
1358
                /* Reconstruction */
1359
                rec_intradc[i] = scale*level + pred_dc;
1360
                /* Oddify */
1361
                rec_intradc[i] |= 1;
1362
                //if ((rec_intradc[i] % 2) == 0)
1363
                //    rec_intradc[i]++;
1364
                /* Clipping */
1365
                if (rec_intradc[i] < 0)
1366
                    rec_intradc[i] = 0;
1367
                else if (rec_intradc[i] > 2047)
1368
                    rec_intradc[i] = 2047;
1369

    
1370
                /* Update AC/DC tables */
1371
                *dc_ptr[i] = rec_intradc[i];
1372
                if (s->block_last_index[i] >= 0)
1373
                    cbp |= 1 << (5 - i);
1374
            }
1375
        }else{
1376
            for(i=0; i<6; i++) {
1377
                /* compute cbp */
1378
                if (s->block_last_index[i] >= 1)
1379
                    cbp |= 1 << (5 - i);
1380
            }
1381
        }
1382

    
1383
        cbpc = cbp & 3;
1384
        if (s->pict_type == I_TYPE) {
1385
            if(s->dquant) cbpc+=4;
1386
            put_bits(&s->pb,
1387
                intra_MCBPC_bits[cbpc],
1388
                intra_MCBPC_code[cbpc]);
1389
        } else {
1390
            if(s->dquant) cbpc+=8;
1391
            put_bits(&s->pb, 1, 0);     /* mb coded */
1392
            put_bits(&s->pb,
1393
                inter_MCBPC_bits[cbpc + 4],
1394
                inter_MCBPC_code[cbpc + 4]);
1395
        }
1396
        if (s->h263_aic) {
1397
            /* XXX: currently, we do not try to use ac prediction */
1398
            put_bits(&s->pb, 1, 0);     /* no AC prediction */
1399
        }
1400
        cbpy = cbp >> 2;
1401
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1402
        if(s->dquant)
1403
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1404

    
1405
        if(interleaved_stats){
1406
            s->misc_bits+= get_bits_diff(s);
1407
        }
1408
    }
1409

    
1410
    for(i=0; i<6; i++) {
1411
        /* encode each block */
1412
        h263_encode_block(s, block[i], i);
1413

    
1414
        /* Update INTRADC for decoding */
1415
        if (s->h263_aic && s->mb_intra) {
1416
            block[i][0] = rec_intradc[i];
1417

    
1418
        }
1419
    }
1420

    
1421
    if(interleaved_stats){
1422
        if (!s->mb_intra) {
1423
            s->p_tex_bits+= get_bits_diff(s);
1424
            s->f_count++;
1425
        }else{
1426
            s->i_tex_bits+= get_bits_diff(s);
1427
            s->i_count++;
1428
        }
1429
    }
1430
}
1431
#endif
1432

    
1433
void ff_h263_loop_filter(MpegEncContext * s){
1434
    int qp_c;
1435
    const int linesize  = s->linesize;
1436
    const int uvlinesize= s->uvlinesize;
1437
    const int xy = s->mb_y * s->mb_stride + s->mb_x;
1438
    uint8_t *dest_y = s->dest[0];
1439
    uint8_t *dest_cb= s->dest[1];
1440
    uint8_t *dest_cr= s->dest[2];
1441

    
1442
//    if(s->pict_type==B_TYPE && !s->readable) return;
1443

    
1444
    /*
1445
       Diag Top
1446
       Left Center
1447
    */
1448
    if(!IS_SKIP(s->current_picture.mb_type[xy])){
1449
        qp_c= s->qscale;
1450
        s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
1451
        s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1452
    }else
1453
        qp_c= 0;
1454

    
1455
    if(s->mb_y){
1456
        int qp_dt, qp_t, qp_tc;
1457

    
1458
        if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1459
            qp_t=0;
1460
        else
1461
            qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1462

    
1463
        if(qp_c)
1464
            qp_tc= qp_c;
1465
        else
1466
            qp_tc= qp_t;
1467

    
1468
        if(qp_tc){
1469
            const int chroma_qp= s->chroma_qscale_table[qp_tc];
1470
            s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
1471
            s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
1472

    
1473
            s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1474
            s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1475
        }
1476

    
1477
        if(qp_t)
1478
            s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_t);
1479

    
1480
        if(s->mb_x){
1481
            if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1482
                qp_dt= qp_t;
1483
            else
1484
                qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1485

    
1486
            if(qp_dt){
1487
                const int chroma_qp= s->chroma_qscale_table[qp_dt];
1488
                s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
1489
                s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1490
                s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1491
            }
1492
        }
1493
    }
1494

    
1495
    if(qp_c){
1496
        s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
1497
        if(s->mb_y + 1 == s->mb_height)
1498
            s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
1499
    }
1500

    
1501
    if(s->mb_x){
1502
        int qp_lc;
1503
        if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1504
            qp_lc= qp_c;
1505
        else
1506
            qp_lc= s->current_picture.qscale_table[xy-1];
1507

    
1508
        if(qp_lc){
1509
            s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
1510
            if(s->mb_y + 1 == s->mb_height){
1511
                const int chroma_qp= s->chroma_qscale_table[qp_lc];
1512
                s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
1513
                s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
1514
                s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
1515
            }
1516
        }
1517
    }
1518
}
1519

    
1520
#ifdef CONFIG_ENCODERS
1521
static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1522
{
1523
    int x, y, wrap, a, c, pred_dc, scale;
1524
    int16_t *dc_val;
1525

    
1526
    /* find prediction */
1527
    if (n < 4) {
1528
        x = 2 * s->mb_x + (n & 1);
1529
        y = 2 * s->mb_y + ((n & 2) >> 1);
1530
        wrap = s->b8_stride;
1531
        dc_val = s->dc_val[0];
1532
        scale = s->y_dc_scale;
1533
    } else {
1534
        x = s->mb_x;
1535
        y = s->mb_y;
1536
        wrap = s->mb_stride;
1537
        dc_val = s->dc_val[n - 4 + 1];
1538
        scale = s->c_dc_scale;
1539
    }
1540
    /* B C
1541
     * A X
1542
     */
1543
    a = dc_val[(x - 1) + (y) * wrap];
1544
    c = dc_val[(x) + (y - 1) * wrap];
1545

    
1546
    /* No prediction outside GOB boundary */
1547
    if(s->first_slice_line && n!=3){
1548
        if(n!=2) c= 1024;
1549
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1550
    }
1551
    pred_dc = 1024;
1552
    /* just DC prediction */
1553
    if (a != 1024 && c != 1024)
1554
        pred_dc = (a + c) >> 1;
1555
    else if (a != 1024)
1556
        pred_dc = a;
1557
    else
1558
        pred_dc = c;
1559

    
1560
    /* we assume pred is positive */
1561
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1562
    *dc_val_ptr = &dc_val[x + y * wrap];
1563
    return pred_dc;
1564
}
1565
#endif /* CONFIG_ENCODERS */
1566

    
1567
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1568
{
1569
    int x, y, wrap, a, c, pred_dc, scale, i;
1570
    int16_t *dc_val, *ac_val, *ac_val1;
1571

    
1572
    /* find prediction */
1573
    if (n < 4) {
1574
        x = 2 * s->mb_x + (n & 1);
1575
        y = 2 * s->mb_y + (n>> 1);
1576
        wrap = s->b8_stride;
1577
        dc_val = s->dc_val[0];
1578
        ac_val = s->ac_val[0][0];
1579
        scale = s->y_dc_scale;
1580
    } else {
1581
        x = s->mb_x;
1582
        y = s->mb_y;
1583
        wrap = s->mb_stride;
1584
        dc_val = s->dc_val[n - 4 + 1];
1585
        ac_val = s->ac_val[n - 4 + 1][0];
1586
        scale = s->c_dc_scale;
1587
    }
1588

    
1589
    ac_val += ((y) * wrap + (x)) * 16;
1590
    ac_val1 = ac_val;
1591

    
1592
    /* B C
1593
     * A X
1594
     */
1595
    a = dc_val[(x - 1) + (y) * wrap];
1596
    c = dc_val[(x) + (y - 1) * wrap];
1597

    
1598
    /* No prediction outside GOB boundary */
1599
    if(s->first_slice_line && n!=3){
1600
        if(n!=2) c= 1024;
1601
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1602
    }
1603

    
1604
    if (s->ac_pred) {
1605
        pred_dc = 1024;
1606
        if (s->h263_aic_dir) {
1607
            /* left prediction */
1608
            if (a != 1024) {
1609
                ac_val -= 16;
1610
                for(i=1;i<8;i++) {
1611
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1612
                }
1613
                pred_dc = a;
1614
            }
1615
        } else {
1616
            /* top prediction */
1617
            if (c != 1024) {
1618
                ac_val -= 16 * wrap;
1619
                for(i=1;i<8;i++) {
1620
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1621
                }
1622
                pred_dc = c;
1623
            }
1624
        }
1625
    } else {
1626
        /* just DC prediction */
1627
        if (a != 1024 && c != 1024)
1628
            pred_dc = (a + c) >> 1;
1629
        else if (a != 1024)
1630
            pred_dc = a;
1631
        else
1632
            pred_dc = c;
1633
    }
1634

    
1635
    /* we assume pred is positive */
1636
    block[0]=block[0]*scale + pred_dc;
1637

    
1638
    if (block[0] < 0)
1639
        block[0] = 0;
1640
    else
1641
        block[0] |= 1;
1642

    
1643
    /* Update AC/DC tables */
1644
    dc_val[(x) + (y) * wrap] = block[0];
1645

    
1646
    /* left copy */
1647
    for(i=1;i<8;i++)
1648
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1649
    /* top copy */
1650
    for(i=1;i<8;i++)
1651
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1652
}
1653

    
1654
int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1655
                        int *px, int *py)
1656
{
1657
    int wrap;
1658
    int16_t *A, *B, *C, (*mot_val)[2];
1659
    static const int off[4]= {2, 1, 1, -1};
1660

    
1661
    wrap = s->b8_stride;
1662
    mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1663

    
1664
    A = mot_val[ - 1];
1665
    /* special case for first (slice) line */
1666
    if (s->first_slice_line && block<3) {
1667
        // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1668
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1669
        if(block==0){ //most common case
1670
            if(s->mb_x  == s->resync_mb_x){ //rare
1671
                *px= *py = 0;
1672
            }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1673
                C = mot_val[off[block] - wrap];
1674
                if(s->mb_x==0){
1675
                    *px = C[0];
1676
                    *py = C[1];
1677
                }else{
1678
                    *px = mid_pred(A[0], 0, C[0]);
1679
                    *py = mid_pred(A[1], 0, C[1]);
1680
                }
1681
            }else{
1682
                *px = A[0];
1683
                *py = A[1];
1684
            }
1685
        }else if(block==1){
1686
            if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1687
                C = mot_val[off[block] - wrap];
1688
                *px = mid_pred(A[0], 0, C[0]);
1689
                *py = mid_pred(A[1], 0, C[1]);
1690
            }else{
1691
                *px = A[0];
1692
                *py = A[1];
1693
            }
1694
        }else{ /* block==2*/
1695
            B = mot_val[ - wrap];
1696
            C = mot_val[off[block] - wrap];
1697
            if(s->mb_x == s->resync_mb_x) //rare
1698
                A[0]=A[1]=0;
1699

    
1700
            *px = mid_pred(A[0], B[0], C[0]);
1701
            *py = mid_pred(A[1], B[1], C[1]);
1702
        }
1703
    } else {
1704
        B = mot_val[ - wrap];
1705
        C = mot_val[off[block] - wrap];
1706
        *px = mid_pred(A[0], B[0], C[0]);
1707
        *py = mid_pred(A[1], B[1], C[1]);
1708
    }
1709
    return *mot_val;
1710
}
1711

    
1712
#ifdef CONFIG_ENCODERS
1713
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1714
{
1715
    int range, l, bit_size, sign, code, bits;
1716

    
1717
    if (val == 0) {
1718
        /* zero vector */
1719
        code = 0;
1720
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1721
    } else {
1722
        bit_size = f_code - 1;
1723
        range = 1 << bit_size;
1724
        /* modulo encoding */
1725
        l= INT_BIT - 6 - bit_size;
1726
        val = (val<<l)>>l;
1727
        sign = val>>31;
1728
        val= (val^sign)-sign;
1729
        sign&=1;
1730

    
1731
        val--;
1732
        code = (val >> bit_size) + 1;
1733
        bits = val & (range - 1);
1734

    
1735
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1736
        if (bit_size > 0) {
1737
            put_bits(&s->pb, bit_size, bits);
1738
        }
1739
    }
1740
}
1741

    
1742
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1743
static void h263p_encode_umotion(MpegEncContext * s, int val)
1744
{
1745
    short sval = 0;
1746
    short i = 0;
1747
    short n_bits = 0;
1748
    short temp_val;
1749
    int code = 0;
1750
    int tcode;
1751

    
1752
    if ( val == 0)
1753
        put_bits(&s->pb, 1, 1);
1754
    else if (val == 1)
1755
        put_bits(&s->pb, 3, 0);
1756
    else if (val == -1)
1757
        put_bits(&s->pb, 3, 2);
1758
    else {
1759

    
1760
        sval = ((val < 0) ? (short)(-val):(short)val);
1761
        temp_val = sval;
1762

    
1763
        while (temp_val != 0) {
1764
            temp_val = temp_val >> 1;
1765
            n_bits++;
1766
        }
1767

    
1768
        i = n_bits - 1;
1769
        while (i > 0) {
1770
            tcode = (sval & (1 << (i-1))) >> (i-1);
1771
            tcode = (tcode << 1) | 1;
1772
            code = (code << 2) | tcode;
1773
            i--;
1774
        }
1775
        code = ((code << 1) | (val < 0)) << 1;
1776
        put_bits(&s->pb, (2*n_bits)+1, code);
1777
        //printf("\nVal = %d\tCode = %d", sval, code);
1778
    }
1779
}
1780

    
1781
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1782
{
1783
    int f_code;
1784
    int mv;
1785

    
1786
    if(mv_penalty==NULL)
1787
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1788

    
1789
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1790
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1791
            int len;
1792

    
1793
            if(mv==0) len= mvtab[0][1];
1794
            else{
1795
                int val, bit_size, range, code;
1796

    
1797
                bit_size = f_code - 1;
1798
                range = 1 << bit_size;
1799

    
1800
                val=mv;
1801
                if (val < 0)
1802
                    val = -val;
1803
                val--;
1804
                code = (val >> bit_size) + 1;
1805
                if(code<33){
1806
                    len= mvtab[code][1] + 1 + bit_size;
1807
                }else{
1808
                    len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1809
                }
1810
            }
1811

    
1812
            mv_penalty[f_code][mv+MAX_MV]= len;
1813
        }
1814
    }
1815

    
1816
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1817
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1818
            fcode_tab[mv+MAX_MV]= f_code;
1819
        }
1820
    }
1821

    
1822
    for(mv=0; mv<MAX_MV*2+1; mv++){
1823
        umv_fcode_tab[mv]= 1;
1824
    }
1825
}
1826
#endif
1827

    
1828
#ifdef CONFIG_ENCODERS
1829

    
1830
static void init_uni_dc_tab(void)
1831
{
1832
    int level, uni_code, uni_len;
1833

    
1834
    for(level=-256; level<256; level++){
1835
        int size, v, l;
1836
        /* find number of bits */
1837
        size = 0;
1838
        v = abs(level);
1839
        while (v) {
1840
            v >>= 1;
1841
            size++;
1842
        }
1843

    
1844
        if (level < 0)
1845
            l= (-level) ^ ((1 << size) - 1);
1846
        else
1847
            l= level;
1848

    
1849
        /* luminance */
1850
        uni_code= DCtab_lum[size][0];
1851
        uni_len = DCtab_lum[size][1];
1852

    
1853
        if (size > 0) {
1854
            uni_code<<=size; uni_code|=l;
1855
            uni_len+=size;
1856
            if (size > 8){
1857
                uni_code<<=1; uni_code|=1;
1858
                uni_len++;
1859
            }
1860
        }
1861
        uni_DCtab_lum_bits[level+256]= uni_code;
1862
        uni_DCtab_lum_len [level+256]= uni_len;
1863

    
1864
        /* chrominance */
1865
        uni_code= DCtab_chrom[size][0];
1866
        uni_len = DCtab_chrom[size][1];
1867

    
1868
        if (size > 0) {
1869
            uni_code<<=size; uni_code|=l;
1870
            uni_len+=size;
1871
            if (size > 8){
1872
                uni_code<<=1; uni_code|=1;
1873
                uni_len++;
1874
            }
1875
        }
1876
        uni_DCtab_chrom_bits[level+256]= uni_code;
1877
        uni_DCtab_chrom_len [level+256]= uni_len;
1878

    
1879
    }
1880
}
1881

    
1882
#endif //CONFIG_ENCODERS
1883

    
1884
#ifdef CONFIG_ENCODERS
1885
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1886
    int slevel, run, last;
1887

    
1888
    assert(MAX_LEVEL >= 64);
1889
    assert(MAX_RUN   >= 63);
1890

    
1891
    for(slevel=-64; slevel<64; slevel++){
1892
        if(slevel==0) continue;
1893
        for(run=0; run<64; run++){
1894
            for(last=0; last<=1; last++){
1895
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1896
                int level= slevel < 0 ? -slevel : slevel;
1897
                int sign= slevel < 0 ? 1 : 0;
1898
                int bits, len, code;
1899
                int level1, run1;
1900

    
1901
                len_tab[index]= 100;
1902

    
1903
                /* ESC0 */
1904
                code= get_rl_index(rl, last, run, level);
1905
                bits= rl->table_vlc[code][0];
1906
                len=  rl->table_vlc[code][1];
1907
                bits=bits*2+sign; len++;
1908

    
1909
                if(code!=rl->n && len < len_tab[index]){
1910
                    bits_tab[index]= bits;
1911
                    len_tab [index]= len;
1912
                }
1913
#if 1
1914
                /* ESC1 */
1915
                bits= rl->table_vlc[rl->n][0];
1916
                len=  rl->table_vlc[rl->n][1];
1917
                bits=bits*2;    len++; //esc1
1918
                level1= level - rl->max_level[last][run];
1919
                if(level1>0){
1920
                    code= get_rl_index(rl, last, run, level1);
1921
                    bits<<= rl->table_vlc[code][1];
1922
                    len  += rl->table_vlc[code][1];
1923
                    bits += rl->table_vlc[code][0];
1924
                    bits=bits*2+sign; len++;
1925

    
1926
                    if(code!=rl->n && len < len_tab[index]){
1927
                        bits_tab[index]= bits;
1928
                        len_tab [index]= len;
1929
                    }
1930
                }
1931
#endif
1932
#if 1
1933
                /* ESC2 */
1934
                bits= rl->table_vlc[rl->n][0];
1935
                len=  rl->table_vlc[rl->n][1];
1936
                bits=bits*4+2;    len+=2; //esc2
1937
                run1 = run - rl->max_run[last][level] - 1;
1938
                if(run1>=0){
1939
                    code= get_rl_index(rl, last, run1, level);
1940
                    bits<<= rl->table_vlc[code][1];
1941
                    len  += rl->table_vlc[code][1];
1942
                    bits += rl->table_vlc[code][0];
1943
                    bits=bits*2+sign; len++;
1944

    
1945
                    if(code!=rl->n && len < len_tab[index]){
1946
                        bits_tab[index]= bits;
1947
                        len_tab [index]= len;
1948
                    }
1949
                }
1950
#endif
1951
                /* ESC3 */
1952
                bits= rl->table_vlc[rl->n][0];
1953
                len = rl->table_vlc[rl->n][1];
1954
                bits=bits*4+3;    len+=2; //esc3
1955
                bits=bits*2+last; len++;
1956
                bits=bits*64+run; len+=6;
1957
                bits=bits*2+1;    len++;  //marker
1958
                bits=bits*4096+(slevel&0xfff); len+=12;
1959
                bits=bits*2+1;    len++;  //marker
1960

    
1961
                if(len < len_tab[index]){
1962
                    bits_tab[index]= bits;
1963
                    len_tab [index]= len;
1964
                }
1965
            }
1966
        }
1967
    }
1968
}
1969

    
1970
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1971
    int slevel, run, last;
1972

    
1973
    assert(MAX_LEVEL >= 64);
1974
    assert(MAX_RUN   >= 63);
1975

    
1976
    for(slevel=-64; slevel<64; slevel++){
1977
        if(slevel==0) continue;
1978
        for(run=0; run<64; run++){
1979
            for(last=0; last<=1; last++){
1980
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1981
                int level= slevel < 0 ? -slevel : slevel;
1982
                int sign= slevel < 0 ? 1 : 0;
1983
                int bits, len, code;
1984

    
1985
                len_tab[index]= 100;
1986

    
1987
                /* ESC0 */
1988
                code= get_rl_index(rl, last, run, level);
1989
                bits= rl->table_vlc[code][0];
1990
                len=  rl->table_vlc[code][1];
1991
                bits=bits*2+sign; len++;
1992

    
1993
                if(code!=rl->n && len < len_tab[index]){
1994
                    if(bits_tab) bits_tab[index]= bits;
1995
                    len_tab [index]= len;
1996
                }
1997
                /* ESC */
1998
                bits= rl->table_vlc[rl->n][0];
1999
                len = rl->table_vlc[rl->n][1];
2000
                bits=bits*2+last; len++;
2001
                bits=bits*64+run; len+=6;
2002
                bits=bits*256+(level&0xff); len+=8;
2003

    
2004
                if(len < len_tab[index]){
2005
                    if(bits_tab) bits_tab[index]= bits;
2006
                    len_tab [index]= len;
2007
                }
2008
            }
2009
        }
2010
    }
2011
}
2012

    
2013
void h263_encode_init(MpegEncContext *s)
2014
{
2015
    static int done = 0;
2016

    
2017
    if (!done) {
2018
        done = 1;
2019

    
2020
        init_uni_dc_tab();
2021

    
2022
        init_rl(&rl_inter, 1);
2023
        init_rl(&rl_intra, 1);
2024
        init_rl(&rl_intra_aic, 1);
2025

    
2026
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2027
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2028

    
2029
        init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2030
        init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
2031

    
2032
        init_mv_penalty_and_fcode(s);
2033
    }
2034
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2035

    
2036
    s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
2037
    s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2038
    if(s->h263_aic){
2039
        s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
2040
        s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2041
    }
2042
    s->ac_esc_length= 7+1+6+8;
2043

    
2044
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2045
    switch(s->codec_id){
2046
    case CODEC_ID_MPEG4:
2047
        s->fcode_tab= fcode_tab;
2048
        s->min_qcoeff= -2048;
2049
        s->max_qcoeff=  2047;
2050
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
2051
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2052
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
2053
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2054
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
2055
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2056
        s->ac_esc_length= 7+2+1+6+1+12+1;
2057
        s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2058
        s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2059

    
2060
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2061

    
2062
            s->avctx->extradata= av_malloc(1024);
2063
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
2064

    
2065
            if(!(s->workaround_bugs & FF_BUG_MS))
2066
                mpeg4_encode_visual_object_header(s);
2067
            mpeg4_encode_vol_header(s, 0, 0);
2068

    
2069
//            ff_mpeg4_stuffing(&s->pb); ?
2070
            flush_put_bits(&s->pb);
2071
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2072
        }
2073

    
2074
        break;
2075
    case CODEC_ID_H263P:
2076
        if(s->umvplus)
2077
            s->fcode_tab= umv_fcode_tab;
2078
        if(s->modified_quant){
2079
            s->min_qcoeff= -2047;
2080
            s->max_qcoeff=  2047;
2081
        }else{
2082
            s->min_qcoeff= -127;
2083
            s->max_qcoeff=  127;
2084
        }
2085
        break;
2086
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2087
    case CODEC_ID_FLV1:
2088
        if (s->h263_flv > 1) {
2089
            s->min_qcoeff= -1023;
2090
            s->max_qcoeff=  1023;
2091
        } else {
2092
            s->min_qcoeff= -127;
2093
            s->max_qcoeff=  127;
2094
        }
2095
        s->y_dc_scale_table=
2096
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2097
        break;
2098
    default: //nothing needed - default table already set in mpegvideo.c
2099
        s->min_qcoeff= -127;
2100
        s->max_qcoeff=  127;
2101
        s->y_dc_scale_table=
2102
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2103
    }
2104
}
2105

    
2106
/**
2107
 * encodes a 8x8 block.
2108
 * @param block the 8x8 block
2109
 * @param n block index (0-3 are luma, 4-5 are chroma)
2110
 */
2111
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2112
{
2113
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2114
    RLTable *rl;
2115

    
2116
    rl = &rl_inter;
2117
    if (s->mb_intra && !s->h263_aic) {
2118
        /* DC coef */
2119
        level = block[0];
2120
        /* 255 cannot be represented, so we clamp */
2121
        if (level > 254) {
2122
            level = 254;
2123
            block[0] = 254;
2124
        }
2125
        /* 0 cannot be represented also */
2126
        else if (level < 1) {
2127
            level = 1;
2128
            block[0] = 1;
2129
        }
2130
        if (level == 128) //FIXME check rv10
2131
            put_bits(&s->pb, 8, 0xff);
2132
        else
2133
            put_bits(&s->pb, 8, level);
2134
        i = 1;
2135
    } else {
2136
        i = 0;
2137
        if (s->h263_aic && s->mb_intra)
2138
            rl = &rl_intra_aic;
2139

    
2140
        if(s->alt_inter_vlc && !s->mb_intra){
2141
            int aic_vlc_bits=0;
2142
            int inter_vlc_bits=0;
2143
            int wrong_pos=-1;
2144
            int aic_code;
2145

    
2146
            last_index = s->block_last_index[n];
2147
            last_non_zero = i - 1;
2148
            for (; i <= last_index; i++) {
2149
                j = s->intra_scantable.permutated[i];
2150
                level = block[j];
2151
                if (level) {
2152
                    run = i - last_non_zero - 1;
2153
                    last = (i == last_index);
2154

    
2155
                    if(level<0) level= -level;
2156

    
2157
                    code = get_rl_index(rl, last, run, level);
2158
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2159
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2160
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2161

    
2162
                    if (code == rl->n) {
2163
                        inter_vlc_bits += 1+6+8-1;
2164
                    }
2165
                    if (aic_code == rl_intra_aic.n) {
2166
                        aic_vlc_bits += 1+6+8-1;
2167
                        wrong_pos += run + 1;
2168
                    }else
2169
                        wrong_pos += wrong_run[aic_code];
2170
                    last_non_zero = i;
2171
                }
2172
            }
2173
            i = 0;
2174
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2175
                rl = &rl_intra_aic;
2176
        }
2177
    }
2178

    
2179
    /* AC coefs */
2180
    last_index = s->block_last_index[n];
2181
    last_non_zero = i - 1;
2182
    for (; i <= last_index; i++) {
2183
        j = s->intra_scantable.permutated[i];
2184
        level = block[j];
2185
        if (level) {
2186
            run = i - last_non_zero - 1;
2187
            last = (i == last_index);
2188
            sign = 0;
2189
            slevel = level;
2190
            if (level < 0) {
2191
                sign = 1;
2192
                level = -level;
2193
            }
2194
            code = get_rl_index(rl, last, run, level);
2195
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2196
            if (code == rl->n) {
2197
              if(s->h263_flv <= 1){
2198
                put_bits(&s->pb, 1, last);
2199
                put_bits(&s->pb, 6, run);
2200

    
2201
                assert(slevel != 0);
2202

    
2203
                if(level < 128)
2204
                    put_bits(&s->pb, 8, slevel & 0xff);
2205
                else{
2206
                    put_bits(&s->pb, 8, 128);
2207
                    put_bits(&s->pb, 5, slevel & 0x1f);
2208
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2209
                }
2210
              }else{
2211
                if(level < 64) { // 7-bit level
2212
                        put_bits(&s->pb, 1, 0);
2213
                        put_bits(&s->pb, 1, last);
2214
                        put_bits(&s->pb, 6, run);
2215

    
2216
                        put_bits(&s->pb, 7, slevel & 0x7f);
2217
                    } else {
2218
                        /* 11-bit level */
2219
                        put_bits(&s->pb, 1, 1);
2220
                        put_bits(&s->pb, 1, last);
2221
                        put_bits(&s->pb, 6, run);
2222

    
2223
                        put_bits(&s->pb, 11, slevel & 0x7ff);
2224
                    }
2225
              }
2226
            } else {
2227
                put_bits(&s->pb, 1, sign);
2228
            }
2229
            last_non_zero = i;
2230
        }
2231
    }
2232
}
2233
#endif
2234

    
2235
#ifdef CONFIG_ENCODERS
2236

    
2237
/***************************************************/
2238
/**
2239
 * add mpeg4 stuffing bits (01...1)
2240
 */
2241
void ff_mpeg4_stuffing(PutBitContext * pbc)
2242
{
2243
    int length;
2244
    put_bits(pbc, 1, 0);
2245
    length= (-put_bits_count(pbc))&7;
2246
    if(length) put_bits(pbc, length, (1<<length)-1);
2247
}
2248

    
2249
/* must be called before writing the header */
2250
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2251
    int time_div, time_mod;
2252

    
2253
    assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2254
    s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2255

    
2256
    time_div= s->time/s->avctx->time_base.den;
2257
    time_mod= s->time%s->avctx->time_base.den;
2258

    
2259
    if(s->pict_type==B_TYPE){
2260
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2261
        assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2262
        ff_mpeg4_init_direct_mv(s);
2263
    }else{
2264
        s->last_time_base= s->time_base;
2265
        s->time_base= time_div;
2266
        s->pp_time= s->time - s->last_non_b_time;
2267
        s->last_non_b_time= s->time;
2268
        assert(picture_number==0 || s->pp_time > 0);
2269
    }
2270
}
2271

    
2272
static void mpeg4_encode_gop_header(MpegEncContext * s){
2273
    int hours, minutes, seconds;
2274
    int64_t time;
2275

    
2276
    put_bits(&s->pb, 16, 0);
2277
    put_bits(&s->pb, 16, GOP_STARTCODE);
2278

    
2279
    time= s->current_picture_ptr->pts;
2280
    if(s->reordered_input_picture[1])
2281
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2282
    time= time*s->avctx->time_base.num;
2283

    
2284
    seconds= time/s->avctx->time_base.den;
2285
    minutes= seconds/60; seconds %= 60;
2286
    hours= minutes/60; minutes %= 60;
2287
    hours%=24;
2288

    
2289
    put_bits(&s->pb, 5, hours);
2290
    put_bits(&s->pb, 6, minutes);
2291
    put_bits(&s->pb, 1, 1);
2292
    put_bits(&s->pb, 6, seconds);
2293

    
2294
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2295
    put_bits(&s->pb, 1, 0); //broken link == NO
2296

    
2297
    s->last_time_base= time / s->avctx->time_base.den;
2298

    
2299
    ff_mpeg4_stuffing(&s->pb);
2300
}
2301

    
2302
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2303
    int profile_and_level_indication;
2304
    int vo_ver_id;
2305

    
2306
    if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2307
        profile_and_level_indication = s->avctx->profile << 4;
2308
    }else if(s->max_b_frames || s->quarter_sample){
2309
        profile_and_level_indication= 0xF0; // adv simple
2310
    }else{
2311
        profile_and_level_indication= 0x00; // simple
2312
    }
2313

    
2314
    if(s->avctx->level != FF_LEVEL_UNKNOWN){
2315
        profile_and_level_indication |= s->avctx->level;
2316
    }else{
2317
        profile_and_level_indication |= 1; //level 1
2318
    }
2319

    
2320
    if(profile_and_level_indication>>4 == 0xF){
2321
        vo_ver_id= 5;
2322
    }else{
2323
        vo_ver_id= 1;
2324
    }
2325

    
2326
    //FIXME levels
2327

    
2328
    put_bits(&s->pb, 16, 0);
2329
    put_bits(&s->pb, 16, VOS_STARTCODE);
2330

    
2331
    put_bits(&s->pb, 8, profile_and_level_indication);
2332

    
2333
    put_bits(&s->pb, 16, 0);
2334
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2335

    
2336
    put_bits(&s->pb, 1, 1);
2337
        put_bits(&s->pb, 4, vo_ver_id);
2338
        put_bits(&s->pb, 3, 1); //priority
2339

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

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

    
2344
    ff_mpeg4_stuffing(&s->pb);
2345
}
2346

    
2347
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2348
{
2349
    int vo_ver_id;
2350

    
2351
    if(s->max_b_frames || s->quarter_sample){
2352
        vo_ver_id= 5;
2353
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2354
    }else{
2355
        vo_ver_id= 1;
2356
        s->vo_type= SIMPLE_VO_TYPE;
2357
    }
2358

    
2359
    put_bits(&s->pb, 16, 0);
2360
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2361
    put_bits(&s->pb, 16, 0);
2362
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2363

    
2364
    put_bits(&s->pb, 1, 0);             /* random access vol */
2365
    put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
2366
    if(s->workaround_bugs & FF_BUG_MS) {
2367
        put_bits(&s->pb, 1, 0);         /* is obj layer id= no */
2368
    } else {
2369
        put_bits(&s->pb, 1, 1);         /* is obj layer id= yes */
2370
        put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2371
        put_bits(&s->pb, 3, 1);         /* is obj layer priority */
2372
    }
2373

    
2374
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2375

    
2376
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2377
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2378
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2379
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2380
    }
2381

    
2382
    if(s->workaround_bugs & FF_BUG_MS) { //
2383
        put_bits(&s->pb, 1, 0);         /* vol control parameters= no @@@ */
2384
    } else {
2385
        put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
2386
        put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
2387
        put_bits(&s->pb, 1, s->low_delay);
2388
        put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
2389
    }
2390

    
2391
    put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2392
    put_bits(&s->pb, 1, 1);             /* marker bit */
2393

    
2394
    put_bits(&s->pb, 16, s->avctx->time_base.den);
2395
    if (s->time_increment_bits < 1)
2396
        s->time_increment_bits = 1;
2397
    put_bits(&s->pb, 1, 1);             /* marker bit */
2398
    put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
2399
    put_bits(&s->pb, 1, 1);             /* marker bit */
2400
    put_bits(&s->pb, 13, s->width);     /* vol width */
2401
    put_bits(&s->pb, 1, 1);             /* marker bit */
2402
    put_bits(&s->pb, 13, s->height);    /* vol height */
2403
    put_bits(&s->pb, 1, 1);             /* marker bit */
2404
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2405
    put_bits(&s->pb, 1, 1);             /* obmc disable */
2406
    if (vo_ver_id == 1) {
2407
        put_bits(&s->pb, 1, s->vol_sprite_usage);       /* sprite enable */
2408
    }else{
2409
        put_bits(&s->pb, 2, s->vol_sprite_usage);       /* sprite enable */
2410
    }
2411

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

    
2415
    if(s->mpeg_quant){
2416
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2417
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2418
    }
2419

    
2420
    if (vo_ver_id != 1)
2421
        put_bits(&s->pb, 1, s->quarter_sample);
2422
    put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
2423
    s->resync_marker= s->rtp_mode;
2424
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2425
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2426
    if(s->data_partitioning){
2427
        put_bits(&s->pb, 1, 0);         /* no rvlc */
2428
    }
2429

    
2430
    if (vo_ver_id != 1){
2431
        put_bits(&s->pb, 1, 0);         /* newpred */
2432
        put_bits(&s->pb, 1, 0);         /* reduced res vop */
2433
    }
2434
    put_bits(&s->pb, 1, 0);             /* scalability */
2435

    
2436
    ff_mpeg4_stuffing(&s->pb);
2437

    
2438
    /* user data */
2439
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2440
        put_bits(&s->pb, 16, 0);
2441
        put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2442
        ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2443
    }
2444
}
2445

    
2446
/* write mpeg4 VOP header */
2447
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2448
{
2449
    int time_incr;
2450
    int time_div, time_mod;
2451

    
2452
    if(s->pict_type==I_TYPE){
2453
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2454
            if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2455
                mpeg4_encode_visual_object_header(s);
2456
            if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2457
                mpeg4_encode_vol_header(s, 0, 0);
2458
        }
2459
        if(!(s->workaround_bugs & FF_BUG_MS))
2460
            mpeg4_encode_gop_header(s);
2461
    }
2462

    
2463
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2464

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

    
2467
    put_bits(&s->pb, 16, 0);                /* vop header */
2468
    put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
2469
    put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
2470

    
2471
    assert(s->time>=0);
2472
    time_div= s->time/s->avctx->time_base.den;
2473
    time_mod= s->time%s->avctx->time_base.den;
2474
    time_incr= time_div - s->last_time_base;
2475
    assert(time_incr >= 0);
2476
    while(time_incr--)
2477
        put_bits(&s->pb, 1, 1);
2478

    
2479
    put_bits(&s->pb, 1, 0);
2480

    
2481
    put_bits(&s->pb, 1, 1);                             /* marker */
2482
    put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2483
    put_bits(&s->pb, 1, 1);                             /* marker */
2484
    put_bits(&s->pb, 1, 1);                             /* vop coded */
2485
    if (    s->pict_type == P_TYPE
2486
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2487
        put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2488
    }
2489
    put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2490
    if(!s->progressive_sequence){
2491
         put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2492
         put_bits(&s->pb, 1, s->alternate_scan);
2493
    }
2494
    //FIXME sprite stuff
2495

    
2496
    put_bits(&s->pb, 5, s->qscale);
2497

    
2498
    if (s->pict_type != I_TYPE)
2499
        put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2500
    if (s->pict_type == B_TYPE)
2501
        put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2502
    //    printf("****frame %d\n", picture_number);
2503
}
2504

    
2505
#endif //CONFIG_ENCODERS
2506

    
2507
/**
2508
 * set qscale and update qscale dependant variables.
2509
 */
2510
void ff_set_qscale(MpegEncContext * s, int qscale)
2511
{
2512
    if (qscale < 1)
2513
        qscale = 1;
2514
    else if (qscale > 31)
2515
        qscale = 31;
2516

    
2517
    s->qscale = qscale;
2518
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2519

    
2520
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2521
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2522
}
2523

    
2524
/**
2525
 * predicts the dc.
2526
 * encoding quantized level -> quantized diff
2527
 * decoding quantized diff -> quantized level
2528
 * @param n block index (0-3 are luma, 4-5 are chroma)
2529
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2530
 */
2531
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2532
{
2533
    int a, b, c, wrap, pred, scale, ret;
2534
    int16_t *dc_val;
2535

    
2536
    /* find prediction */
2537
    if (n < 4) {
2538
        scale = s->y_dc_scale;
2539
    } else {
2540
        scale = s->c_dc_scale;
2541
    }
2542
    if(IS_3IV1)
2543
        scale= 8;
2544

    
2545
    wrap= s->block_wrap[n];
2546
    dc_val = s->dc_val[0] + s->block_index[n];
2547

    
2548
    /* B C
2549
     * A X
2550
     */
2551
    a = dc_val[ - 1];
2552
    b = dc_val[ - 1 - wrap];
2553
    c = dc_val[ - wrap];
2554

    
2555
    /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2556
    if(s->first_slice_line && n!=3){
2557
        if(n!=2) b=c= 1024;
2558
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2559
    }
2560
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2561
        if(n==0 || n==4 || n==5)
2562
            b=1024;
2563
    }
2564

    
2565
    if (abs(a - b) < abs(b - c)) {
2566
        pred = c;
2567
        *dir_ptr = 1; /* top */
2568
    } else {
2569
        pred = a;
2570
        *dir_ptr = 0; /* left */
2571
    }
2572
    /* we assume pred is positive */
2573
    pred = FASTDIV((pred + (scale >> 1)), scale);
2574

    
2575
    if(encoding){
2576
        ret = level - pred;
2577
    }else{
2578
        level += pred;
2579
        ret= level;
2580
        if(s->error_resilience>=3){
2581
            if(level<0){
2582
                av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2583
                return -1;
2584
            }
2585
            if(level*scale > 2048 + scale){
2586
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2587
                return -1;
2588
            }
2589
        }
2590
    }
2591
    level *=scale;
2592
    if(level&(~2047)){
2593
        if(level<0)
2594
            level=0;
2595
        else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2596
            level=2047;
2597
    }
2598
    dc_val[0]= level;
2599

    
2600
    return ret;
2601
}
2602

    
2603
/**
2604
 * predicts the ac.
2605
 * @param n block index (0-3 are luma, 4-5 are chroma)
2606
 * @param dir the ac prediction direction
2607
 */
2608
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2609
                   int dir)
2610
{
2611
    int i;
2612
    int16_t *ac_val, *ac_val1;
2613
    int8_t * const qscale_table= s->current_picture.qscale_table;
2614

    
2615
    /* find prediction */
2616
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2617
    ac_val1 = ac_val;
2618
    if (s->ac_pred) {
2619
        if (dir == 0) {
2620
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2621
            /* left prediction */
2622
            ac_val -= 16;
2623

    
2624
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2625
                /* same qscale */
2626
                for(i=1;i<8;i++) {
2627
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2628
                }
2629
            }else{
2630
                /* different qscale, we must rescale */
2631
                for(i=1;i<8;i++) {
2632
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2633
                }
2634
            }
2635
        } else {
2636
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2637
            /* top prediction */
2638
            ac_val -= 16 * s->block_wrap[n];
2639

    
2640
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2641
                /* same qscale */
2642
                for(i=1;i<8;i++) {
2643
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2644
                }
2645
            }else{
2646
                /* different qscale, we must rescale */
2647
                for(i=1;i<8;i++) {
2648
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2649
                }
2650
            }
2651
        }
2652
    }
2653
    /* left copy */
2654
    for(i=1;i<8;i++)
2655
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2656

    
2657
    /* top copy */
2658
    for(i=1;i<8;i++)
2659
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2660

    
2661
}
2662

    
2663
#ifdef CONFIG_ENCODERS
2664

    
2665
/**
2666
 * encodes the dc value.
2667
 * @param n block index (0-3 are luma, 4-5 are chroma)
2668
 */
2669
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2670
{
2671
#if 1
2672
//    if(level<-255 || level>255) printf("dc overflow\n");
2673
    level+=256;
2674
    if (n < 4) {
2675
        /* luminance */
2676
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2677
    } else {
2678
        /* chrominance */
2679
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2680
    }
2681
#else
2682
    int size, v;
2683
    /* find number of bits */
2684
    size = 0;
2685
    v = abs(level);
2686
    while (v) {
2687
        v >>= 1;
2688
        size++;
2689
    }
2690

    
2691
    if (n < 4) {
2692
        /* luminance */
2693
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2694
    } else {
2695
        /* chrominance */
2696
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2697
    }
2698

    
2699
    /* encode remaining bits */
2700
    if (size > 0) {
2701
        if (level < 0)
2702
            level = (-level) ^ ((1 << size) - 1);
2703
        put_bits(&s->pb, size, level);
2704
        if (size > 8)
2705
            put_bits(&s->pb, 1, 1);
2706
    }
2707
#endif
2708
}
2709

    
2710
static inline int mpeg4_get_dc_length(int level, int n){
2711
    if (n < 4) {
2712
        return uni_DCtab_lum_len[level + 256];
2713
    } else {
2714
        return uni_DCtab_chrom_len[level + 256];
2715
    }
2716
}
2717

    
2718
/**
2719
 * encodes a 8x8 block
2720
 * @param n block index (0-3 are luma, 4-5 are chroma)
2721
 */
2722
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2723
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2724
{
2725
    int i, last_non_zero;
2726
#if 0 //variables for the outcommented version
2727
    int code, sign, last;
2728
#endif
2729
    const RLTable *rl;
2730
    uint32_t *bits_tab;
2731
    uint8_t *len_tab;
2732
    const int last_index = s->block_last_index[n];
2733

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

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

    
2838
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2839
                               uint8_t *scan_table)
2840
{
2841
    int i, last_non_zero;
2842
    const RLTable *rl;
2843
    uint8_t *len_tab;
2844
    const int last_index = s->block_last_index[n];
2845
    int len=0;
2846

    
2847
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2848
        /* mpeg4 based DC predictor */
2849
        len += mpeg4_get_dc_length(intra_dc, n);
2850
        if(last_index<1) return len;
2851
        i = 1;
2852
        rl = &rl_intra;
2853
        len_tab = uni_mpeg4_intra_rl_len;
2854
    } else {
2855
        if(last_index<0) return 0;
2856
        i = 0;
2857
        rl = &rl_inter;
2858
        len_tab = uni_mpeg4_inter_rl_len;
2859
    }
2860

    
2861
    /* AC coefs */
2862
    last_non_zero = i - 1;
2863
    for (; i < last_index; i++) {
2864
        int level = block[ scan_table[i] ];
2865
        if (level) {
2866
            int run = i - last_non_zero - 1;
2867
            level+=64;
2868
            if((level&(~127)) == 0){
2869
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2870
                len += len_tab[index];
2871
            }else{ //ESC3
2872
                len += 7+2+1+6+1+12+1;
2873
            }
2874
            last_non_zero = i;
2875
        }
2876
    }
2877
    /*if(i<=last_index)*/{
2878
        int level = block[ scan_table[i] ];
2879
        int run = i - last_non_zero - 1;
2880
        level+=64;
2881
        if((level&(~127)) == 0){
2882
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2883
            len += len_tab[index];
2884
        }else{ //ESC3
2885
            len += 7+2+1+6+1+12+1;
2886
        }
2887
    }
2888

    
2889
    return len;
2890
}
2891

    
2892
#endif
2893

    
2894

    
2895
/***********************************************/
2896
/* decoding */
2897

    
2898
static VLC intra_MCBPC_vlc;
2899
static VLC inter_MCBPC_vlc;
2900
static VLC cbpy_vlc;
2901
static VLC mv_vlc;
2902
static VLC dc_lum, dc_chrom;
2903
static VLC sprite_trajectory;
2904
static VLC mb_type_b_vlc;
2905
static VLC h263_mbtype_b_vlc;
2906
static VLC cbpc_b_vlc;
2907

    
2908
void init_vlc_rl(RLTable *rl, int use_static)
2909
{
2910
    int i, q;
2911

    
2912
    /* Return if static table is already initialized */
2913
    if(use_static && rl->rl_vlc[0])
2914
        return;
2915

    
2916
    init_vlc(&rl->vlc, 9, rl->n + 1,
2917
             &rl->table_vlc[0][1], 4, 2,
2918
             &rl->table_vlc[0][0], 4, 2, use_static);
2919

    
2920

    
2921
    for(q=0; q<32; q++){
2922
        int qmul= q*2;
2923
        int qadd= (q-1)|1;
2924

    
2925
        if(q==0){
2926
            qmul=1;
2927
            qadd=0;
2928
        }
2929
        if(use_static)
2930
            rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2931
        else
2932
            rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2933
        for(i=0; i<rl->vlc.table_size; i++){
2934
            int code= rl->vlc.table[i][0];
2935
            int len = rl->vlc.table[i][1];
2936
            int level, run;
2937

    
2938
            if(len==0){ // illegal code
2939
                run= 66;
2940
                level= MAX_LEVEL;
2941
            }else if(len<0){ //more bits needed
2942
                run= 0;
2943
                level= code;
2944
            }else{
2945
                if(code==rl->n){ //esc
2946
                    run= 66;
2947
                    level= 0;
2948
                }else{
2949
                    run=   rl->table_run  [code] + 1;
2950
                    level= rl->table_level[code] * qmul + qadd;
2951
                    if(code >= rl->last) run+=192;
2952
                }
2953
            }
2954
            rl->rl_vlc[q][i].len= len;
2955
            rl->rl_vlc[q][i].level= level;
2956
            rl->rl_vlc[q][i].run= run;
2957
        }
2958
    }
2959
}
2960

    
2961
/* init vlcs */
2962

    
2963
/* XXX: find a better solution to handle static init */
2964
void h263_decode_init_vlc(MpegEncContext *s)
2965
{
2966
    static int done = 0;
2967

    
2968
    if (!done) {
2969
        done = 1;
2970

    
2971
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2972
                 intra_MCBPC_bits, 1, 1,
2973
                 intra_MCBPC_code, 1, 1, 1);
2974
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2975
                 inter_MCBPC_bits, 1, 1,
2976
                 inter_MCBPC_code, 1, 1, 1);
2977
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2978
                 &cbpy_tab[0][1], 2, 1,
2979
                 &cbpy_tab[0][0], 2, 1, 1);
2980
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2981
                 &mvtab[0][1], 2, 1,
2982
                 &mvtab[0][0], 2, 1, 1);
2983
        init_rl(&rl_inter, 1);
2984
        init_rl(&rl_intra, 1);
2985
        init_rl(&rvlc_rl_inter, 1);
2986
        init_rl(&rvlc_rl_intra, 1);
2987
        init_rl(&rl_intra_aic, 1);
2988
        init_vlc_rl(&rl_inter, 1);
2989
        init_vlc_rl(&rl_intra, 1);
2990
        init_vlc_rl(&rvlc_rl_inter, 1);
2991
        init_vlc_rl(&rvlc_rl_intra, 1);
2992
        init_vlc_rl(&rl_intra_aic, 1);
2993
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2994
                 &DCtab_lum[0][1], 2, 1,
2995
                 &DCtab_lum[0][0], 2, 1, 1);
2996
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2997
                 &DCtab_chrom[0][1], 2, 1,
2998
                 &DCtab_chrom[0][0], 2, 1, 1);
2999
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
3000
                 &sprite_trajectory_tab[0][1], 4, 2,
3001
                 &sprite_trajectory_tab[0][0], 4, 2, 1);
3002
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
3003
                 &mb_type_b_tab[0][1], 2, 1,
3004
                 &mb_type_b_tab[0][0], 2, 1, 1);
3005
        init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
3006
                 &h263_mbtype_b_tab[0][1], 2, 1,
3007
                 &h263_mbtype_b_tab[0][0], 2, 1, 1);
3008
        init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
3009
                 &cbpc_b_tab[0][1], 2, 1,
3010
                 &cbpc_b_tab[0][0], 2, 1, 1);
3011
    }
3012
}
3013

    
3014
/**
3015
 * Get the GOB height based on picture height.
3016
 */
3017
int ff_h263_get_gob_height(MpegEncContext *s){
3018
    if (s->height <= 400)
3019
        return 1;
3020
    else if (s->height <= 800)
3021
        return  2;
3022
    else
3023
        return 4;
3024
}
3025

    
3026
int ff_h263_decode_mba(MpegEncContext *s)
3027
{
3028
    int i, mb_pos;
3029

    
3030
    for(i=0; i<6; i++){
3031
        if(s->mb_num-1 <= ff_mba_max[i]) break;
3032
    }
3033
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
3034
    s->mb_x= mb_pos % s->mb_width;
3035
    s->mb_y= mb_pos / s->mb_width;
3036

    
3037
    return mb_pos;
3038
}
3039

    
3040
void ff_h263_encode_mba(MpegEncContext *s)
3041
{
3042
    int i, mb_pos;
3043

    
3044
    for(i=0; i<6; i++){
3045
        if(s->mb_num-1 <= ff_mba_max[i]) break;
3046
    }
3047
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
3048
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
3049
}
3050

    
3051
/**
3052
 * decodes the group of blocks header or slice header.
3053
 * @return <0 if an error occured
3054
 */
3055
static int h263_decode_gob_header(MpegEncContext *s)
3056
{
3057
    unsigned int val, gfid, gob_number;
3058
    int left;
3059

    
3060
    /* Check for GOB Start Code */
3061
    val = show_bits(&s->gb, 16);
3062
    if(val)
3063
        return -1;
3064

    
3065
        /* We have a GBSC probably with GSTUFF */
3066
    skip_bits(&s->gb, 16); /* Drop the zeros */
3067
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3068
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3069
    for(;left>13; left--){
3070
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3071
    }
3072
    if(left<=13)
3073
        return -1;
3074

    
3075
    if(s->h263_slice_structured){
3076
        if(get_bits1(&s->gb)==0)
3077
            return -1;
3078

    
3079
        ff_h263_decode_mba(s);
3080

    
3081
        if(s->mb_num > 1583)
3082
            if(get_bits1(&s->gb)==0)
3083
                return -1;
3084

    
3085
        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3086
        if(get_bits1(&s->gb)==0)
3087
            return -1;
3088
        gfid = get_bits(&s->gb, 2); /* GFID */
3089
    }else{
3090
        gob_number = get_bits(&s->gb, 5); /* GN */
3091
        s->mb_x= 0;
3092
        s->mb_y= s->gob_index* gob_number;
3093
        gfid = get_bits(&s->gb, 2); /* GFID */
3094
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3095
    }
3096

    
3097
    if(s->mb_y >= s->mb_height)
3098
        return -1;
3099

    
3100
    if(s->qscale==0)
3101
        return -1;
3102

    
3103
    return 0;
3104
}
3105

    
3106
static inline void memsetw(short *tab, int val, int n)
3107
{
3108
    int i;
3109
    for(i=0;i<n;i++)
3110
        tab[i] = val;
3111
}
3112

    
3113
#ifdef CONFIG_ENCODERS
3114

    
3115
void ff_mpeg4_init_partitions(MpegEncContext *s)
3116
{
3117
    uint8_t *start= pbBufPtr(&s->pb);
3118
    uint8_t *end= s->pb.buf_end;
3119
    int size= end - start;
3120
    int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3121
    int tex_size= (size - 2*pb_size)&(~3);
3122

    
3123
    set_put_bits_buffer_size(&s->pb, pb_size);
3124
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3125
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3126
}
3127

    
3128
void ff_mpeg4_merge_partitions(MpegEncContext *s)
3129
{
3130
    const int pb2_len   = put_bits_count(&s->pb2   );
3131
    const int tex_pb_len= put_bits_count(&s->tex_pb);
3132
    const int bits= put_bits_count(&s->pb);
3133

    
3134
    if(s->pict_type==I_TYPE){
3135
        put_bits(&s->pb, 19, DC_MARKER);
3136
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3137
        s->i_tex_bits+= tex_pb_len;
3138
    }else{
3139
        put_bits(&s->pb, 17, MOTION_MARKER);
3140
        s->misc_bits+=17 + pb2_len;
3141
        s->mv_bits+= bits - s->last_bits;
3142
        s->p_tex_bits+= tex_pb_len;
3143
    }
3144

    
3145
    flush_put_bits(&s->pb2);
3146
    flush_put_bits(&s->tex_pb);
3147

    
3148
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3149
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3150
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3151
    s->last_bits= put_bits_count(&s->pb);
3152
}
3153

    
3154
#endif //CONFIG_ENCODERS
3155

    
3156
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3157
    switch(s->pict_type){
3158
        case I_TYPE:
3159
            return 16;
3160
        case P_TYPE:
3161
        case S_TYPE:
3162
            return s->f_code+15;
3163
        case B_TYPE:
3164
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3165
        default:
3166
            return -1;
3167
    }
3168
}
3169

    
3170
#ifdef CONFIG_ENCODERS
3171

    
3172
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3173
{
3174
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3175

    
3176
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3177
    put_bits(&s->pb, 1, 1);
3178

    
3179
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3180
    put_bits(&s->pb, s->quant_precision, s->qscale);
3181
    put_bits(&s->pb, 1, 0); /* no HEC */
3182
}
3183

    
3184
#endif //CONFIG_ENCODERS
3185

    
3186
/**
3187
 * check if the next stuff is a resync marker or the end.
3188
 * @return 0 if not
3189
 */
3190
static inline int mpeg4_is_resync(MpegEncContext *s){
3191
    int bits_count= get_bits_count(&s->gb);
3192
    int v= show_bits(&s->gb, 16);
3193

    
3194
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3195
        return 0;
3196
    }
3197

    
3198
    while(v<=0xFF){
3199
        if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1))
3200
            break;
3201
        skip_bits(&s->gb, 8+s->pict_type);
3202
        bits_count+= 8+s->pict_type;
3203
        v= show_bits(&s->gb, 16);
3204
    }
3205

    
3206
    if(bits_count + 8 >= s->gb.size_in_bits){
3207
        v>>=8;
3208
        v|= 0x7F >> (7-(bits_count&7));
3209

    
3210
        if(v==0x7F)
3211
            return 1;
3212
    }else{
3213
        if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3214
            int len;
3215
            GetBitContext gb= s->gb;
3216

    
3217
            skip_bits(&s->gb, 1);
3218
            align_get_bits(&s->gb);
3219

    
3220
            for(len=0; len<32; len++){
3221
                if(get_bits1(&s->gb)) break;
3222
            }
3223

    
3224
            s->gb= gb;
3225

    
3226
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3227
                return 1;
3228
        }
3229
    }
3230
    return 0;
3231
}
3232

    
3233
/**
3234
 * decodes the next video packet.
3235
 * @return <0 if something went wrong
3236
 */
3237
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3238
{
3239
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3240
    int header_extension=0, mb_num, len;
3241

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

    
3245
    for(len=0; len<32; len++){
3246
        if(get_bits1(&s->gb)) break;
3247
    }
3248

    
3249
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3250
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3251
        return -1;
3252
    }
3253

    
3254
    if(s->shape != RECT_SHAPE){
3255
        header_extension= get_bits1(&s->gb);
3256
        //FIXME more stuff here
3257
    }
3258

    
3259
    mb_num= get_bits(&s->gb, mb_num_bits);
3260
    if(mb_num>=s->mb_num){
3261
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3262
        return -1;
3263
    }
3264
    if(s->pict_type == B_TYPE){
3265
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3266
        if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3267
    }
3268

    
3269
    s->mb_x= mb_num % s->mb_width;
3270
    s->mb_y= mb_num / s->mb_width;
3271

    
3272
    if(s->shape != BIN_ONLY_SHAPE){
3273
        int qscale= get_bits(&s->gb, s->quant_precision);
3274
        if(qscale)
3275
            s->chroma_qscale=s->qscale= qscale;
3276
    }
3277

    
3278
    if(s->shape == RECT_SHAPE){
3279
        header_extension= get_bits1(&s->gb);
3280
    }
3281
    if(header_extension){
3282
        int time_increment;
3283
        int time_incr=0;
3284

    
3285
        while (get_bits1(&s->gb) != 0)
3286
            time_incr++;
3287

    
3288
        check_marker(&s->gb, "before time_increment in video packed header");
3289
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3290
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3291

    
3292
        skip_bits(&s->gb, 2); /* vop coding type */
3293
        //FIXME not rect stuff here
3294

    
3295
        if(s->shape != BIN_ONLY_SHAPE){
3296
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3297
//FIXME don't just ignore everything
3298
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3299
                mpeg4_decode_sprite_trajectory(s, &s->gb);
3300
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3301
            }
3302

    
3303
            //FIXME reduced res stuff here
3304

    
3305
            if (s->pict_type != I_TYPE) {
3306
                int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3307
                if(f_code==0){
3308
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3309
                }
3310
            }
3311
            if (s->pict_type == B_TYPE) {
3312
                int b_code = get_bits(&s->gb, 3);
3313
                if(b_code==0){
3314
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3315
                }
3316
            }
3317
        }
3318
    }
3319
    //FIXME new-pred stuff
3320

    
3321
//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));
3322

    
3323
    return 0;
3324
}
3325

    
3326
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3327
{
3328
    int c_wrap, c_xy, l_wrap, l_xy;
3329

    
3330
    l_wrap= s->b8_stride;
3331
    l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3332
    c_wrap= s->mb_stride;
3333
    c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3334

    
3335
#if 0
3336
    /* clean DC */
3337
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3338
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3339
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3340
#endif
3341

    
3342
    /* clean AC */
3343
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3344
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3345
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3346

    
3347
    /* clean MV */
3348
    // we can't clear the MVs as they might be needed by a b frame
3349
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3350
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3351
    s->last_mv[0][0][0]=
3352
    s->last_mv[0][0][1]=
3353
    s->last_mv[1][0][0]=
3354
    s->last_mv[1][0][1]= 0;
3355
}
3356

    
3357
/**
3358
 * decodes the group of blocks / video packet header.
3359
 * @return <0 if no resync found
3360
 */
3361
int ff_h263_resync(MpegEncContext *s){
3362
    int left, ret;
3363

    
3364
    if(s->codec_id==CODEC_ID_MPEG4){
3365
        skip_bits1(&s->gb);
3366
        align_get_bits(&s->gb);
3367
    }
3368

    
3369
    if(show_bits(&s->gb, 16)==0){
3370
        if(s->codec_id==CODEC_ID_MPEG4)
3371
            ret= mpeg4_decode_video_packet_header(s);
3372
        else
3373
            ret= h263_decode_gob_header(s);
3374
        if(ret>=0)
3375
            return 0;
3376
    }
3377
    //ok, it's not where its supposed to be ...
3378
    s->gb= s->last_resync_gb;
3379
    align_get_bits(&s->gb);
3380
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3381

    
3382
    for(;left>16+1+5+5; left-=8){
3383
        if(show_bits(&s->gb, 16)==0){
3384
            GetBitContext bak= s->gb;
3385

    
3386
            if(s->codec_id==CODEC_ID_MPEG4)
3387
                ret= mpeg4_decode_video_packet_header(s);
3388
            else
3389
                ret= h263_decode_gob_header(s);
3390
            if(ret>=0)
3391
                return 0;
3392

    
3393
            s->gb= bak;
3394
        }
3395
        skip_bits(&s->gb, 8);
3396
    }
3397

    
3398
    return -1;
3399
}
3400

    
3401
/**
3402
 * gets the average motion vector for a GMC MB.
3403
 * @param n either 0 for the x component or 1 for y
3404
 * @returns the average MV for a GMC MB
3405
 */
3406
static inline int get_amv(MpegEncContext *s, int n){
3407
    int x, y, mb_v, sum, dx, dy, shift;
3408
    int len = 1 << (s->f_code + 4);
3409
    const int a= s->sprite_warping_accuracy;
3410

    
3411
    if(s->workaround_bugs & FF_BUG_AMV)
3412
        len >>= s->quarter_sample;
3413

    
3414
    if(s->real_sprite_warping_points==1){
3415
        if(s->divx_version==500 && s->divx_build==413)
3416
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3417
        else
3418
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3419
    }else{
3420
        dx= s->sprite_delta[n][0];
3421
        dy= s->sprite_delta[n][1];
3422
        shift= s->sprite_shift[0];
3423
        if(n) dy -= 1<<(shift + a + 1);
3424
        else  dx -= 1<<(shift + a + 1);
3425
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3426

    
3427
        sum=0;
3428
        for(y=0; y<16; y++){
3429
            int v;
3430

    
3431
            v= mb_v + dy*y;
3432
            //XXX FIXME optimize
3433
            for(x=0; x<16; x++){
3434
                sum+= v>>shift;
3435
                v+= dx;
3436
            }
3437
        }
3438
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3439
    }
3440

    
3441
    if      (sum < -len) sum= -len;
3442
    else if (sum >= len) sum= len-1;
3443

    
3444
    return sum;
3445
}
3446

    
3447
/**
3448
 * decodes first partition.
3449
 * @return number of MBs decoded or <0 if an error occured
3450
 */
3451
static int mpeg4_decode_partition_a(MpegEncContext *s){
3452
    int mb_num;
3453
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3454

    
3455
    /* decode first partition */
3456
    mb_num=0;
3457
    s->first_slice_line=1;
3458
    for(; s->mb_y<s->mb_height; s->mb_y++){
3459
        ff_init_block_index(s);
3460
        for(; s->mb_x<s->mb_width; s->mb_x++){
3461
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3462
            int cbpc;
3463
            int dir=0;
3464

    
3465
            mb_num++;
3466
            ff_update_block_index(s);
3467
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3468
                s->first_slice_line=0;
3469

    
3470
            if(s->pict_type==I_TYPE){
3471
                int i;
3472

    
3473
                do{
3474
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
3475
                        return mb_num-1;
3476
                    }
3477

    
3478
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3479
                    if (cbpc < 0){
3480
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3481
                        return -1;
3482
                    }
3483
                }while(cbpc == 8);
3484

    
3485
                s->cbp_table[xy]= cbpc & 3;
3486
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3487
                s->mb_intra = 1;
3488

    
3489
                if(cbpc & 4) {
3490
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3491
                }
3492
                s->current_picture.qscale_table[xy]= s->qscale;
3493

    
3494
                s->mbintra_table[xy]= 1;
3495
                for(i=0; i<6; i++){
3496
                    int dc_pred_dir;
3497
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3498
                    if(dc < 0){
3499
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3500
                        return -1;
3501
                    }
3502
                    dir<<=1;
3503
                    if(dc_pred_dir) dir|=1;
3504
                }
3505
                s->pred_dir_table[xy]= dir;
3506
            }else{ /* P/S_TYPE */
3507
                int mx, my, pred_x, pred_y, bits;
3508
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3509
                const int stride= s->b8_stride*2;
3510

    
3511
try_again:
3512
                bits= show_bits(&s->gb, 17);
3513
                if(bits==MOTION_MARKER){
3514
                    return mb_num-1;
3515
                }
3516
                skip_bits1(&s->gb);
3517
                if(bits&0x10000){
3518
                    /* skip mb */
3519
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3520
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3521
                        mx= get_amv(s, 0);
3522
                        my= get_amv(s, 1);
3523
                    }else{
3524
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3525
                        mx=my=0;
3526
                    }
3527
                    mot_val[0       ]= mot_val[2       ]=
3528
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3529
                    mot_val[1       ]= mot_val[3       ]=
3530
                    mot_val[1+stride]= mot_val[3+stride]= my;
3531

    
3532
                    if(s->mbintra_table[xy])
3533
                        ff_clean_intra_table_entries(s);
3534
                    continue;
3535
                }
3536

    
3537
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3538
                if (cbpc < 0){
3539
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3540
                    return -1;
3541
                }
3542
                if(cbpc == 20)
3543
                    goto try_again;
3544

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

    
3547
                s->mb_intra = ((cbpc & 4) != 0);
3548

    
3549
                if(s->mb_intra){
3550
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3551
                    s->mbintra_table[xy]= 1;
3552
                    mot_val[0       ]= mot_val[2       ]=
3553
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3554
                    mot_val[1       ]= mot_val[3       ]=
3555
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3556
                }else{
3557
                    if(s->mbintra_table[xy])
3558
                        ff_clean_intra_table_entries(s);
3559

    
3560
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3561
                        s->mcsel= get_bits1(&s->gb);
3562
                    else s->mcsel= 0;
3563

    
3564
                    if ((cbpc & 16) == 0) {
3565
                        /* 16x16 motion prediction */
3566

    
3567
                        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3568
                        if(!s->mcsel){
3569
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3570
                            if (mx >= 0xffff)
3571
                                return -1;
3572

    
3573
                            my = h263_decode_motion(s, pred_y, s->f_code);
3574
                            if (my >= 0xffff)
3575
                                return -1;
3576
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3577
                        } else {
3578
                            mx = get_amv(s, 0);
3579
                            my = get_amv(s, 1);
3580
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3581
                        }
3582

    
3583
                        mot_val[0       ]= mot_val[2       ] =
3584
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3585
                        mot_val[1       ]= mot_val[3       ]=
3586
                        mot_val[1+stride]= mot_val[3+stride]= my;
3587
                    } else {
3588
                        int i;
3589
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3590
                        for(i=0;i<4;i++) {
3591
                            int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3592
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3593
                            if (mx >= 0xffff)
3594
                                return -1;
3595

    
3596
                            my = h263_decode_motion(s, pred_y, s->f_code);
3597
                            if (my >= 0xffff)
3598
                                return -1;
3599
                            mot_val[0] = mx;
3600
                            mot_val[1] = my;
3601
                        }
3602
                    }
3603
                }
3604
            }
3605
        }
3606
        s->mb_x= 0;
3607
    }
3608

    
3609
    return mb_num;
3610
}
3611

    
3612
/**
3613
 * decode second partition.
3614
 * @return <0 if an error occured
3615
 */
3616
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3617
    int mb_num=0;
3618
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3619

    
3620
    s->mb_x= s->resync_mb_x;
3621
    s->first_slice_line=1;
3622
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3623
        ff_init_block_index(s);
3624
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3625
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3626

    
3627
            mb_num++;
3628
            ff_update_block_index(s);
3629
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3630
                s->first_slice_line=0;
3631

    
3632
            if(s->pict_type==I_TYPE){
3633
                int ac_pred= get_bits1(&s->gb);
3634
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3635
                if(cbpy<0){
3636
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3637
                    return -1;
3638
                }
3639

    
3640
                s->cbp_table[xy]|= cbpy<<2;
3641
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3642
            }else{ /* P || S_TYPE */
3643
                if(IS_INTRA(s->current_picture.mb_type[xy])){
3644
                    int dir=0,i;
3645
                    int ac_pred = get_bits1(&s->gb);
3646
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3647

    
3648
                    if(cbpy<0){
3649
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3650
                        return -1;
3651
                    }
3652

    
3653
                    if(s->cbp_table[xy] & 8) {
3654
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3655
                    }
3656
                    s->current_picture.qscale_table[xy]= s->qscale;
3657

    
3658
                    for(i=0; i<6; i++){
3659
                        int dc_pred_dir;
3660
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3661
                        if(dc < 0){
3662
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3663
                            return -1;
3664
                        }
3665
                        dir<<=1;
3666
                        if(dc_pred_dir) dir|=1;
3667
                    }
3668
                    s->cbp_table[xy]&= 3; //remove dquant
3669
                    s->cbp_table[xy]|= cbpy<<2;
3670
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3671
                    s->pred_dir_table[xy]= dir;
3672
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3673
                    s->current_picture.qscale_table[xy]= s->qscale;
3674
                    s->cbp_table[xy]= 0;
3675
                }else{
3676
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3677

    
3678
                    if(cbpy<0){
3679
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3680
                        return -1;
3681
                    }
3682

    
3683
                    if(s->cbp_table[xy] & 8) {
3684
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3685
                    }
3686
                    s->current_picture.qscale_table[xy]= s->qscale;
3687

    
3688
                    s->cbp_table[xy]&= 3; //remove dquant
3689
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3690
                }
3691
            }
3692
        }
3693
        if(mb_num >= mb_count) return 0;
3694
        s->mb_x= 0;
3695
    }
3696
    return 0;
3697
}
3698

    
3699
/**
3700
 * decodes the first & second partition
3701
 * @return <0 if error (and sets error type in the error_status_table)
3702
 */
3703
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3704
{
3705
    int mb_num;
3706
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3707
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3708

    
3709
    mb_num= mpeg4_decode_partition_a(s);
3710
    if(mb_num<0){
3711
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3712
        return -1;
3713
    }
3714

    
3715
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3716
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3717
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3718
        return -1;
3719
    }
3720

    
3721
    s->mb_num_left= mb_num;
3722

    
3723
    if(s->pict_type==I_TYPE){
3724
        while(show_bits(&s->gb, 9) == 1)
3725
            skip_bits(&s->gb, 9);
3726
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3727
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3728
            return -1;
3729
        }
3730
    }else{
3731
        while(show_bits(&s->gb, 10) == 1)
3732
            skip_bits(&s->gb, 10);
3733
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3734
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3735
            return -1;
3736
        }
3737
    }
3738
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3739

    
3740
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3741
        if(s->pict_type==P_TYPE)
3742
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3743
        return -1;
3744
    }else{
3745
        if(s->pict_type==P_TYPE)
3746
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3747
    }
3748

    
3749
    return 0;
3750
}
3751

    
3752
/**
3753
 * decode partition C of one MB.
3754
 * @return <0 if an error occured
3755
 */
3756
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3757
{
3758
    int cbp, mb_type;
3759
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3760

    
3761
    mb_type= s->current_picture.mb_type[xy];
3762
    cbp = s->cbp_table[xy];
3763

    
3764
    s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3765

    
3766
    if(s->current_picture.qscale_table[xy] != s->qscale){
3767
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3768
    }
3769

    
3770
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3771
        int i;
3772
        for(i=0; i<4; i++){
3773
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3774
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3775
        }
3776
        s->mb_intra = IS_INTRA(mb_type);
3777

    
3778
        if (IS_SKIP(mb_type)) {
3779
            /* skip mb */
3780
            for(i=0;i<6;i++)
3781
                s->block_last_index[i] = -1;
3782
            s->mv_dir = MV_DIR_FORWARD;
3783
            s->mv_type = MV_TYPE_16X16;
3784
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3785
                s->mcsel=1;
3786
                s->mb_skipped = 0;
3787
            }else{
3788
                s->mcsel=0;
3789
                s->mb_skipped = 1;
3790
            }
3791
        }else if(s->mb_intra){
3792
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3793
        }else if(!s->mb_intra){
3794
//            s->mcsel= 0; //FIXME do we need to init that
3795

    
3796
            s->mv_dir = MV_DIR_FORWARD;
3797
            if (IS_8X8(mb_type)) {
3798
                s->mv_type = MV_TYPE_8X8;
3799
            } else {
3800
                s->mv_type = MV_TYPE_16X16;
3801
            }
3802
        }
3803
    } else { /* I-Frame */
3804
        s->mb_intra = 1;
3805
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3806
    }
3807

    
3808
    if (!IS_SKIP(mb_type)) {
3809
        int i;
3810
        s->dsp.clear_blocks(s->block[0]);
3811
        /* decode each block */
3812
        for (i = 0; i < 6; i++) {
3813
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3814
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3815
                return -1;
3816
            }
3817
            cbp+=cbp;
3818
        }
3819
    }
3820

    
3821
    /* per-MB end of slice check */
3822

    
3823
    if(--s->mb_num_left <= 0){
3824
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3825
        if(mpeg4_is_resync(s))
3826
            return SLICE_END;
3827
        else
3828
            return SLICE_NOEND;
3829
    }else{
3830
        if(mpeg4_is_resync(s)){
3831
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3832
            if(s->cbp_table[xy+delta])
3833
                return SLICE_END;
3834
        }
3835
        return SLICE_OK;
3836
    }
3837
}
3838

    
3839
/**
3840
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3841
 */
3842
static void preview_obmc(MpegEncContext *s){
3843
    GetBitContext gb= s->gb;
3844

    
3845
    int cbpc, i, pred_x, pred_y, mx, my;
3846
    int16_t *mot_val;
3847
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3848
    const int stride= s->b8_stride*2;
3849

    
3850
    for(i=0; i<4; i++)
3851
        s->block_index[i]+= 2;
3852
    for(i=4; i<6; i++)
3853
        s->block_index[i]+= 1;
3854
    s->mb_x++;
3855

    
3856
    assert(s->pict_type == P_TYPE);
3857

    
3858
    do{
3859
        if (get_bits1(&s->gb)) {
3860
            /* skip mb */
3861
            mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3862
            mot_val[0       ]= mot_val[2       ]=
3863
            mot_val[0+stride]= mot_val[2+stride]= 0;
3864
            mot_val[1       ]= mot_val[3       ]=
3865
            mot_val[1+stride]= mot_val[3+stride]= 0;
3866

    
3867
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3868
            goto end;
3869
        }
3870
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3871
    }while(cbpc == 20);
3872

    
3873
    if(cbpc & 4){
3874
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3875
    }else{
3876
        get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3877
        if (cbpc & 8) {
3878
            if(s->modified_quant){
3879
                if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3880
                else                  skip_bits(&s->gb, 5);
3881
            }else
3882
                skip_bits(&s->gb, 2);
3883
        }
3884

    
3885
        if ((cbpc & 16) == 0) {
3886
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3887
                /* 16x16 motion prediction */
3888
                mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3889
                if (s->umvplus)
3890
                   mx = h263p_decode_umotion(s, pred_x);
3891
                else
3892
                   mx = h263_decode_motion(s, pred_x, 1);
3893

    
3894
                if (s->umvplus)
3895
                   my = h263p_decode_umotion(s, pred_y);
3896
                else
3897
                   my = h263_decode_motion(s, pred_y, 1);
3898

    
3899
                mot_val[0       ]= mot_val[2       ]=
3900
                mot_val[0+stride]= mot_val[2+stride]= mx;
3901
                mot_val[1       ]= mot_val[3       ]=
3902
                mot_val[1+stride]= mot_val[3+stride]= my;
3903
        } else {
3904
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3905
            for(i=0;i<4;i++) {
3906
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3907
                if (s->umvplus)
3908
                  mx = h263p_decode_umotion(s, pred_x);
3909
                else
3910
                  mx = h263_decode_motion(s, pred_x, 1);
3911

    
3912
                if (s->umvplus)
3913
                  my = h263p_decode_umotion(s, pred_y);
3914
                else
3915
                  my = h263_decode_motion(s, pred_y, 1);
3916
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3917
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3918
                mot_val[0] = mx;
3919
                mot_val[1] = my;
3920
            }
3921
        }
3922
    }
3923
end:
3924

    
3925
    for(i=0; i<4; i++)
3926
        s->block_index[i]-= 2;
3927
    for(i=4; i<6; i++)
3928
        s->block_index[i]-= 1;
3929
    s->mb_x--;
3930

    
3931
    s->gb= gb;
3932
}
3933

    
3934
static void h263_decode_dquant(MpegEncContext *s){
3935
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3936

    
3937
    if(s->modified_quant){
3938
        if(get_bits1(&s->gb))
3939
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3940
        else
3941
            s->qscale= get_bits(&s->gb, 5);
3942
    }else
3943
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3944
    ff_set_qscale(s, s->qscale);
3945
}
3946

    
3947
int ff_h263_decode_mb(MpegEncContext *s,
3948
                      DCTELEM block[6][64])
3949
{
3950
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3951
    int16_t *mot_val;
3952
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3953

    
3954
    assert(!s->h263_pred);
3955

    
3956
    if (s->pict_type == P_TYPE) {
3957
        do{
3958
            if (get_bits1(&s->gb)) {
3959
                /* skip mb */
3960
                s->mb_intra = 0;
3961
                for(i=0;i<6;i++)
3962
                    s->block_last_index[i] = -1;
3963
                s->mv_dir = MV_DIR_FORWARD;
3964
                s->mv_type = MV_TYPE_16X16;
3965
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3966
                s->mv[0][0][0] = 0;
3967
                s->mv[0][0][1] = 0;
3968
                s->mb_skipped = !(s->obmc | s->loop_filter);
3969
                goto end;
3970
            }
3971
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3972
            //fprintf(stderr, "\tCBPC: %d", cbpc);
3973
            if (cbpc < 0){
3974
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3975
                return -1;
3976
            }
3977
        }while(cbpc == 20);
3978

    
3979
        s->dsp.clear_blocks(s->block[0]);
3980

    
3981
        dquant = cbpc & 8;
3982
        s->mb_intra = ((cbpc & 4) != 0);
3983
        if (s->mb_intra) goto intra;
3984

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

    
3987
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3988
            cbpy ^= 0xF;
3989

    
3990
        cbp = (cbpc & 3) | (cbpy << 2);
3991
        if (dquant) {
3992
            h263_decode_dquant(s);
3993
        }
3994

    
3995
        s->mv_dir = MV_DIR_FORWARD;
3996
        if ((cbpc & 16) == 0) {
3997
            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3998
            /* 16x16 motion prediction */
3999
            s->mv_type = MV_TYPE_16X16;
4000
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4001
            if (s->umvplus)
4002
               mx = h263p_decode_umotion(s, pred_x);
4003
            else
4004
               mx = h263_decode_motion(s, pred_x, 1);
4005

    
4006
            if (mx >= 0xffff)
4007
                return -1;
4008

    
4009
            if (s->umvplus)
4010
               my = h263p_decode_umotion(s, pred_y);
4011
            else
4012
               my = h263_decode_motion(s, pred_y, 1);
4013

    
4014
            if (my >= 0xffff)
4015
                return -1;
4016
            s->mv[0][0][0] = mx;
4017
            s->mv[0][0][1] = my;
4018

    
4019
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4020
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4021
        } else {
4022
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4023
            s->mv_type = MV_TYPE_8X8;
4024
            for(i=0;i<4;i++) {
4025
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4026
                if (s->umvplus)
4027
                  mx = h263p_decode_umotion(s, pred_x);
4028
                else
4029
                  mx = h263_decode_motion(s, pred_x, 1);
4030
                if (mx >= 0xffff)
4031
                    return -1;
4032

    
4033
                if (s->umvplus)
4034
                  my = h263p_decode_umotion(s, pred_y);
4035
                else
4036
                  my = h263_decode_motion(s, pred_y, 1);
4037
                if (my >= 0xffff)
4038
                    return -1;
4039
                s->mv[0][i][0] = mx;
4040
                s->mv[0][i][1] = my;
4041
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4042
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4043
                mot_val[0] = mx;
4044
                mot_val[1] = my;
4045
            }
4046
        }
4047

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

    
4055
        if(s->obmc){
4056
            if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4057
                preview_obmc(s);
4058
        }
4059
    } else if(s->pict_type==B_TYPE) {
4060
        int mb_type;
4061
        const int stride= s->b8_stride;
4062
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4063
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4064
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4065

    
4066
        //FIXME ugly
4067
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4068
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4069
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4070
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4071

    
4072
        do{
4073
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4074
            if (mb_type < 0){
4075
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4076
                return -1;
4077
            }
4078

    
4079
            mb_type= h263_mb_type_b_map[ mb_type ];
4080
        }while(!mb_type);
4081

    
4082
        s->mb_intra = IS_INTRA(mb_type);
4083
        if(HAS_CBP(mb_type)){
4084
            s->dsp.clear_blocks(s->block[0]);
4085
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4086
            if(s->mb_intra){
4087
                dquant = IS_QUANT(mb_type);
4088
                goto intra;
4089
            }
4090

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

    
4093
            if (cbpy < 0){
4094
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4095
                return -1;
4096
            }
4097

    
4098
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4099
                cbpy ^= 0xF;
4100

    
4101
            cbp = (cbpc & 3) | (cbpy << 2);
4102
        }else
4103
            cbp=0;
4104

    
4105
        assert(!s->mb_intra);
4106

    
4107
        if(IS_QUANT(mb_type)){
4108
            h263_decode_dquant(s);
4109
        }
4110

    
4111
        if(IS_DIRECT(mb_type)){
4112
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4113
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4114
        }else{
4115
            s->mv_dir = 0;
4116
            s->mv_type= MV_TYPE_16X16;
4117
//FIXME UMV
4118

    
4119
            if(USES_LIST(mb_type, 0)){
4120
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4121
                s->mv_dir = MV_DIR_FORWARD;
4122

    
4123
                mx = h263_decode_motion(s, mx, 1);
4124
                my = h263_decode_motion(s, my, 1);
4125

    
4126
                s->mv[0][0][0] = mx;
4127
                s->mv[0][0][1] = my;
4128
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4129
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4130
            }
4131

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

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

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

    
4146
        s->current_picture.mb_type[xy]= mb_type;
4147

    
4148
        /* decode each block */
4149
        for (i = 0; i < 6; i++) {
4150
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4151
                return -1;
4152
            cbp+=cbp;
4153
        }
4154
    } else { /* I-Frame */
4155
        do{
4156
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4157
            if (cbpc < 0){
4158
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4159
                return -1;
4160
            }
4161
        }while(cbpc == 8);
4162

    
4163
        s->dsp.clear_blocks(s->block[0]);
4164

    
4165
        dquant = cbpc & 4;
4166
        s->mb_intra = 1;
4167
intra:
4168
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4169
        if (s->h263_aic) {
4170
            s->ac_pred = get_bits1(&s->gb);
4171
            if(s->ac_pred){
4172
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4173

    
4174
                s->h263_aic_dir = get_bits1(&s->gb);
4175
            }
4176
        }else
4177
            s->ac_pred = 0;
4178

    
4179
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4180
        if(cbpy<0){
4181
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4182
            return -1;
4183
        }
4184
        cbp = (cbpc & 3) | (cbpy << 2);
4185
        if (dquant) {
4186
            h263_decode_dquant(s);
4187
        }
4188

    
4189
        /* decode each block */
4190
        for (i = 0; i < 6; i++) {
4191
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4192
                return -1;
4193
            cbp+=cbp;
4194
        }
4195
    }
4196
end:
4197

    
4198
        /* per-MB end of slice check */
4199
    {
4200
        int v= show_bits(&s->gb, 16);
4201

    
4202
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4203
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4204
        }
4205

    
4206
        if(v==0)
4207
            return SLICE_END;
4208
    }
4209

    
4210
    return SLICE_OK;
4211
}
4212

    
4213
int ff_mpeg4_decode_mb(MpegEncContext *s,
4214
                      DCTELEM block[6][64])
4215
{
4216
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4217
    int16_t *mot_val;
4218
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4219
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4220

    
4221
    assert(s->h263_pred);
4222

    
4223
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4224
        do{
4225
            if (get_bits1(&s->gb)) {
4226
                /* skip mb */
4227
                s->mb_intra = 0;
4228
                for(i=0;i<6;i++)
4229
                    s->block_last_index[i] = -1;
4230
                s->mv_dir = MV_DIR_FORWARD;
4231
                s->mv_type = MV_TYPE_16X16;
4232
                if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4233
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4234
                    s->mcsel=1;
4235
                    s->mv[0][0][0]= get_amv(s, 0);
4236
                    s->mv[0][0][1]= get_amv(s, 1);
4237

    
4238
                    s->mb_skipped = 0;
4239
                }else{
4240
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4241
                    s->mcsel=0;
4242
                    s->mv[0][0][0] = 0;
4243
                    s->mv[0][0][1] = 0;
4244
                    s->mb_skipped = 1;
4245
                }
4246
                goto end;
4247
            }
4248
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4249
            //fprintf(stderr, "\tCBPC: %d", cbpc);
4250
            if (cbpc < 0){
4251
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4252
                return -1;
4253
            }
4254
        }while(cbpc == 20);
4255

    
4256
        s->dsp.clear_blocks(s->block[0]);
4257
        dquant = cbpc & 8;
4258
        s->mb_intra = ((cbpc & 4) != 0);
4259
        if (s->mb_intra) goto intra;
4260

    
4261
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4262
            s->mcsel= get_bits1(&s->gb);
4263
        else s->mcsel= 0;
4264
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4265

    
4266
        cbp = (cbpc & 3) | (cbpy << 2);
4267
        if (dquant) {
4268
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4269
        }
4270
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4271
            s->interlaced_dct= get_bits1(&s->gb);
4272

    
4273
        s->mv_dir = MV_DIR_FORWARD;
4274
        if ((cbpc & 16) == 0) {
4275
            if(s->mcsel){
4276
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4277
                /* 16x16 global motion prediction */
4278
                s->mv_type = MV_TYPE_16X16;
4279
                mx= get_amv(s, 0);
4280
                my= get_amv(s, 1);
4281
                s->mv[0][0][0] = mx;
4282
                s->mv[0][0][1] = my;
4283
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4284
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4285
                /* 16x8 field motion prediction */
4286
                s->mv_type= MV_TYPE_FIELD;
4287

    
4288
                s->field_select[0][0]= get_bits1(&s->gb);
4289
                s->field_select[0][1]= get_bits1(&s->gb);
4290

    
4291
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4292

    
4293
                for(i=0; i<2; i++){
4294
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4295
                    if (mx >= 0xffff)
4296
                        return -1;
4297

    
4298
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4299
                    if (my >= 0xffff)
4300
                        return -1;
4301

    
4302
                    s->mv[0][i][0] = mx;
4303
                    s->mv[0][i][1] = my;
4304
                }
4305
            }else{
4306
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4307
                /* 16x16 motion prediction */
4308
                s->mv_type = MV_TYPE_16X16;
4309
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4310
                mx = h263_decode_motion(s, pred_x, s->f_code);
4311

    
4312
                if (mx >= 0xffff)
4313
                    return -1;
4314

    
4315
                my = h263_decode_motion(s, pred_y, s->f_code);
4316

    
4317
                if (my >= 0xffff)
4318
                    return -1;
4319
                s->mv[0][0][0] = mx;
4320
                s->mv[0][0][1] = my;
4321
            }
4322
        } else {
4323
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4324
            s->mv_type = MV_TYPE_8X8;
4325
            for(i=0;i<4;i++) {
4326
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4327
                mx = h263_decode_motion(s, pred_x, s->f_code);
4328
                if (mx >= 0xffff)
4329
                    return -1;
4330

    
4331
                my = h263_decode_motion(s, pred_y, s->f_code);
4332
                if (my >= 0xffff)
4333
                    return -1;
4334
                s->mv[0][i][0] = mx;
4335
                s->mv[0][i][1] = my;
4336
                mot_val[0] = mx;
4337
                mot_val[1] = my;
4338
            }
4339
        }
4340
    } else if(s->pict_type==B_TYPE) {
4341
        int modb1; // first bit of modb
4342
        int modb2; // second bit of modb
4343
        int mb_type;
4344

    
4345
        s->mb_intra = 0; //B-frames never contain intra blocks
4346
        s->mcsel=0;      //     ...               true gmc blocks
4347

    
4348
        if(s->mb_x==0){
4349
            for(i=0; i<2; i++){
4350
                s->last_mv[i][0][0]=
4351
                s->last_mv[i][0][1]=
4352
                s->last_mv[i][1][0]=
4353
                s->last_mv[i][1][1]= 0;
4354
            }
4355
        }
4356

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

    
4360
        if(s->mb_skipped){
4361
                /* skip mb */
4362
            for(i=0;i<6;i++)
4363
                s->block_last_index[i] = -1;
4364

    
4365
            s->mv_dir = MV_DIR_FORWARD;
4366
            s->mv_type = MV_TYPE_16X16;
4367
            s->mv[0][0][0] = 0;
4368
            s->mv[0][0][1] = 0;
4369
            s->mv[1][0][0] = 0;
4370
            s->mv[1][0][1] = 0;
4371
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4372
            goto end;
4373
        }
4374

    
4375
        modb1= get_bits1(&s->gb);
4376
        if(modb1){
4377
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4378
            cbp=0;
4379
        }else{
4380
            modb2= get_bits1(&s->gb);
4381
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4382
            if(mb_type<0){
4383
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4384
                return -1;
4385
            }
4386
            mb_type= mb_type_b_map[ mb_type ];
4387
            if(modb2) cbp= 0;
4388
            else{
4389
                s->dsp.clear_blocks(s->block[0]);
4390
                cbp= get_bits(&s->gb, 6);
4391
            }
4392

    
4393
            if ((!IS_DIRECT(mb_type)) && cbp) {
4394
                if(get_bits1(&s->gb)){
4395
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4396
                }
4397
            }
4398

    
4399
            if(!s->progressive_sequence){
4400
                if(cbp)
4401
                    s->interlaced_dct= get_bits1(&s->gb);
4402

    
4403
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4404
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4405
                    mb_type &= ~MB_TYPE_16x16;
4406

    
4407
                    if(USES_LIST(mb_type, 0)){
4408
                        s->field_select[0][0]= get_bits1(&s->gb);
4409
                        s->field_select[0][1]= get_bits1(&s->gb);
4410
                    }
4411
                    if(USES_LIST(mb_type, 1)){
4412
                        s->field_select[1][0]= get_bits1(&s->gb);
4413
                        s->field_select[1][1]= get_bits1(&s->gb);
4414
                    }
4415
                }
4416
            }
4417

    
4418
            s->mv_dir = 0;
4419
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4420
                s->mv_type= MV_TYPE_16X16;
4421

    
4422
                if(USES_LIST(mb_type, 0)){
4423
                    s->mv_dir = MV_DIR_FORWARD;
4424

    
4425
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4426
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4427
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4428
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4429
                }
4430

    
4431
                if(USES_LIST(mb_type, 1)){
4432
                    s->mv_dir |= MV_DIR_BACKWARD;
4433

    
4434
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4435
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4436
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4437
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4438
                }
4439
            }else if(!IS_DIRECT(mb_type)){
4440
                s->mv_type= MV_TYPE_FIELD;
4441

    
4442
                if(USES_LIST(mb_type, 0)){
4443
                    s->mv_dir = MV_DIR_FORWARD;
4444

    
4445
                    for(i=0; i<2; i++){
4446
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4447
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4448
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4449
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4450
                    }
4451
                }
4452

    
4453
                if(USES_LIST(mb_type, 1)){
4454
                    s->mv_dir |= MV_DIR_BACKWARD;
4455

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

    
4466
        if(IS_DIRECT(mb_type)){
4467
            if(IS_SKIP(mb_type))
4468
                mx=my=0;
4469
            else{
4470
                mx = h263_decode_motion(s, 0, 1);
4471
                my = h263_decode_motion(s, 0, 1);
4472
            }
4473

    
4474
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4475
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4476
        }
4477
        s->current_picture.mb_type[xy]= mb_type;
4478
    } else { /* I-Frame */
4479
        do{
4480
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4481
            if (cbpc < 0){
4482
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4483
                return -1;
4484
            }
4485
        }while(cbpc == 8);
4486

    
4487
        dquant = cbpc & 4;
4488
        s->mb_intra = 1;
4489
intra:
4490
        s->ac_pred = get_bits1(&s->gb);
4491
        if(s->ac_pred)
4492
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4493
        else
4494
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4495

    
4496
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4497
        if(cbpy<0){
4498
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4499
            return -1;
4500
        }
4501
        cbp = (cbpc & 3) | (cbpy << 2);
4502

    
4503
        s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4504

    
4505
        if (dquant) {
4506
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4507
        }
4508

    
4509
        if(!s->progressive_sequence)
4510
            s->interlaced_dct= get_bits1(&s->gb);
4511

    
4512
        s->dsp.clear_blocks(s->block[0]);
4513
        /* decode each block */
4514
        for (i = 0; i < 6; i++) {
4515
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4516
                return -1;
4517
            cbp+=cbp;
4518
        }
4519
        goto end;
4520
    }
4521

    
4522
    /* decode each block */
4523
    for (i = 0; i < 6; i++) {
4524
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4525
            return -1;
4526
        cbp+=cbp;
4527
    }
4528
end:
4529

    
4530
        /* per-MB end of slice check */
4531
    if(s->codec_id==CODEC_ID_MPEG4){
4532
        if(mpeg4_is_resync(s)){
4533
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4534
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4535
                return SLICE_OK;
4536
            return SLICE_END;
4537
        }
4538
    }
4539

    
4540
    return SLICE_OK;
4541
}
4542

    
4543
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4544
{
4545
    int code, val, sign, shift, l;
4546
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4547

    
4548
    if (code == 0)
4549
        return pred;
4550
    if (code < 0)
4551
        return 0xffff;
4552

    
4553
    sign = get_bits1(&s->gb);
4554
    shift = f_code - 1;
4555
    val = code;
4556
    if (shift) {
4557
        val = (val - 1) << shift;
4558
        val |= get_bits(&s->gb, shift);
4559
        val++;
4560
    }
4561
    if (sign)
4562
        val = -val;
4563
    val += pred;
4564

    
4565
    /* modulo decoding */
4566
    if (!s->h263_long_vectors) {
4567
        l = INT_BIT - 5 - f_code;
4568
        val = (val<<l)>>l;
4569
    } else {
4570
        /* horrible h263 long vector mode */
4571
        if (pred < -31 && val < -63)
4572
            val += 64;
4573
        if (pred > 32 && val > 63)
4574
            val -= 64;
4575

    
4576
    }
4577
    return val;
4578
}
4579

    
4580
/* Decodes RVLC of H.263+ UMV */
4581
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4582
{
4583
   int code = 0, sign;
4584

    
4585
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4586
      return pred;
4587

    
4588
   code = 2 + get_bits1(&s->gb);
4589

    
4590
   while (get_bits1(&s->gb))
4591
   {
4592
      code <<= 1;
4593
      code += get_bits1(&s->gb);
4594
   }
4595
   sign = code & 1;
4596
   code >>= 1;
4597

    
4598
   code = (sign) ? (pred - code) : (pred + code);
4599
#ifdef DEBUG
4600
   av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4601
#endif
4602
   return code;
4603

    
4604
}
4605

    
4606
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4607
                             int n, int coded)
4608
{
4609
    int code, level, i, j, last, run;
4610
    RLTable *rl = &rl_inter;
4611
    const uint8_t *scan_table;
4612
    GetBitContext gb= s->gb;
4613

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

    
4736
/**
4737
 * decodes the dc value.
4738
 * @param n block index (0-3 are luma, 4-5 are chroma)
4739
 * @param dir_ptr the prediction direction will be stored here
4740
 * @return the quantized dc
4741
 */
4742
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4743
{
4744
    int level, code;
4745

    
4746
    if (n < 4)
4747
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4748
    else
4749
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4750
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4751
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4752
        return -1;
4753
    }
4754
    if (code == 0) {
4755
        level = 0;
4756
    } else {
4757
        if(IS_3IV1){
4758
            if(code==1)
4759
                level= 2*get_bits1(&s->gb)-1;
4760
            else{
4761
                if(get_bits1(&s->gb))
4762
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4763
                else
4764
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4765
            }
4766
        }else{
4767
            level = get_xbits(&s->gb, code);
4768
        }
4769

    
4770
        if (code > 8){
4771
            if(get_bits1(&s->gb)==0){ /* marker */
4772
                if(s->error_resilience>=2){
4773
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4774
                    return -1;
4775
                }
4776
            }
4777
        }
4778
    }
4779

    
4780
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4781
}
4782

    
4783
/**
4784
 * decodes a block.
4785
 * @return <0 if an error occured
4786
 */
4787
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4788
                              int n, int coded, int intra, int rvlc)
4789
{
4790
    int level, i, last, run;
4791