Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 94d85eaf

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

    
27
/**
28
 * @file h263.c
29
 * h263/mpeg4 codec.
30
 */
31

    
32
//#define DEBUG
33
#include <limits.h>
34

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

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

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

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

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

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

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

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

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

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

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

    
119
int h263_get_picture_format(int width, int height)
120
{
121
    int format;
122

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

    
138
#ifdef CONFIG_ENCODERS
139

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

    
143
    if(aspect.num==0) aspect= (AVRational){1,1};
144

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

    
152
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
153
}
154

    
155
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
156
{
157
      int format;
158

    
159
      align_put_bits(&s->pb);
160

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

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

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

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

    
225
    align_put_bits(&s->pb);
226

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

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

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

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

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

    
280
        put_bits(&s->pb, 3, s->pict_type == P_TYPE);
281

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

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

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

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

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

    
320
        put_bits(&s->pb, 5, s->qscale);
321
    }
322

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

    
325
    if(s->h263_slice_structured){
326
        put_bits(&s->pb, 1, 1);
327

    
328
        assert(s->mb_x == 0 && s->mb_y == 0);
329
        ff_h263_encode_mba(s);
330

    
331
        put_bits(&s->pb, 1, 1);
332
    }
333

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

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

    
350
    if(s->h263_slice_structured){
351
        put_bits(&s->pb, 1, 1);
352

    
353
        ff_h263_encode_mba(s);
354

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

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

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

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

    
386
            last= j;
387
        }
388
    }
389

    
390
    return rate;
391
}
392

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

    
399
    memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
400

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

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

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

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

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

    
461
    return score < 0;
462
}
463

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

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

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

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

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

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

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

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

    
522
    ff_clean_h263_qscales(s);
523

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

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

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

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

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

    
554
#endif //CONFIG_ENCODERS
555

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

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

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

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

    
595
#undef tab_size
596
#undef tab_bias
597

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

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

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

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

    
659
    s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
660

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

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

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

    
705
#ifdef CONFIG_ENCODERS
706

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

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

    
720
        return mvtab[code][1] + 1 + bit_size;
721
    }
722
}
723

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
906
                return;
907
            }
908

    
909
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
910

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

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

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

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

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

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

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

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

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

    
1005
            mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1006

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

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

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

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

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

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

    
1036
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
1037

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

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

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

    
1060
                    return;
1061
                }
1062
            }
1063

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1152
            mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1153

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

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

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

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

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

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

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

    
1214
        mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1215

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1416
        }
1417
    }
1418

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

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

    
1440
//    if(s->pict_type==B_TYPE && !s->readable) return;
1441

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

    
1453
    if(s->mb_y){
1454
        int qp_dt, qp_t, qp_tc;
1455

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

    
1461
        if(qp_c)
1462
            qp_tc= qp_c;
1463
        else
1464
            qp_tc= qp_t;
1465

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

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

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

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

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

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

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

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

    
1518
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1519
{
1520
    int x, y, wrap, a, c, pred_dc, scale;
1521
    int16_t *dc_val;
1522

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

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

    
1557
    /* we assume pred is positive */
1558
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1559
    *dc_val_ptr = &dc_val[x + y * wrap];
1560
    return pred_dc;
1561
}
1562

    
1563
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1564
{
1565
    int x, y, wrap, a, c, pred_dc, scale, i;
1566
    int16_t *dc_val, *ac_val, *ac_val1;
1567

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

    
1585
    ac_val += ((y) * wrap + (x)) * 16;
1586
    ac_val1 = ac_val;
1587

    
1588
    /* B C
1589
     * A X
1590
     */
1591
    a = dc_val[(x - 1) + (y) * wrap];
1592
    c = dc_val[(x) + (y - 1) * wrap];
1593

    
1594
    /* No prediction outside GOB boundary */
1595
    if(s->first_slice_line && n!=3){
1596
        if(n!=2) c= 1024;
1597
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1598
    }
1599

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

    
1631
    /* we assume pred is positive */
1632
    block[0]=block[0]*scale + pred_dc;
1633

    
1634
    if (block[0] < 0)
1635
        block[0] = 0;
1636
    else
1637
        block[0] |= 1;
1638

    
1639
    /* Update AC/DC tables */
1640
    dc_val[(x) + (y) * wrap] = block[0];
1641

    
1642
    /* left copy */
1643
    for(i=1;i<8;i++)
1644
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1645
    /* top copy */
1646
    for(i=1;i<8;i++)
1647
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1648
}
1649

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

    
1657
    wrap = s->b8_stride;
1658
    mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1659

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

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

    
1708
#ifdef CONFIG_ENCODERS
1709
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1710
{
1711
    int range, l, bit_size, sign, code, bits;
1712

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

    
1727
        val--;
1728
        code = (val >> bit_size) + 1;
1729
        bits = val & (range - 1);
1730

    
1731
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1732
        if (bit_size > 0) {
1733
            put_bits(&s->pb, bit_size, bits);
1734
        }
1735
    }
1736
}
1737

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

    
1748
    if ( val == 0)
1749
        put_bits(&s->pb, 1, 1);
1750
    else if (val == 1)
1751
        put_bits(&s->pb, 3, 0);
1752
    else if (val == -1)
1753
        put_bits(&s->pb, 3, 2);
1754
    else {
1755

    
1756
        sval = ((val < 0) ? (short)(-val):(short)val);
1757
        temp_val = sval;
1758

    
1759
        while (temp_val != 0) {
1760
            temp_val = temp_val >> 1;
1761
            n_bits++;
1762
        }
1763

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

    
1777
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1778
{
1779
    int f_code;
1780
    int mv;
1781

    
1782
    if(mv_penalty==NULL)
1783
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1784

    
1785
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1786
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1787
            int len;
1788

    
1789
            if(mv==0) len= mvtab[0][1];
1790
            else{
1791
                int val, bit_size, range, code;
1792

    
1793
                bit_size = f_code - 1;
1794
                range = 1 << bit_size;
1795

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

    
1808
            mv_penalty[f_code][mv+MAX_MV]= len;
1809
        }
1810
    }
1811

    
1812
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1813
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1814
            fcode_tab[mv+MAX_MV]= f_code;
1815
        }
1816
    }
1817

    
1818
    for(mv=0; mv<MAX_MV*2+1; mv++){
1819
        umv_fcode_tab[mv]= 1;
1820
    }
1821
}
1822
#endif
1823

    
1824
#ifdef CONFIG_ENCODERS
1825

    
1826
static void init_uni_dc_tab(void)
1827
{
1828
    int level, uni_code, uni_len;
1829

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

    
1840
        if (level < 0)
1841
            l= (-level) ^ ((1 << size) - 1);
1842
        else
1843
            l= level;
1844

    
1845
        /* luminance */
1846
        uni_code= DCtab_lum[size][0];
1847
        uni_len = DCtab_lum[size][1];
1848

    
1849
        if (size > 0) {
1850
            uni_code<<=size; uni_code|=l;
1851
            uni_len+=size;
1852
            if (size > 8){
1853
                uni_code<<=1; uni_code|=1;
1854
                uni_len++;
1855
            }
1856
        }
1857
        uni_DCtab_lum_bits[level+256]= uni_code;
1858
        uni_DCtab_lum_len [level+256]= uni_len;
1859

    
1860
        /* chrominance */
1861
        uni_code= DCtab_chrom[size][0];
1862
        uni_len = DCtab_chrom[size][1];
1863

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

    
1875
    }
1876
}
1877

    
1878
#endif //CONFIG_ENCODERS
1879

    
1880
#ifdef CONFIG_ENCODERS
1881
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1882
    int slevel, run, last;
1883

    
1884
    assert(MAX_LEVEL >= 64);
1885
    assert(MAX_RUN   >= 63);
1886

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

    
1897
                len_tab[index]= 100;
1898

    
1899
                /* ESC0 */
1900
                code= get_rl_index(rl, last, run, level);
1901
                bits= rl->table_vlc[code][0];
1902
                len=  rl->table_vlc[code][1];
1903
                bits=bits*2+sign; len++;
1904

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

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

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

    
1957
                if(len < len_tab[index]){
1958
                    bits_tab[index]= bits;
1959
                    len_tab [index]= len;
1960
                }
1961
            }
1962
        }
1963
    }
1964
}
1965

    
1966
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1967
    int slevel, run, last;
1968

    
1969
    assert(MAX_LEVEL >= 64);
1970
    assert(MAX_RUN   >= 63);
1971

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

    
1981
                len_tab[index]= 100;
1982

    
1983
                /* ESC0 */
1984
                code= get_rl_index(rl, last, run, level);
1985
                bits= rl->table_vlc[code][0];
1986
                len=  rl->table_vlc[code][1];
1987
                bits=bits*2+sign; len++;
1988

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

    
2000
                if(len < len_tab[index]){
2001
                    if(bits_tab) bits_tab[index]= bits;
2002
                    len_tab [index]= len;
2003
                }
2004
            }
2005
        }
2006
    }
2007
}
2008

    
2009
void h263_encode_init(MpegEncContext *s)
2010
{
2011
    static int done = 0;
2012

    
2013
    if (!done) {
2014
        done = 1;
2015

    
2016
        init_uni_dc_tab();
2017

    
2018
        init_rl(&rl_inter, 1);
2019
        init_rl(&rl_intra, 1);
2020
        init_rl(&rl_intra_aic, 1);
2021

    
2022
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2023
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2024

    
2025
        init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2026
        init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
2027

    
2028
        init_mv_penalty_and_fcode(s);
2029
    }
2030
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2031

    
2032
    s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
2033
    s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2034
    if(s->h263_aic){
2035
        s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
2036
        s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2037
    }
2038
    s->ac_esc_length= 7+1+6+8;
2039

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

    
2056
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2057

    
2058
            s->avctx->extradata= av_malloc(1024);
2059
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
2060

    
2061
            if(!(s->workaround_bugs & FF_BUG_MS))
2062
                mpeg4_encode_visual_object_header(s);
2063
            mpeg4_encode_vol_header(s, 0, 0);
2064

    
2065
//            ff_mpeg4_stuffing(&s->pb); ?
2066
            flush_put_bits(&s->pb);
2067
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2068
        }
2069

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

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

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

    
2136
        if(s->alt_inter_vlc && !s->mb_intra){
2137
            int aic_vlc_bits=0;
2138
            int inter_vlc_bits=0;
2139
            int wrong_pos=-1;
2140
            int aic_code;
2141

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

    
2151
                    if(level<0) level= -level;
2152

    
2153
                    code = get_rl_index(rl, last, run, level);
2154
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2155
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2156
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2157

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

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

    
2197
                assert(slevel != 0);
2198

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

    
2212
                        put_bits(&s->pb, 7, slevel & 0x7f);
2213
                    } else {
2214
                        /* 11-bit level */
2215
                        put_bits(&s->pb, 1, 1);
2216
                        put_bits(&s->pb, 1, last);
2217
                        put_bits(&s->pb, 6, run);
2218

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

    
2231
#ifdef CONFIG_ENCODERS
2232

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

    
2245
/* must be called before writing the header */
2246
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2247
    int time_div, time_mod;
2248

    
2249
    assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2250
    s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2251

    
2252
    time_div= s->time/s->avctx->time_base.den;
2253
    time_mod= s->time%s->avctx->time_base.den;
2254

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

    
2268
static void mpeg4_encode_gop_header(MpegEncContext * s){
2269
    int hours, minutes, seconds;
2270
    int64_t time;
2271

    
2272
    put_bits(&s->pb, 16, 0);
2273
    put_bits(&s->pb, 16, GOP_STARTCODE);
2274

    
2275
    time= s->current_picture_ptr->pts;
2276
    if(s->reordered_input_picture[1])
2277
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2278
    time= time*s->avctx->time_base.num;
2279

    
2280
    seconds= time/s->avctx->time_base.den;
2281
    minutes= seconds/60; seconds %= 60;
2282
    hours= minutes/60; minutes %= 60;
2283
    hours%=24;
2284

    
2285
    put_bits(&s->pb, 5, hours);
2286
    put_bits(&s->pb, 6, minutes);
2287
    put_bits(&s->pb, 1, 1);
2288
    put_bits(&s->pb, 6, seconds);
2289

    
2290
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2291
    put_bits(&s->pb, 1, 0); //broken link == NO
2292

    
2293
    s->last_time_base= time / s->avctx->time_base.den;
2294

    
2295
    ff_mpeg4_stuffing(&s->pb);
2296
}
2297

    
2298
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2299
    int profile_and_level_indication;
2300
    int vo_ver_id;
2301

    
2302
    if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2303
        profile_and_level_indication = s->avctx->profile << 4;
2304
    }else if(s->max_b_frames || s->quarter_sample){
2305
        profile_and_level_indication= 0xF0; // adv simple
2306
    }else{
2307
        profile_and_level_indication= 0x00; // simple
2308
    }
2309

    
2310
    if(s->avctx->level != FF_LEVEL_UNKNOWN){
2311
        profile_and_level_indication |= s->avctx->level;
2312
    }else{
2313
        profile_and_level_indication |= 1; //level 1
2314
    }
2315

    
2316
    if(profile_and_level_indication>>4 == 0xF){
2317
        vo_ver_id= 5;
2318
    }else{
2319
        vo_ver_id= 1;
2320
    }
2321

    
2322
    //FIXME levels
2323

    
2324
    put_bits(&s->pb, 16, 0);
2325
    put_bits(&s->pb, 16, VOS_STARTCODE);
2326

    
2327
    put_bits(&s->pb, 8, profile_and_level_indication);
2328

    
2329
    put_bits(&s->pb, 16, 0);
2330
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2331

    
2332
    put_bits(&s->pb, 1, 1);
2333
        put_bits(&s->pb, 4, vo_ver_id);
2334
        put_bits(&s->pb, 3, 1); //priority
2335

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

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

    
2340
    ff_mpeg4_stuffing(&s->pb);
2341
}
2342

    
2343
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2344
{
2345
    int vo_ver_id;
2346

    
2347
    if(s->max_b_frames || s->quarter_sample){
2348
        vo_ver_id= 5;
2349
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2350
    }else{
2351
        vo_ver_id= 1;
2352
        s->vo_type= SIMPLE_VO_TYPE;
2353
    }
2354

    
2355
    put_bits(&s->pb, 16, 0);
2356
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2357
    put_bits(&s->pb, 16, 0);
2358
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2359

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

    
2370
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2371

    
2372
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2373
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2374
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2375
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2376
    }
2377

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

    
2387
    put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2388
    put_bits(&s->pb, 1, 1);             /* marker bit */
2389

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

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

    
2411
    if(s->mpeg_quant){
2412
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2413
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2414
    }
2415

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

    
2426
    if (vo_ver_id != 1){
2427
        put_bits(&s->pb, 1, 0);         /* newpred */
2428
        put_bits(&s->pb, 1, 0);         /* reduced res vop */
2429
    }
2430
    put_bits(&s->pb, 1, 0);             /* scalability */
2431

    
2432
    ff_mpeg4_stuffing(&s->pb);
2433

    
2434
    /* user data */
2435
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2436
        put_bits(&s->pb, 16, 0);
2437
        put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2438
        ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2439
    }
2440
}
2441

    
2442
/* write mpeg4 VOP header */
2443
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2444
{
2445
    int time_incr;
2446
    int time_div, time_mod;
2447

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

    
2459
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2460

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

    
2463
    put_bits(&s->pb, 16, 0);                /* vop header */
2464
    put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
2465
    put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
2466

    
2467
    assert(s->time>=0);
2468
    time_div= s->time/s->avctx->time_base.den;
2469
    time_mod= s->time%s->avctx->time_base.den;
2470
    time_incr= time_div - s->last_time_base;
2471
    assert(time_incr >= 0);
2472
    while(time_incr--)
2473
        put_bits(&s->pb, 1, 1);
2474

    
2475
    put_bits(&s->pb, 1, 0);
2476

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

    
2492
    put_bits(&s->pb, 5, s->qscale);
2493

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

    
2501
#endif //CONFIG_ENCODERS
2502

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

    
2513
    s->qscale = qscale;
2514
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2515

    
2516
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2517
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2518
}
2519

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

    
2532
    /* find prediction */
2533
    if (n < 4) {
2534
        scale = s->y_dc_scale;
2535
    } else {
2536
        scale = s->c_dc_scale;
2537
    }
2538
    if(IS_3IV1)
2539
        scale= 8;
2540

    
2541
    wrap= s->block_wrap[n];
2542
    dc_val = s->dc_val[0] + s->block_index[n];
2543

    
2544
    /* B C
2545
     * A X
2546
     */
2547
    a = dc_val[ - 1];
2548
    b = dc_val[ - 1 - wrap];
2549
    c = dc_val[ - wrap];
2550

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

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

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

    
2596
    return ret;
2597
}
2598

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

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

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

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

    
2653
    /* top copy */
2654
    for(i=1;i<8;i++)
2655
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2656

    
2657
}
2658

    
2659
#ifdef CONFIG_ENCODERS
2660

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

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

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

    
2706
static inline int mpeg4_get_dc_length(int level, int n){
2707
    if (n < 4) {
2708
        return uni_DCtab_lum_len[level + 256];
2709
    } else {
2710
        return uni_DCtab_chrom_len[level + 256];
2711
    }
2712
}
2713

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

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

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

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

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

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

    
2885
    return len;
2886
}
2887

    
2888
#endif
2889

    
2890

    
2891
/***********************************************/
2892
/* decoding */
2893

    
2894
static VLC intra_MCBPC_vlc;
2895
static VLC inter_MCBPC_vlc;
2896
static VLC cbpy_vlc;
2897
static VLC mv_vlc;
2898
static VLC dc_lum, dc_chrom;
2899
static VLC sprite_trajectory;
2900
static VLC mb_type_b_vlc;
2901
static VLC h263_mbtype_b_vlc;
2902
static VLC cbpc_b_vlc;
2903

    
2904
void init_vlc_rl(RLTable *rl, int use_static)
2905
{
2906
    int i, q;
2907

    
2908
    /* Return if static table is already initialized */
2909
    if(use_static && rl->rl_vlc[0])
2910
        return;
2911

    
2912
    init_vlc(&rl->vlc, 9, rl->n + 1,
2913
             &rl->table_vlc[0][1], 4, 2,
2914
             &rl->table_vlc[0][0], 4, 2, use_static);
2915

    
2916

    
2917
    for(q=0; q<32; q++){
2918
        int qmul= q*2;
2919
        int qadd= (q-1)|1;
2920

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

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

    
2957
/* init vlcs */
2958

    
2959
/* XXX: find a better solution to handle static init */
2960
void h263_decode_init_vlc(MpegEncContext *s)
2961
{
2962
    static int done = 0;
2963

    
2964
    if (!done) {
2965
        done = 1;
2966

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

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

    
3022
int ff_h263_decode_mba(MpegEncContext *s)
3023
{
3024
    int i, mb_pos;
3025

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

    
3033
    return mb_pos;
3034
}
3035

    
3036
void ff_h263_encode_mba(MpegEncContext *s)
3037
{
3038
    int i, mb_pos;
3039

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

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

    
3056
    /* Check for GOB Start Code */
3057
    val = show_bits(&s->gb, 16);
3058
    if(val)
3059
        return -1;
3060

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

    
3071
    if(s->h263_slice_structured){
3072
        if(get_bits1(&s->gb)==0)
3073
            return -1;
3074

    
3075
        ff_h263_decode_mba(s);
3076

    
3077
        if(s->mb_num > 1583)
3078
            if(get_bits1(&s->gb)==0)
3079
                return -1;
3080

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

    
3093
    if(s->mb_y >= s->mb_height)
3094
        return -1;
3095

    
3096
    if(s->qscale==0)
3097
        return -1;
3098

    
3099
    return 0;
3100
}
3101

    
3102
static inline void memsetw(short *tab, int val, int n)
3103
{
3104
    int i;
3105
    for(i=0;i<n;i++)
3106
        tab[i] = val;
3107
}
3108

    
3109
#ifdef CONFIG_ENCODERS
3110

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

    
3119
    set_put_bits_buffer_size(&s->pb, pb_size);
3120
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3121
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3122
}
3123

    
3124
void ff_mpeg4_merge_partitions(MpegEncContext *s)
3125
{
3126
    const int pb2_len   = put_bits_count(&s->pb2   );
3127
    const int tex_pb_len= put_bits_count(&s->tex_pb);
3128
    const int bits= put_bits_count(&s->pb);
3129

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

    
3141
    flush_put_bits(&s->pb2);
3142
    flush_put_bits(&s->tex_pb);
3143

    
3144
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3145
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3146
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3147
    s->last_bits= put_bits_count(&s->pb);
3148
}
3149

    
3150
#endif //CONFIG_ENCODERS
3151

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

    
3166
#ifdef CONFIG_ENCODERS
3167

    
3168
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3169
{
3170
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3171

    
3172
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3173
    put_bits(&s->pb, 1, 1);
3174

    
3175
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3176
    put_bits(&s->pb, s->quant_precision, s->qscale);
3177
    put_bits(&s->pb, 1, 0); /* no HEC */
3178
}
3179

    
3180
#endif //CONFIG_ENCODERS
3181

    
3182
/**
3183
 * check if the next stuff is a resync marker or the end.
3184
 * @return 0 if not
3185
 */
3186
static inline int mpeg4_is_resync(MpegEncContext *s){
3187
    const int bits_count= get_bits_count(&s->gb);
3188

    
3189
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3190
        return 0;
3191
    }
3192

    
3193
    if(bits_count + 8 >= s->gb.size_in_bits){
3194
        int v= show_bits(&s->gb, 8);
3195
        v|= 0x7F >> (7-(bits_count&7));
3196

    
3197
        if(v==0x7F)
3198
            return 1;
3199
    }else{
3200
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3201
            int len;
3202
            GetBitContext gb= s->gb;
3203

    
3204
            skip_bits(&s->gb, 1);
3205
            align_get_bits(&s->gb);
3206

    
3207
            for(len=0; len<32; len++){
3208
                if(get_bits1(&s->gb)) break;
3209
            }
3210

    
3211
            s->gb= gb;
3212

    
3213
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3214
                return 1;
3215
        }
3216
    }
3217
    return 0;
3218
}
3219

    
3220
/**
3221
 * decodes the next video packet.
3222
 * @return <0 if something went wrong
3223
 */
3224
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3225
{
3226
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3227
    int header_extension=0, mb_num, len;
3228

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

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

    
3236
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3237
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3238
        return -1;
3239
    }
3240

    
3241
    if(s->shape != RECT_SHAPE){
3242
        header_extension= get_bits1(&s->gb);
3243
        //FIXME more stuff here
3244
    }
3245

    
3246
    mb_num= get_bits(&s->gb, mb_num_bits);
3247
    if(mb_num>=s->mb_num){
3248
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3249
        return -1;
3250
    }
3251
    if(s->pict_type == B_TYPE){
3252
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3253
        if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3254
    }
3255

    
3256
    s->mb_x= mb_num % s->mb_width;
3257
    s->mb_y= mb_num / s->mb_width;
3258

    
3259
    if(s->shape != BIN_ONLY_SHAPE){
3260
        int qscale= get_bits(&s->gb, s->quant_precision);
3261
        if(qscale)
3262
            s->chroma_qscale=s->qscale= qscale;
3263
    }
3264

    
3265
    if(s->shape == RECT_SHAPE){
3266
        header_extension= get_bits1(&s->gb);
3267
    }
3268
    if(header_extension){
3269
        int time_increment;
3270
        int time_incr=0;
3271

    
3272
        while (get_bits1(&s->gb) != 0)
3273
            time_incr++;
3274

    
3275
        check_marker(&s->gb, "before time_increment in video packed header");
3276
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3277
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3278

    
3279
        skip_bits(&s->gb, 2); /* vop coding type */
3280
        //FIXME not rect stuff here
3281

    
3282
        if(s->shape != BIN_ONLY_SHAPE){
3283
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3284
//FIXME don't just ignore everything
3285
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3286
                mpeg4_decode_sprite_trajectory(s, &s->gb);
3287
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3288
            }
3289

    
3290
            //FIXME reduced res stuff here
3291

    
3292
            if (s->pict_type != I_TYPE) {
3293
                int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3294
                if(f_code==0){
3295
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3296
                }
3297
            }
3298
            if (s->pict_type == B_TYPE) {
3299
                int b_code = get_bits(&s->gb, 3);
3300
                if(b_code==0){
3301
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3302
                }
3303
            }
3304
        }
3305
    }
3306
    //FIXME new-pred stuff
3307

    
3308
//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));
3309

    
3310
    return 0;
3311
}
3312

    
3313
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3314
{
3315
    int c_wrap, c_xy, l_wrap, l_xy;
3316

    
3317
    l_wrap= s->b8_stride;
3318
    l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3319
    c_wrap= s->mb_stride;
3320
    c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3321

    
3322
#if 0
3323
    /* clean DC */
3324
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3325
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3326
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3327
#endif
3328

    
3329
    /* clean AC */
3330
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3331
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3332
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3333

    
3334
    /* clean MV */
3335
    // we can't clear the MVs as they might be needed by a b frame
3336
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3337
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3338
    s->last_mv[0][0][0]=
3339
    s->last_mv[0][0][1]=
3340
    s->last_mv[1][0][0]=
3341
    s->last_mv[1][0][1]= 0;
3342
}
3343

    
3344
/**
3345
 * decodes the group of blocks / video packet header.
3346
 * @return <0 if no resync found
3347
 */
3348
int ff_h263_resync(MpegEncContext *s){
3349
    int left, ret;
3350

    
3351
    if(s->codec_id==CODEC_ID_MPEG4){
3352
        skip_bits1(&s->gb);
3353
        align_get_bits(&s->gb);
3354
    }
3355

    
3356
    if(show_bits(&s->gb, 16)==0){
3357
        if(s->codec_id==CODEC_ID_MPEG4)
3358
            ret= mpeg4_decode_video_packet_header(s);
3359
        else
3360
            ret= h263_decode_gob_header(s);
3361
        if(ret>=0)
3362
            return 0;
3363
    }
3364
    //ok, it's not where its supposed to be ...
3365
    s->gb= s->last_resync_gb;
3366
    align_get_bits(&s->gb);
3367
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3368

    
3369
    for(;left>16+1+5+5; left-=8){
3370
        if(show_bits(&s->gb, 16)==0){
3371
            GetBitContext bak= s->gb;
3372

    
3373
            if(s->codec_id==CODEC_ID_MPEG4)
3374
                ret= mpeg4_decode_video_packet_header(s);
3375
            else
3376
                ret= h263_decode_gob_header(s);
3377
            if(ret>=0)
3378
                return 0;
3379

    
3380
            s->gb= bak;
3381
        }
3382
        skip_bits(&s->gb, 8);
3383
    }
3384

    
3385
    return -1;
3386
}
3387

    
3388
/**
3389
 * gets the average motion vector for a GMC MB.
3390
 * @param n either 0 for the x component or 1 for y
3391
 * @returns the average MV for a GMC MB
3392
 */
3393
static inline int get_amv(MpegEncContext *s, int n){
3394
    int x, y, mb_v, sum, dx, dy, shift;
3395
    int len = 1 << (s->f_code + 4);
3396
    const int a= s->sprite_warping_accuracy;
3397

    
3398
    if(s->workaround_bugs & FF_BUG_AMV)
3399
        len >>= s->quarter_sample;
3400

    
3401
    if(s->real_sprite_warping_points==1){
3402
        if(s->divx_version==500 && s->divx_build==413)
3403
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3404
        else
3405
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3406
    }else{
3407
        dx= s->sprite_delta[n][0];
3408
        dy= s->sprite_delta[n][1];
3409
        shift= s->sprite_shift[0];
3410
        if(n) dy -= 1<<(shift + a + 1);
3411
        else  dx -= 1<<(shift + a + 1);
3412
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3413

    
3414
        sum=0;
3415
        for(y=0; y<16; y++){
3416
            int v;
3417

    
3418
            v= mb_v + dy*y;
3419
            //XXX FIXME optimize
3420
            for(x=0; x<16; x++){
3421
                sum+= v>>shift;
3422
                v+= dx;
3423
            }
3424
        }
3425
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3426
    }
3427

    
3428
    if      (sum < -len) sum= -len;
3429
    else if (sum >= len) sum= len-1;
3430

    
3431
    return sum;
3432
}
3433

    
3434
/**
3435
 * decodes first partition.
3436
 * @return number of MBs decoded or <0 if an error occured
3437
 */
3438
static int mpeg4_decode_partition_a(MpegEncContext *s){
3439
    int mb_num;
3440
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3441

    
3442
    /* decode first partition */
3443
    mb_num=0;
3444
    s->first_slice_line=1;
3445
    for(; s->mb_y<s->mb_height; s->mb_y++){
3446
        ff_init_block_index(s);
3447
        for(; s->mb_x<s->mb_width; s->mb_x++){
3448
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3449
            int cbpc;
3450
            int dir=0;
3451

    
3452
            mb_num++;
3453
            ff_update_block_index(s);
3454
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3455
                s->first_slice_line=0;
3456

    
3457
            if(s->pict_type==I_TYPE){
3458
                int i;
3459

    
3460
                do{
3461
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
3462
                        return mb_num-1;
3463
                    }
3464

    
3465
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3466
                    if (cbpc < 0){
3467
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3468
                        return -1;
3469
                    }
3470
                }while(cbpc == 8);
3471

    
3472
                s->cbp_table[xy]= cbpc & 3;
3473
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3474
                s->mb_intra = 1;
3475

    
3476
                if(cbpc & 4) {
3477
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3478
                }
3479
                s->current_picture.qscale_table[xy]= s->qscale;
3480

    
3481
                s->mbintra_table[xy]= 1;
3482
                for(i=0; i<6; i++){
3483
                    int dc_pred_dir;
3484
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3485
                    if(dc < 0){
3486
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3487
                        return -1;
3488
                    }
3489
                    dir<<=1;
3490
                    if(dc_pred_dir) dir|=1;
3491
                }
3492
                s->pred_dir_table[xy]= dir;
3493
            }else{ /* P/S_TYPE */
3494
                int mx, my, pred_x, pred_y, bits;
3495
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3496
                const int stride= s->b8_stride*2;
3497

    
3498
try_again:
3499
                bits= show_bits(&s->gb, 17);
3500
                if(bits==MOTION_MARKER){
3501
                    return mb_num-1;
3502
                }
3503
                skip_bits1(&s->gb);
3504
                if(bits&0x10000){
3505
                    /* skip mb */
3506
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3507
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3508
                        mx= get_amv(s, 0);
3509
                        my= get_amv(s, 1);
3510
                    }else{
3511
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3512
                        mx=my=0;
3513
                    }
3514
                    mot_val[0       ]= mot_val[2       ]=
3515
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3516
                    mot_val[1       ]= mot_val[3       ]=
3517
                    mot_val[1+stride]= mot_val[3+stride]= my;
3518

    
3519
                    if(s->mbintra_table[xy])
3520
                        ff_clean_intra_table_entries(s);
3521
                    continue;
3522
                }
3523

    
3524
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3525
                if (cbpc < 0){
3526
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3527
                    return -1;
3528
                }
3529
                if(cbpc == 20)
3530
                    goto try_again;
3531

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

    
3534
                s->mb_intra = ((cbpc & 4) != 0);
3535

    
3536
                if(s->mb_intra){
3537
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3538
                    s->mbintra_table[xy]= 1;
3539
                    mot_val[0       ]= mot_val[2       ]=
3540
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3541
                    mot_val[1       ]= mot_val[3       ]=
3542
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3543
                }else{
3544
                    if(s->mbintra_table[xy])
3545
                        ff_clean_intra_table_entries(s);
3546

    
3547
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3548
                        s->mcsel= get_bits1(&s->gb);
3549
                    else s->mcsel= 0;
3550

    
3551
                    if ((cbpc & 16) == 0) {
3552
                        /* 16x16 motion prediction */
3553

    
3554
                        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3555
                        if(!s->mcsel){
3556
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3557
                            if (mx >= 0xffff)
3558
                                return -1;
3559

    
3560
                            my = h263_decode_motion(s, pred_y, s->f_code);
3561
                            if (my >= 0xffff)
3562
                                return -1;
3563
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3564
                        } else {
3565
                            mx = get_amv(s, 0);
3566
                            my = get_amv(s, 1);
3567
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3568
                        }
3569

    
3570
                        mot_val[0       ]= mot_val[2       ] =
3571
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3572
                        mot_val[1       ]= mot_val[3       ]=
3573
                        mot_val[1+stride]= mot_val[3+stride]= my;
3574
                    } else {
3575
                        int i;
3576
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3577
                        for(i=0;i<4;i++) {
3578
                            int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3579
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3580
                            if (mx >= 0xffff)
3581
                                return -1;
3582

    
3583
                            my = h263_decode_motion(s, pred_y, s->f_code);
3584
                            if (my >= 0xffff)
3585
                                return -1;
3586
                            mot_val[0] = mx;
3587
                            mot_val[1] = my;
3588
                        }
3589
                    }
3590
                }
3591
            }
3592
        }
3593
        s->mb_x= 0;
3594
    }
3595

    
3596
    return mb_num;
3597
}
3598

    
3599
/**
3600
 * decode second partition.
3601
 * @return <0 if an error occured
3602
 */
3603
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3604
    int mb_num=0;
3605
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3606

    
3607
    s->mb_x= s->resync_mb_x;
3608
    s->first_slice_line=1;
3609
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3610
        ff_init_block_index(s);
3611
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3612
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3613

    
3614
            mb_num++;
3615
            ff_update_block_index(s);
3616
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3617
                s->first_slice_line=0;
3618

    
3619
            if(s->pict_type==I_TYPE){
3620
                int ac_pred= get_bits1(&s->gb);
3621
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3622
                if(cbpy<0){
3623
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3624
                    return -1;
3625
                }
3626

    
3627
                s->cbp_table[xy]|= cbpy<<2;
3628
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3629
            }else{ /* P || S_TYPE */
3630
                if(IS_INTRA(s->current_picture.mb_type[xy])){
3631
                    int dir=0,i;
3632
                    int ac_pred = get_bits1(&s->gb);
3633
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3634

    
3635
                    if(cbpy<0){
3636
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3637
                        return -1;
3638
                    }
3639

    
3640
                    if(s->cbp_table[xy] & 8) {
3641
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3642
                    }
3643
                    s->current_picture.qscale_table[xy]= s->qscale;
3644

    
3645
                    for(i=0; i<6; i++){
3646
                        int dc_pred_dir;
3647
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3648
                        if(dc < 0){
3649
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3650
                            return -1;
3651
                        }
3652
                        dir<<=1;
3653
                        if(dc_pred_dir) dir|=1;
3654
                    }
3655
                    s->cbp_table[xy]&= 3; //remove dquant
3656
                    s->cbp_table[xy]|= cbpy<<2;
3657
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3658
                    s->pred_dir_table[xy]= dir;
3659
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3660
                    s->current_picture.qscale_table[xy]= s->qscale;
3661
                    s->cbp_table[xy]= 0;
3662
                }else{
3663
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3664

    
3665
                    if(cbpy<0){
3666
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3667
                        return -1;
3668
                    }
3669

    
3670
                    if(s->cbp_table[xy] & 8) {
3671
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3672
                    }
3673
                    s->current_picture.qscale_table[xy]= s->qscale;
3674

    
3675
                    s->cbp_table[xy]&= 3; //remove dquant
3676
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3677
                }
3678
            }
3679
        }
3680
        if(mb_num >= mb_count) return 0;
3681
        s->mb_x= 0;
3682
    }
3683
    return 0;
3684
}
3685

    
3686
/**
3687
 * decodes the first & second partition
3688
 * @return <0 if error (and sets error type in the error_status_table)
3689
 */
3690
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3691
{
3692
    int mb_num;
3693
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3694
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3695

    
3696
    mb_num= mpeg4_decode_partition_a(s);
3697
    if(mb_num<0){
3698
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3699
        return -1;
3700
    }
3701

    
3702
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3703
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3704
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3705
        return -1;
3706
    }
3707

    
3708
    s->mb_num_left= mb_num;
3709

    
3710
    if(s->pict_type==I_TYPE){
3711
        while(show_bits(&s->gb, 9) == 1)
3712
            skip_bits(&s->gb, 9);
3713
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3714
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3715
            return -1;
3716
        }
3717
    }else{
3718
        while(show_bits(&s->gb, 10) == 1)
3719
            skip_bits(&s->gb, 10);
3720
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3721
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3722
            return -1;
3723
        }
3724
    }
3725
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3726

    
3727
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3728
        if(s->pict_type==P_TYPE)
3729
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3730
        return -1;
3731
    }else{
3732
        if(s->pict_type==P_TYPE)
3733
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3734
    }
3735

    
3736
    return 0;
3737
}
3738

    
3739
/**
3740
 * decode partition C of one MB.
3741
 * @return <0 if an error occured
3742
 */
3743
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3744
{
3745
    int cbp, mb_type;
3746
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3747

    
3748
    mb_type= s->current_picture.mb_type[xy];
3749
    cbp = s->cbp_table[xy];
3750

    
3751
    s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3752

    
3753
    if(s->current_picture.qscale_table[xy] != s->qscale){
3754
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3755
    }
3756

    
3757
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3758
        int i;
3759
        for(i=0; i<4; i++){
3760
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3761
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3762
        }
3763
        s->mb_intra = IS_INTRA(mb_type);
3764

    
3765
        if (IS_SKIP(mb_type)) {
3766
            /* skip mb */
3767
            for(i=0;i<6;i++)
3768
                s->block_last_index[i] = -1;
3769
            s->mv_dir = MV_DIR_FORWARD;
3770
            s->mv_type = MV_TYPE_16X16;
3771
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3772
                s->mcsel=1;
3773
                s->mb_skipped = 0;
3774
            }else{
3775
                s->mcsel=0;
3776
                s->mb_skipped = 1;
3777
            }
3778
        }else if(s->mb_intra){
3779
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3780
        }else if(!s->mb_intra){
3781
//            s->mcsel= 0; //FIXME do we need to init that
3782

    
3783
            s->mv_dir = MV_DIR_FORWARD;
3784
            if (IS_8X8(mb_type)) {
3785
                s->mv_type = MV_TYPE_8X8;
3786
            } else {
3787
                s->mv_type = MV_TYPE_16X16;
3788
            }
3789
        }
3790
    } else { /* I-Frame */
3791
        s->mb_intra = 1;
3792
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3793
    }
3794

    
3795
    if (!IS_SKIP(mb_type)) {
3796
        int i;
3797
        s->dsp.clear_blocks(s->block[0]);
3798
        /* decode each block */
3799
        for (i = 0; i < 6; i++) {
3800
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3801
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3802
                return -1;
3803
            }
3804
            cbp+=cbp;
3805
        }
3806
    }
3807

    
3808
    /* per-MB end of slice check */
3809

    
3810
    if(--s->mb_num_left <= 0){
3811
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3812
        if(mpeg4_is_resync(s))
3813
            return SLICE_END;
3814
        else
3815
            return SLICE_NOEND;
3816
    }else{
3817
        if(mpeg4_is_resync(s)){
3818
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3819
            if(s->cbp_table[xy+delta])
3820
                return SLICE_END;
3821
        }
3822
        return SLICE_OK;
3823
    }
3824
}
3825

    
3826
/**
3827
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3828
 */
3829
static void preview_obmc(MpegEncContext *s){
3830
    GetBitContext gb= s->gb;
3831

    
3832
    int cbpc, i, pred_x, pred_y, mx, my;
3833
    int16_t *mot_val;
3834
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3835
    const int stride= s->b8_stride*2;
3836

    
3837
    for(i=0; i<4; i++)
3838
        s->block_index[i]+= 2;
3839
    for(i=4; i<6; i++)
3840
        s->block_index[i]+= 1;
3841
    s->mb_x++;
3842

    
3843
    assert(s->pict_type == P_TYPE);
3844

    
3845
    do{
3846
        if (get_bits1(&s->gb)) {
3847
            /* skip mb */
3848
            mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3849
            mot_val[0       ]= mot_val[2       ]=
3850
            mot_val[0+stride]= mot_val[2+stride]= 0;
3851
            mot_val[1       ]= mot_val[3       ]=
3852
            mot_val[1+stride]= mot_val[3+stride]= 0;
3853

    
3854
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3855
            goto end;
3856
        }
3857
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3858
    }while(cbpc == 20);
3859

    
3860
    if(cbpc & 4){
3861
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3862
    }else{
3863
        get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3864
        if (cbpc & 8) {
3865
            if(s->modified_quant){
3866
                if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3867
                else                  skip_bits(&s->gb, 5);
3868
            }else
3869
                skip_bits(&s->gb, 2);
3870
        }
3871

    
3872
        if ((cbpc & 16) == 0) {
3873
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3874
                /* 16x16 motion prediction */
3875
                mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3876
                if (s->umvplus)
3877
                   mx = h263p_decode_umotion(s, pred_x);
3878
                else
3879
                   mx = h263_decode_motion(s, pred_x, 1);
3880

    
3881
                if (s->umvplus)
3882
                   my = h263p_decode_umotion(s, pred_y);
3883
                else
3884
                   my = h263_decode_motion(s, pred_y, 1);
3885

    
3886
                mot_val[0       ]= mot_val[2       ]=
3887
                mot_val[0+stride]= mot_val[2+stride]= mx;
3888
                mot_val[1       ]= mot_val[3       ]=
3889
                mot_val[1+stride]= mot_val[3+stride]= my;
3890
        } else {
3891
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3892
            for(i=0;i<4;i++) {
3893
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3894
                if (s->umvplus)
3895
                  mx = h263p_decode_umotion(s, pred_x);
3896
                else
3897
                  mx = h263_decode_motion(s, pred_x, 1);
3898

    
3899
                if (s->umvplus)
3900
                  my = h263p_decode_umotion(s, pred_y);
3901
                else
3902
                  my = h263_decode_motion(s, pred_y, 1);
3903
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3904
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3905
                mot_val[0] = mx;
3906
                mot_val[1] = my;
3907
            }
3908
        }
3909
    }
3910
end:
3911

    
3912
    for(i=0; i<4; i++)
3913
        s->block_index[i]-= 2;
3914
    for(i=4; i<6; i++)
3915
        s->block_index[i]-= 1;
3916
    s->mb_x--;
3917

    
3918
    s->gb= gb;
3919
}
3920

    
3921
static void h263_decode_dquant(MpegEncContext *s){
3922
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3923

    
3924
    if(s->modified_quant){
3925
        if(get_bits1(&s->gb))
3926
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3927
        else
3928
            s->qscale= get_bits(&s->gb, 5);
3929
    }else
3930
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3931
    ff_set_qscale(s, s->qscale);
3932
}
3933

    
3934
int ff_h263_decode_mb(MpegEncContext *s,
3935
                      DCTELEM block[6][64])
3936
{
3937
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3938
    int16_t *mot_val;
3939
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3940

    
3941
    assert(!s->h263_pred);
3942

    
3943
    if (s->pict_type == P_TYPE) {
3944
        do{
3945
            if (get_bits1(&s->gb)) {
3946
                /* skip mb */
3947
                s->mb_intra = 0;
3948
                for(i=0;i<6;i++)
3949
                    s->block_last_index[i] = -1;
3950
                s->mv_dir = MV_DIR_FORWARD;
3951
                s->mv_type = MV_TYPE_16X16;
3952
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3953
                s->mv[0][0][0] = 0;
3954
                s->mv[0][0][1] = 0;
3955
                s->mb_skipped = !(s->obmc | s->loop_filter);
3956
                goto end;
3957
            }
3958
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3959
            //fprintf(stderr, "\tCBPC: %d", cbpc);
3960
            if (cbpc < 0){
3961
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3962
                return -1;
3963
            }
3964
        }while(cbpc == 20);
3965

    
3966
        s->dsp.clear_blocks(s->block[0]);
3967

    
3968
        dquant = cbpc & 8;
3969
        s->mb_intra = ((cbpc & 4) != 0);
3970
        if (s->mb_intra) goto intra;
3971

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

    
3974
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3975
            cbpy ^= 0xF;
3976

    
3977
        cbp = (cbpc & 3) | (cbpy << 2);
3978
        if (dquant) {
3979
            h263_decode_dquant(s);
3980
        }
3981

    
3982
        s->mv_dir = MV_DIR_FORWARD;
3983
        if ((cbpc & 16) == 0) {
3984
            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3985
            /* 16x16 motion prediction */
3986
            s->mv_type = MV_TYPE_16X16;
3987
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3988
            if (s->umvplus)
3989
               mx = h263p_decode_umotion(s, pred_x);
3990
            else
3991
               mx = h263_decode_motion(s, pred_x, 1);
3992

    
3993
            if (mx >= 0xffff)
3994
                return -1;
3995

    
3996
            if (s->umvplus)
3997
               my = h263p_decode_umotion(s, pred_y);
3998
            else
3999
               my = h263_decode_motion(s, pred_y, 1);
4000

    
4001
            if (my >= 0xffff)
4002
                return -1;
4003
            s->mv[0][0][0] = mx;
4004
            s->mv[0][0][1] = my;
4005

    
4006
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4007
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4008
        } else {
4009
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4010
            s->mv_type = MV_TYPE_8X8;
4011
            for(i=0;i<4;i++) {
4012
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4013
                if (s->umvplus)
4014
                  mx = h263p_decode_umotion(s, pred_x);
4015
                else
4016
                  mx = h263_decode_motion(s, pred_x, 1);
4017
                if (mx >= 0xffff)
4018
                    return -1;
4019

    
4020
                if (s->umvplus)
4021
                  my = h263p_decode_umotion(s, pred_y);
4022
                else
4023
                  my = h263_decode_motion(s, pred_y, 1);
4024
                if (my >= 0xffff)
4025
                    return -1;
4026
                s->mv[0][i][0] = mx;
4027
                s->mv[0][i][1] = my;
4028
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4029
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4030
                mot_val[0] = mx;
4031
                mot_val[1] = my;
4032
            }
4033
        }
4034

    
4035
        /* decode each block */
4036
        for (i = 0; i < 6; i++) {
4037
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4038
                return -1;
4039
            cbp+=cbp;
4040
        }
4041

    
4042
        if(s->obmc){
4043
            if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4044
                preview_obmc(s);
4045
        }
4046
    } else if(s->pict_type==B_TYPE) {
4047
        int mb_type;
4048
        const int stride= s->b8_stride;
4049
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4050
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4051
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4052

    
4053
        //FIXME ugly
4054
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4055
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4056
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4057
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4058

    
4059
        do{
4060
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4061
            if (mb_type < 0){
4062
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4063
                return -1;
4064
            }
4065

    
4066
            mb_type= h263_mb_type_b_map[ mb_type ];
4067
        }while(!mb_type);
4068

    
4069
        s->mb_intra = IS_INTRA(mb_type);
4070
        if(HAS_CBP(mb_type)){
4071
            s->dsp.clear_blocks(s->block[0]);
4072
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4073
            if(s->mb_intra){
4074
                dquant = IS_QUANT(mb_type);
4075
                goto intra;
4076
            }
4077

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

    
4080
            if (cbpy < 0){
4081
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4082
                return -1;
4083
            }
4084

    
4085
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4086
                cbpy ^= 0xF;
4087

    
4088
            cbp = (cbpc & 3) | (cbpy << 2);
4089
        }else
4090
            cbp=0;
4091

    
4092
        assert(!s->mb_intra);
4093

    
4094
        if(IS_QUANT(mb_type)){
4095
            h263_decode_dquant(s);
4096
        }
4097

    
4098
        if(IS_DIRECT(mb_type)){
4099
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4100
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4101
        }else{
4102
            s->mv_dir = 0;
4103
            s->mv_type= MV_TYPE_16X16;
4104
//FIXME UMV
4105

    
4106
            if(USES_LIST(mb_type, 0)){
4107
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4108
                s->mv_dir = MV_DIR_FORWARD;
4109

    
4110
                mx = h263_decode_motion(s, mx, 1);
4111
                my = h263_decode_motion(s, my, 1);
4112

    
4113
                s->mv[0][0][0] = mx;
4114
                s->mv[0][0][1] = my;
4115
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4116
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4117
            }
4118

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

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

    
4126
                s->mv[1][0][0] = mx;
4127
                s->mv[1][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

    
4133
        s->current_picture.mb_type[xy]= mb_type;
4134

    
4135
        /* decode each block */
4136
        for (i = 0; i < 6; i++) {
4137
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4138
                return -1;
4139
            cbp+=cbp;
4140
        }
4141
    } else { /* I-Frame */
4142
        do{
4143
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4144
            if (cbpc < 0){
4145
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4146
                return -1;
4147
            }
4148
        }while(cbpc == 8);
4149

    
4150
        s->dsp.clear_blocks(s->block[0]);
4151

    
4152
        dquant = cbpc & 4;
4153
        s->mb_intra = 1;
4154
intra:
4155
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4156
        if (s->h263_aic) {
4157
            s->ac_pred = get_bits1(&s->gb);
4158
            if(s->ac_pred){
4159
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4160

    
4161
                s->h263_aic_dir = get_bits1(&s->gb);
4162
            }
4163
        }else
4164
            s->ac_pred = 0;
4165

    
4166
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4167
        if(cbpy<0){
4168
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4169
            return -1;
4170
        }
4171
        cbp = (cbpc & 3) | (cbpy << 2);
4172
        if (dquant) {
4173
            h263_decode_dquant(s);
4174
        }
4175

    
4176
        /* decode each block */
4177
        for (i = 0; i < 6; i++) {
4178
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4179
                return -1;
4180
            cbp+=cbp;
4181
        }
4182
    }
4183
end:
4184

    
4185
        /* per-MB end of slice check */
4186
    {
4187
        int v= show_bits(&s->gb, 16);
4188

    
4189
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4190
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4191
        }
4192

    
4193
        if(v==0)
4194
            return SLICE_END;
4195
    }
4196

    
4197
    return SLICE_OK;
4198
}
4199

    
4200
int ff_mpeg4_decode_mb(MpegEncContext *s,
4201
                      DCTELEM block[6][64])
4202
{
4203
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4204
    int16_t *mot_val;
4205
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4206
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4207

    
4208
    assert(s->h263_pred);
4209

    
4210
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4211
        do{
4212
            if (get_bits1(&s->gb)) {
4213
                /* skip mb */
4214
                s->mb_intra = 0;
4215
                for(i=0;i<6;i++)
4216
                    s->block_last_index[i] = -1;
4217
                s->mv_dir = MV_DIR_FORWARD;
4218
                s->mv_type = MV_TYPE_16X16;
4219
                if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4220
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4221
                    s->mcsel=1;
4222
                    s->mv[0][0][0]= get_amv(s, 0);
4223
                    s->mv[0][0][1]= get_amv(s, 1);
4224

    
4225
                    s->mb_skipped = 0;
4226
                }else{
4227
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4228
                    s->mcsel=0;
4229
                    s->mv[0][0][0] = 0;
4230
                    s->mv[0][0][1] = 0;
4231
                    s->mb_skipped = 1;
4232
                }
4233
                goto end;
4234
            }
4235
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4236
            //fprintf(stderr, "\tCBPC: %d", cbpc);
4237
            if (cbpc < 0){
4238
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4239
                return -1;
4240
            }
4241
        }while(cbpc == 20);
4242

    
4243
        s->dsp.clear_blocks(s->block[0]);
4244
        dquant = cbpc & 8;
4245
        s->mb_intra = ((cbpc & 4) != 0);
4246
        if (s->mb_intra) goto intra;
4247

    
4248
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4249
            s->mcsel= get_bits1(&s->gb);
4250
        else s->mcsel= 0;
4251
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4252

    
4253
        cbp = (cbpc & 3) | (cbpy << 2);
4254
        if (dquant) {
4255
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4256
        }
4257
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4258
            s->interlaced_dct= get_bits1(&s->gb);
4259

    
4260
        s->mv_dir = MV_DIR_FORWARD;
4261
        if ((cbpc & 16) == 0) {
4262
            if(s->mcsel){
4263
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4264
                /* 16x16 global motion prediction */
4265
                s->mv_type = MV_TYPE_16X16;
4266
                mx= get_amv(s, 0);
4267
                my= get_amv(s, 1);
4268
                s->mv[0][0][0] = mx;
4269
                s->mv[0][0][1] = my;
4270
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4271
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4272
                /* 16x8 field motion prediction */
4273
                s->mv_type= MV_TYPE_FIELD;
4274

    
4275
                s->field_select[0][0]= get_bits1(&s->gb);
4276
                s->field_select[0][1]= get_bits1(&s->gb);
4277

    
4278
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4279

    
4280
                for(i=0; i<2; i++){
4281
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4282
                    if (mx >= 0xffff)
4283
                        return -1;
4284

    
4285
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4286
                    if (my >= 0xffff)
4287
                        return -1;
4288

    
4289
                    s->mv[0][i][0] = mx;
4290
                    s->mv[0][i][1] = my;
4291
                }
4292
            }else{
4293
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4294
                /* 16x16 motion prediction */
4295
                s->mv_type = MV_TYPE_16X16;
4296
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4297
                mx = h263_decode_motion(s, pred_x, s->f_code);
4298

    
4299
                if (mx >= 0xffff)
4300
                    return -1;
4301

    
4302
                my = h263_decode_motion(s, pred_y, s->f_code);
4303

    
4304
                if (my >= 0xffff)
4305
                    return -1;
4306
                s->mv[0][0][0] = mx;
4307
                s->mv[0][0][1] = my;
4308
            }
4309
        } else {
4310
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4311
            s->mv_type = MV_TYPE_8X8;
4312
            for(i=0;i<4;i++) {
4313
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4314
                mx = h263_decode_motion(s, pred_x, s->f_code);
4315
                if (mx >= 0xffff)
4316
                    return -1;
4317

    
4318
                my = h263_decode_motion(s, pred_y, s->f_code);
4319
                if (my >= 0xffff)
4320
                    return -1;
4321
                s->mv[0][i][0] = mx;
4322
                s->mv[0][i][1] = my;
4323
                mot_val[0] = mx;
4324
                mot_val[1] = my;
4325
            }
4326
        }
4327
    } else if(s->pict_type==B_TYPE) {
4328
        int modb1; // first bit of modb
4329
        int modb2; // second bit of modb
4330
        int mb_type;
4331

    
4332
        s->mb_intra = 0; //B-frames never contain intra blocks
4333
        s->mcsel=0;      //     ...               true gmc blocks
4334

    
4335
        if(s->mb_x==0){
4336
            for(i=0; i<2; i++){
4337
                s->last_mv[i][0][0]=
4338
                s->last_mv[i][0][1]=
4339
                s->last_mv[i][1][0]=
4340
                s->last_mv[i][1][1]= 0;
4341
            }
4342
        }
4343

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

    
4347
        if(s->mb_skipped){
4348
                /* skip mb */
4349
            for(i=0;i<6;i++)
4350
                s->block_last_index[i] = -1;
4351

    
4352
            s->mv_dir = MV_DIR_FORWARD;
4353
            s->mv_type = MV_TYPE_16X16;
4354
            s->mv[0][0][0] = 0;
4355
            s->mv[0][0][1] = 0;
4356
            s->mv[1][0][0] = 0;
4357
            s->mv[1][0][1] = 0;
4358
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4359
            goto end;
4360
        }
4361

    
4362
        modb1= get_bits1(&s->gb);
4363
        if(modb1){
4364
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4365
            cbp=0;
4366
        }else{
4367
            modb2= get_bits1(&s->gb);
4368
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4369
            if(mb_type<0){
4370
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4371
                return -1;
4372
            }
4373
            mb_type= mb_type_b_map[ mb_type ];
4374
            if(modb2) cbp= 0;
4375
            else{
4376
                s->dsp.clear_blocks(s->block[0]);
4377
                cbp= get_bits(&s->gb, 6);
4378
            }
4379

    
4380
            if ((!IS_DIRECT(mb_type)) && cbp) {
4381
                if(get_bits1(&s->gb)){
4382
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4383
                }
4384
            }
4385

    
4386
            if(!s->progressive_sequence){
4387
                if(cbp)
4388
                    s->interlaced_dct= get_bits1(&s->gb);
4389

    
4390
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4391
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4392
                    mb_type &= ~MB_TYPE_16x16;
4393

    
4394
                    if(USES_LIST(mb_type, 0)){
4395
                        s->field_select[0][0]= get_bits1(&s->gb);
4396
                        s->field_select[0][1]= get_bits1(&s->gb);
4397
                    }
4398
                    if(USES_LIST(mb_type, 1)){
4399
                        s->field_select[1][0]= get_bits1(&s->gb);
4400
                        s->field_select[1][1]= get_bits1(&s->gb);
4401
                    }
4402
                }
4403
            }
4404

    
4405
            s->mv_dir = 0;
4406
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4407
                s->mv_type= MV_TYPE_16X16;
4408

    
4409
                if(USES_LIST(mb_type, 0)){
4410
                    s->mv_dir = MV_DIR_FORWARD;
4411

    
4412
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4413
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4414
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4415
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4416
                }
4417

    
4418
                if(USES_LIST(mb_type, 1)){
4419
                    s->mv_dir |= MV_DIR_BACKWARD;
4420

    
4421
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4422
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4423
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4424
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4425
                }
4426
            }else if(!IS_DIRECT(mb_type)){
4427
                s->mv_type= MV_TYPE_FIELD;
4428

    
4429
                if(USES_LIST(mb_type, 0)){
4430
                    s->mv_dir = MV_DIR_FORWARD;
4431

    
4432
                    for(i=0; i<2; i++){
4433
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4434
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4435
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4436
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4437
                    }
4438
                }
4439

    
4440
                if(USES_LIST(mb_type, 1)){
4441
                    s->mv_dir |= MV_DIR_BACKWARD;
4442

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

    
4453
        if(IS_DIRECT(mb_type)){
4454
            if(IS_SKIP(mb_type))
4455
                mx=my=0;
4456
            else{
4457
                mx = h263_decode_motion(s, 0, 1);
4458
                my = h263_decode_motion(s, 0, 1);
4459
            }
4460

    
4461
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4462
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4463
        }
4464
        s->current_picture.mb_type[xy]= mb_type;
4465
    } else { /* I-Frame */
4466
        do{
4467
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4468
            if (cbpc < 0){
4469
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4470
                return -1;
4471
            }
4472
        }while(cbpc == 8);
4473

    
4474
        dquant = cbpc & 4;
4475
        s->mb_intra = 1;
4476
intra:
4477
        s->ac_pred = get_bits1(&s->gb);
4478
        if(s->ac_pred)
4479
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4480
        else
4481
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4482

    
4483
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4484
        if(cbpy<0){
4485
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4486
            return -1;
4487
        }
4488
        cbp = (cbpc & 3) | (cbpy << 2);
4489

    
4490
        s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4491

    
4492
        if (dquant) {
4493
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4494
        }
4495

    
4496
        if(!s->progressive_sequence)
4497
            s->interlaced_dct= get_bits1(&s->gb);
4498

    
4499
        s->dsp.clear_blocks(s->block[0]);
4500
        /* decode each block */
4501
        for (i = 0; i < 6; i++) {
4502
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4503
                return -1;
4504
            cbp+=cbp;
4505
        }
4506
        goto end;
4507
    }
4508

    
4509
    /* decode each block */
4510
    for (i = 0; i < 6; i++) {
4511
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4512
            return -1;
4513
        cbp+=cbp;
4514
    }
4515
end:
4516

    
4517
        /* per-MB end of slice check */
4518
    if(s->codec_id==CODEC_ID_MPEG4){
4519
#if 0 //http://standards.iso.org/ittf/PubliclyAvailableStandards/ISO_IEC_14496-4_2004_Conformance_Testing/video_conformance/version_1/simple/ERROR.ZIP/mit025.m4v needs this but its unclear if the mpeg4 standard allows this at all (MN)
4520
        if(s->pict_type != B_TYPE){
4521
            while(show_bits(&s->gb, 9 + (s->pict_type == P_TYPE)) == 1)
4522
                skip_bits(&s->gb, 9 + (s->pict_type == P_TYPE));
4523
        }
4524
#endif
4525
        if(mpeg4_is_resync(s)){
4526
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4527
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4528
                return SLICE_OK;
4529
            return SLICE_END;
4530
        }
4531
    }
4532

    
4533
    return SLICE_OK;
4534
}
4535

    
4536
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4537
{
4538
    int code, val, sign, shift, l;
4539
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4540

    
4541
    if (code == 0)
4542
        return pred;
4543
    if (code < 0)
4544
        return 0xffff;
4545

    
4546
    sign = get_bits1(&s->gb);
4547
    shift = f_code - 1;
4548
    val = code;
4549
    if (shift) {
4550
        val = (val - 1) << shift;
4551
        val |= get_bits(&s->gb, shift);
4552
        val++;
4553
    }
4554
    if (sign)
4555
        val = -val;
4556
    val += pred;
4557

    
4558
    /* modulo decoding */
4559
    if (!s->h263_long_vectors) {
4560
        l = INT_BIT - 5 - f_code;
4561
        val = (val<<l)>>l;
4562
    } else {
4563
        /* horrible h263 long vector mode */
4564
        if (pred < -31 && val < -63)
4565
            val += 64;
4566
        if (pred > 32 && val > 63)
4567
            val -= 64;
4568

    
4569
    }
4570
    return val;
4571
}
4572

    
4573
/* Decodes RVLC of H.263+ UMV */
4574
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4575
{
4576
   int code = 0, sign;
4577

    
4578
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4579
      return pred;
4580

    
4581
   code = 2 + get_bits1(&s->gb);
4582

    
4583
   while (get_bits1(&s->gb))
4584
   {
4585
      code <<= 1;
4586
      code += get_bits1(&s->gb);
4587
   }
4588
   sign = code & 1;
4589
   code >>= 1;
4590

    
4591
   code = (sign) ? (pred - code) : (pred + code);
4592
#ifdef DEBUG
4593
   av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4594
#endif
4595
   return code;
4596

    
4597
}
4598

    
4599
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4600
                             int n, int coded)
4601
{
4602
    int code, level, i, j, last, run;
4603
    RLTable *rl = &rl_inter;
4604
    const uint8_t *scan_table;
4605
    GetBitContext gb= s->gb;
4606

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

    
4729
/**
4730
 * decodes the dc value.
4731
 * @param n block index (0-3 are luma, 4-5 are chroma)
4732
 * @param dir_ptr the prediction direction will be stored here
4733
 * @return the quantized dc
4734
 */
4735
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4736
{
4737
    int level, code;
4738

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

    
4763
        if (code > 8){
4764
            if(get_bits1(&s->gb)==0){ /* marker */
4765
                if(s->error_resilience>=2){
4766
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4767
                    return -1;
4768
                }
4769
            }
4770
        }
4771
    }
4772

    
4773
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4774
}
4775

    
4776
/**
4777
 * decodes a block.
4778
 * @return <0 if an error occured
4779
 */
4780
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4781
                              int n, int coded, int intra, int rvlc)
4782
{
4783
    int level, i, last, run;
4784
    int dc_pred_dir;
4785
    RLTable * rl;
4786
    RL_VLC_ELEM * rl_vlc;
4787
    const uint8_t * scan_table;
4788
    int qmul, qadd;
4789