Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 1be7c87f

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
141
static void show_pict_info(MpegEncContext *s){
142
    av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
143
         s->qscale, av_get_pict_type_char(s->pict_type),
144
         s->gb.size_in_bits, 1-s->no_rounding,
145
         s->obmc ? " AP" : "",
146
         s->umvplus ? " UMV" : "",
147
         s->h263_long_vectors ? " LONG" : "",
148
         s->h263_plus ? " +" : "",
149
         s->h263_aic ? " AIC" : "",
150
         s->alt_inter_vlc ? " AIV" : "",
151
         s->modified_quant ? " MQ" : "",
152
         s->loop_filter ? " LOOP" : "",
153
         s->h263_slice_structured ? " SS" : "",
154
         s->avctx->time_base.den, s->avctx->time_base.num
155
    );
156
}
157

    
158
#ifdef CONFIG_ENCODERS
159

    
160
static void aspect_to_info(MpegEncContext * s, AVRational aspect){
161
    int i;
162

    
163
    if(aspect.num==0) aspect= (AVRational){1,1};
164

    
165
    for(i=1; i<6; i++){
166
        if(av_cmp_q(pixel_aspect[i], aspect) == 0){
167
            s->aspect_ratio_info=i;
168
            return;
169
        }
170
    }
171

    
172
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
173
}
174

    
175
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
176
{
177
      int format;
178

    
179
      align_put_bits(&s->pb);
180

    
181
      put_bits(&s->pb, 17, 1);
182
      put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
183
      put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
184
                           s->avctx->time_base.den) & 0xff); /* TemporalReference */
185
      if (s->width == 352 && s->height == 288)
186
        format = 2;
187
      else if (s->width == 176 && s->height == 144)
188
        format = 3;
189
      else if (s->width == 128 && s->height == 96)
190
        format = 4;
191
      else if (s->width == 320 && s->height == 240)
192
        format = 5;
193
      else if (s->width == 160 && s->height == 120)
194
        format = 6;
195
      else if (s->width <= 255 && s->height <= 255)
196
        format = 0; /* use 1 byte width & height */
197
      else
198
        format = 1; /* use 2 bytes width & height */
199
      put_bits(&s->pb, 3, format); /* PictureSize */
200
      if (format == 0) {
201
        put_bits(&s->pb, 8, s->width);
202
        put_bits(&s->pb, 8, s->height);
203
      } else if (format == 1) {
204
        put_bits(&s->pb, 16, s->width);
205
        put_bits(&s->pb, 16, s->height);
206
      }
207
      put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
208
      put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
209
      put_bits(&s->pb, 5, s->qscale); /* Quantizer */
210
      put_bits(&s->pb, 1, 0); /* ExtraInformation */
211

    
212
      if(s->h263_aic){
213
        s->y_dc_scale_table=
214
          s->c_dc_scale_table= ff_aic_dc_scale_table;
215
      }else{
216
        s->y_dc_scale_table=
217
          s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
218
      }
219
}
220

    
221
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
222
{
223
    int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
224
    int best_clock_code=1;
225
    int best_divisor=60;
226
    int best_error= INT_MAX;
227

    
228
    if(s->h263_plus){
229
        for(i=0; i<2; i++){
230
            int div, error;
231
            div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
232
            div= av_clip(div, 1, 127);
233
            error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
234
            if(error < best_error){
235
                best_error= error;
236
                best_divisor= div;
237
                best_clock_code= i;
238
            }
239
        }
240
    }
241
    s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
242
    coded_frame_rate= 1800000;
243
    coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
244

    
245
    align_put_bits(&s->pb);
246

    
247
    /* Update the pointer to last GOB */
248
    s->ptr_lastgob = pbBufPtr(&s->pb);
249
    put_bits(&s->pb, 22, 0x20); /* PSC */
250
    temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
251
                         (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
252
    put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
253

    
254
    put_bits(&s->pb, 1, 1);     /* marker */
255
    put_bits(&s->pb, 1, 0);     /* h263 id */
256
    put_bits(&s->pb, 1, 0);     /* split screen off */
257
    put_bits(&s->pb, 1, 0);     /* camera  off */
258
    put_bits(&s->pb, 1, 0);     /* freeze picture release off */
259

    
260
    format = h263_get_picture_format(s->width, s->height);
261
    if (!s->h263_plus) {
262
        /* H.263v1 */
263
        put_bits(&s->pb, 3, format);
264
        put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
265
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
266
        of H.263v1 UMV implies to check the predicted MV after
267
        calculation of the current MB to see if we're on the limits */
268
        put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
269
        put_bits(&s->pb, 1, 0);         /* SAC: off */
270
        put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
271
        put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
272
        put_bits(&s->pb, 5, s->qscale);
273
        put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
274
    } else {
275
        int ufep=1;
276
        /* H.263v2 */
277
        /* H.263 Plus PTYPE */
278

    
279
        put_bits(&s->pb, 3, 7);
280
        put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
281
        if (format == 7)
282
            put_bits(&s->pb,3,6); /* Custom Source Format */
283
        else
284
            put_bits(&s->pb, 3, format);
285

    
286
        put_bits(&s->pb,1, s->custom_pcf);
287
        put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
288
        put_bits(&s->pb,1,0); /* SAC: off */
289
        put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
290
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
291
        put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
292
        put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
293
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
294
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
295
        put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
296
        put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
297
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
298
        put_bits(&s->pb,3,0); /* Reserved */
299

    
300
        put_bits(&s->pb, 3, s->pict_type == P_TYPE);
301

    
302
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
303
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
304
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
305
        put_bits(&s->pb,2,0); /* Reserved */
306
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
307

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

    
311
                if (format == 7) {
312
            /* Custom Picture Format (CPFMT) */
313
            aspect_to_info(s, s->avctx->sample_aspect_ratio);
314

    
315
            put_bits(&s->pb,4,s->aspect_ratio_info);
316
            put_bits(&s->pb,9,(s->width >> 2) - 1);
317
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
318
            put_bits(&s->pb,9,(s->height >> 2));
319
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
320
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
321
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
322
            }
323
        }
324
        if(s->custom_pcf){
325
            if(ufep){
326
                put_bits(&s->pb, 1, best_clock_code);
327
                put_bits(&s->pb, 7, best_divisor);
328
            }
329
            put_bits(&s->pb, 2, (temp_ref>>8)&3);
330
        }
331

    
332
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
333
        if (s->umvplus)
334
//            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
335
//FIXME check actual requested range
336
            put_bits(&s->pb,2,1); /* unlimited */
337
        if(s->h263_slice_structured)
338
            put_bits(&s->pb,2,0); /* no weird submodes */
339

    
340
        put_bits(&s->pb, 5, s->qscale);
341
    }
342

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

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

    
348
        assert(s->mb_x == 0 && s->mb_y == 0);
349
        ff_h263_encode_mba(s);
350

    
351
        put_bits(&s->pb, 1, 1);
352
    }
353

    
354
    if(s->h263_aic){
355
         s->y_dc_scale_table=
356
         s->c_dc_scale_table= ff_aic_dc_scale_table;
357
    }else{
358
        s->y_dc_scale_table=
359
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
360
    }
361
}
362

    
363
/**
364
 * Encodes a group of blocks header.
365
 */
366
void h263_encode_gob_header(MpegEncContext * s, int mb_line)
367
{
368
    put_bits(&s->pb, 17, 1); /* GBSC */
369

    
370
    if(s->h263_slice_structured){
371
        put_bits(&s->pb, 1, 1);
372

    
373
        ff_h263_encode_mba(s);
374

    
375
        if(s->mb_num > 1583)
376
            put_bits(&s->pb, 1, 1);
377
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
378
        put_bits(&s->pb, 1, 1);
379
        put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
380
    }else{
381
        int gob_number= mb_line / s->gob_index;
382

    
383
        put_bits(&s->pb, 5, gob_number); /* GN */
384
        put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
385
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
386
    }
387
}
388

    
389
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
390
    int last=0;
391
    int j;
392
    int rate=0;
393

    
394
    for(j=1; j<=block_last_index; j++){
395
        const int index= scantable[j];
396
        int level= block[index];
397
        if(level){
398
            level+= 64;
399
            if((level&(~127)) == 0){
400
                if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
401
                else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
402
            }else
403
                rate += s->ac_esc_length;
404
            level-= 64;
405

    
406
            last= j;
407
        }
408
    }
409

    
410
    return rate;
411
}
412

    
413
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
414
{
415
    int score= 0;
416
    int i, n;
417
    int8_t * const qscale_table= s->current_picture.qscale_table;
418

    
419
    memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
420

    
421
    for(n=0; n<6; n++){
422
        int16_t *ac_val, *ac_val1;
423

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

    
426
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
427
        ac_val1= ac_val;
428
        if(dir[n]){
429
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
430
            /* top prediction */
431
            ac_val-= s->block_wrap[n]*16;
432
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
433
                /* same qscale */
434
                for(i=1; i<8; i++){
435
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
436
                    block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
437
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
438
                    ac_val1[i+8]= level;
439
                }
440
            }else{
441
                /* different qscale, we must rescale */
442
                for(i=1; i<8; i++){
443
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
444
                    block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
445
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
446
                    ac_val1[i+8]= level;
447
                }
448
            }
449
            st[n]= s->intra_h_scantable.permutated;
450
        }else{
451
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
452
            /* left prediction */
453
            ac_val-= 16;
454
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
455
                /* same qscale */
456
                for(i=1; i<8; i++){
457
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
458
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
459
                    ac_val1[i  ]= level;
460
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
461
                }
462
            }else{
463
                /* different qscale, we must rescale */
464
                for(i=1; i<8; i++){
465
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
466
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
467
                    ac_val1[i  ]= level;
468
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
469
                }
470
            }
471
            st[n]= s->intra_v_scantable.permutated;
472
        }
473

    
474
        for(i=63; i>0; i--) //FIXME optimize
475
            if(block[n][ st[n][i] ]) break;
476
        s->block_last_index[n]= i;
477

    
478
        score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
479
    }
480

    
481
    return score < 0;
482
}
483

    
484
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
485
{
486
    int i, n;
487
    memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
488

    
489
    for(n=0; n<6; n++){
490
        int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
491

    
492
        st[n]= s->intra_scantable.permutated;
493
        if(dir[n]){
494
            /* top prediction */
495
            for(i=1; i<8; i++){
496
                block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
497
            }
498
        }else{
499
            /* left prediction */
500
            for(i=1; i<8; i++){
501
                block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
502
            }
503
        }
504
    }
505
}
506

    
507
/**
508
 * init s->current_picture.qscale_table from s->lambda_table
509
 */
510
static void ff_init_qscale_tab(MpegEncContext *s){
511
    int8_t * const qscale_table= s->current_picture.qscale_table;
512
    int i;
513

    
514
    for(i=0; i<s->mb_num; i++){
515
        unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ];
516
        int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
517
        qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax);
518
    }
519
}
520

    
521
/**
522
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
523
 */
524
void ff_clean_h263_qscales(MpegEncContext *s){
525
    int i;
526
    int8_t * const qscale_table= s->current_picture.qscale_table;
527

    
528
    ff_init_qscale_tab(s);
529

    
530
    for(i=1; i<s->mb_num; i++){
531
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
532
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
533
    }
534
    for(i=s->mb_num-2; i>=0; i--){
535
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
536
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
537
    }
538

    
539
    if(s->codec_id != CODEC_ID_H263P){
540
        for(i=1; i<s->mb_num; i++){
541
            int mb_xy= s->mb_index2xy[i];
542

    
543
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
544
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
545
            }
546
        }
547
    }
548
}
549

    
550
/**
551
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
552
 */
553
void ff_clean_mpeg4_qscales(MpegEncContext *s){
554
    int i;
555
    int8_t * const qscale_table= s->current_picture.qscale_table;
556

    
557
    ff_clean_h263_qscales(s);
558

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

    
563
        for(i=0; i<s->mb_num; i++){
564
            int mb_xy= s->mb_index2xy[i];
565
            odd += qscale_table[mb_xy]&1;
566
        }
567

    
568
        if(2*odd > s->mb_num) odd=1;
569
        else                  odd=0;
570

    
571
        for(i=0; i<s->mb_num; i++){
572
            int mb_xy= s->mb_index2xy[i];
573
            if((qscale_table[mb_xy]&1) != odd)
574
                qscale_table[mb_xy]++;
575
            if(qscale_table[mb_xy] > 31)
576
                qscale_table[mb_xy]= 31;
577
        }
578

    
579
        for(i=1; i<s->mb_num; i++){
580
            int mb_xy= s->mb_index2xy[i];
581
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
582
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
583
            }
584
        }
585
    }
586
}
587

    
588
#endif //CONFIG_ENCODERS
589

    
590
#define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
591
#define tab_bias (tab_size/2)
592

    
593
void ff_mpeg4_init_direct_mv(MpegEncContext *s){
594
    int i;
595
    for(i=0; i<tab_size; i++){
596
        s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
597
        s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
598
    }
599
}
600

    
601
static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
602
    int xy= s->block_index[i];
603
    uint16_t time_pp= s->pp_time;
604
    uint16_t time_pb= s->pb_time;
605
    int p_mx, p_my;
606

    
607
    p_mx= s->next_picture.motion_val[0][xy][0];
608
    if((unsigned)(p_mx + tab_bias) < tab_size){
609
        s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
610
        s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
611
                            : s->direct_scale_mv[1][p_mx + tab_bias];
612
    }else{
613
        s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
614
        s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
615
                            : p_mx*(time_pb - time_pp)/time_pp;
616
    }
617
    p_my= s->next_picture.motion_val[0][xy][1];
618
    if((unsigned)(p_my + tab_bias) < tab_size){
619
        s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
620
        s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
621
                            : s->direct_scale_mv[1][p_my + tab_bias];
622
    }else{
623
        s->mv[0][i][1] = p_my*time_pb/time_pp + my;
624
        s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
625
                            : p_my*(time_pb - time_pp)/time_pp;
626
    }
627
}
628

    
629
#undef tab_size
630
#undef tab_bias
631

    
632
/**
633
 *
634
 * @return the mb_type
635
 */
636
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
637
    const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
638
    const int colocated_mb_type= s->next_picture.mb_type[mb_index];
639
    uint16_t time_pp= s->pp_time;
640
    uint16_t time_pb= s->pb_time;
641
    int i;
642

    
643
    //FIXME avoid divides
644
    // try special case with shifts for 1 and 3 B-frames?
645

    
646
    if(IS_8X8(colocated_mb_type)){
647
        s->mv_type = MV_TYPE_8X8;
648
        for(i=0; i<4; i++){
649
            ff_mpeg4_set_one_direct_mv(s, mx, my, i);
650
        }
651
        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
652
    } else if(IS_INTERLACED(colocated_mb_type)){
653
        s->mv_type = MV_TYPE_FIELD;
654
        for(i=0; i<2; i++){
655
            int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
656
            s->field_select[0][i]= field_select;
657
            s->field_select[1][i]= i;
658
            if(s->top_field_first){
659
                time_pp= s->pp_field_time - field_select + i;
660
                time_pb= s->pb_field_time - field_select + i;
661
            }else{
662
                time_pp= s->pp_field_time + field_select - i;
663
                time_pb= s->pb_field_time + field_select - i;
664
            }
665
            s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
666
            s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
667
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
668
                                : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
669
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
670
                                : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
671
        }
672
        return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
673
    }else{
674
        ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
675
        s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
676
        s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
677
        s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
678
        s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
679
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
680
            s->mv_type= MV_TYPE_16X16;
681
        else
682
            s->mv_type= MV_TYPE_8X8;
683
        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
684
    }
685
}
686

    
687
void ff_h263_update_motion_val(MpegEncContext * s){
688
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
689
               //FIXME a lot of that is only needed for !low_delay
690
    const int wrap = s->b8_stride;
691
    const int xy = s->block_index[0];
692

    
693
    s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
694

    
695
    if(s->mv_type != MV_TYPE_8X8){
696
        int motion_x, motion_y;
697
        if (s->mb_intra) {
698
            motion_x = 0;
699
            motion_y = 0;
700
        } else if (s->mv_type == MV_TYPE_16X16) {
701
            motion_x = s->mv[0][0][0];
702
            motion_y = s->mv[0][0][1];
703
        } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
704
            int i;
705
            motion_x = s->mv[0][0][0] + s->mv[0][1][0];
706
            motion_y = s->mv[0][0][1] + s->mv[0][1][1];
707
            motion_x = (motion_x>>1) | (motion_x&1);
708
            for(i=0; i<2; i++){
709
                s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
710
                s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
711
            }
712
            s->current_picture.ref_index[0][xy           ]=
713
            s->current_picture.ref_index[0][xy        + 1]= s->field_select[0][0];
714
            s->current_picture.ref_index[0][xy + wrap    ]=
715
            s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
716
        }
717

    
718
        /* no update if 8X8 because it has been done during parsing */
719
        s->current_picture.motion_val[0][xy][0] = motion_x;
720
        s->current_picture.motion_val[0][xy][1] = motion_y;
721
        s->current_picture.motion_val[0][xy + 1][0] = motion_x;
722
        s->current_picture.motion_val[0][xy + 1][1] = motion_y;
723
        s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
724
        s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
725
        s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
726
        s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
727
    }
728

    
729
    if(s->encoding){ //FIXME encoding MUST be cleaned up
730
        if (s->mv_type == MV_TYPE_8X8)
731
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
732
        else if(s->mb_intra)
733
            s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
734
        else
735
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
736
    }
737
}
738

    
739
#ifdef CONFIG_ENCODERS
740

    
741
static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
742
    int l, bit_size, code;
743

    
744
    if (val == 0) {
745
        return mvtab[0][1];
746
    } else {
747
        bit_size = f_code - 1;
748
        /* modulo encoding */
749
        l= INT_BIT - 6 - bit_size;
750
        val = (val<<l)>>l;
751
        val--;
752
        code = (val >> bit_size) + 1;
753

    
754
        return mvtab[code][1] + 1 + bit_size;
755
    }
756
}
757

    
758
static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
759
    if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
760
        skip_put_bits(&s->pb,
761
            h263_get_motion_length(s, x, f_code)
762
           +h263_get_motion_length(s, y, f_code));
763
    }else{
764
        ff_h263_encode_motion(s, x, f_code);
765
        ff_h263_encode_motion(s, y, f_code);
766
    }
767
}
768

    
769
static inline int get_p_cbp(MpegEncContext * s,
770
                      DCTELEM block[6][64],
771
                      int motion_x, int motion_y){
772
    int cbp, i;
773

    
774
    if(s->flags & CODEC_FLAG_CBP_RD){
775
        int best_cbpy_score= INT_MAX;
776
        int best_cbpc_score= INT_MAX;
777
        int cbpc = (-1), cbpy= (-1);
778
        const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
779
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
780

    
781
        for(i=0; i<4; i++){
782
            int score= inter_MCBPC_bits[i + offset] * lambda;
783
            if(i&1) score += s->coded_score[5];
784
            if(i&2) score += s->coded_score[4];
785

    
786
            if(score < best_cbpc_score){
787
                best_cbpc_score= score;
788
                cbpc= i;
789
            }
790
        }
791

    
792
        for(i=0; i<16; i++){
793
            int score= cbpy_tab[i ^ 0xF][1] * lambda;
794
            if(i&1) score += s->coded_score[3];
795
            if(i&2) score += s->coded_score[2];
796
            if(i&4) score += s->coded_score[1];
797
            if(i&8) score += s->coded_score[0];
798

    
799
            if(score < best_cbpy_score){
800
                best_cbpy_score= score;
801
                cbpy= i;
802
            }
803
        }
804
        cbp= cbpc + 4*cbpy;
805
        if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
806
            if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
807
                cbp= 0;
808
        }
809

    
810
        for (i = 0; i < 6; i++) {
811
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
812
                s->block_last_index[i]= -1;
813
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
814
            }
815
        }
816
    }else{
817
        cbp= 0;
818
        for (i = 0; i < 6; i++) {
819
            if (s->block_last_index[i] >= 0)
820
                cbp |= 1 << (5 - i);
821
        }
822
    }
823
    return cbp;
824
}
825

    
826
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
827
                            int motion_x, int motion_y, int mb_type){
828
    int cbp=0, i;
829

    
830
    if(s->flags & CODEC_FLAG_CBP_RD){
831
        int score=0;
832
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
833

    
834
        for(i=0; i<6; i++){
835
            if(s->coded_score[i] < 0){
836
                score += s->coded_score[i];
837
                cbp |= 1 << (5 - i);
838
            }
839
        }
840

    
841
        if(cbp){
842
            int zero_score= -6;
843
            if ((motion_x | motion_y | s->dquant | mb_type) == 0){
844
                zero_score-= 4; //2*MV + mb_type + cbp bit
845
            }
846

    
847
            zero_score*= lambda;
848
            if(zero_score <= score){
849
                cbp=0;
850
            }
851
        }
852

    
853
        for (i = 0; i < 6; i++) {
854
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
855
                s->block_last_index[i]= -1;
856
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
857
            }
858
        }
859
    }else{
860
        for (i = 0; i < 6; i++) {
861
            if (s->block_last_index[i] >= 0)
862
                cbp |= 1 << (5 - i);
863
        }
864
    }
865
    return cbp;
866
}
867

    
868
static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
869
                               uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
870
    int i;
871

    
872
    if(scan_table){
873
        if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
874
            for (i = 0; i < 6; i++) {
875
                skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
876
            }
877
        }else{
878
            /* encode each block */
879
            for (i = 0; i < 6; i++) {
880
                mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
881
            }
882
        }
883
    }else{
884
        if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
885
            for (i = 0; i < 6; i++) {
886
                skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
887
            }
888
        }else{
889
            /* encode each block */
890
            for (i = 0; i < 6; i++) {
891
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
892
            }
893
        }
894
    }
895
}
896

    
897
void mpeg4_encode_mb(MpegEncContext * s,
898
                    DCTELEM block[6][64],
899
                    int motion_x, int motion_y)
900
{
901
    int cbpc, cbpy, pred_x, pred_y;
902
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
903
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
904
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
905
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
906
    const int dquant_code[5]= {1,0,9,2,3};
907

    
908
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
909
    if (!s->mb_intra) {
910
        int i, cbp;
911

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

    
916
            if(s->mb_x==0){
917
                for(i=0; i<2; i++){
918
                    s->last_mv[i][0][0]=
919
                    s->last_mv[i][0][1]=
920
                    s->last_mv[i][1][0]=
921
                    s->last_mv[i][1][1]= 0;
922
                }
923
            }
924

    
925
            assert(s->dquant>=-2 && s->dquant<=2);
926
            assert((s->dquant&1)==0);
927
            assert(mb_type>=0);
928

    
929
            /* nothing to do if this MB was skipped in the next P Frame */
930
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
931
                s->skip_count++;
932
                s->mv[0][0][0]=
933
                s->mv[0][0][1]=
934
                s->mv[1][0][0]=
935
                s->mv[1][0][1]= 0;
936
                s->mv_dir= MV_DIR_FORWARD; //doesn't matter
937
                s->qscale -= s->dquant;
938
//                s->mb_skipped=1;
939

    
940
                return;
941
            }
942

    
943
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
944

    
945
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
946
                /* direct MB with MV={0,0} */
947
                assert(s->dquant==0);
948

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

    
951
                if(interleaved_stats){
952
                    s->misc_bits++;
953
                    s->last_bits++;
954
                }
955
                s->skip_count++;
956
                return;
957
            }
958

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

    
964
            if(cbp && mb_type){
965
                if(s->dquant)
966
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
967
                else
968
                    put_bits(&s->pb, 1, 0);
969
            }else
970
                s->qscale -= s->dquant;
971

    
972
            if(!s->progressive_sequence){
973
                if(cbp)
974
                    put_bits(&s->pb, 1, s->interlaced_dct);
975
                if(mb_type) // not direct mode
976
                    put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
977
            }
978

    
979
            if(interleaved_stats){
980
                s->misc_bits+= get_bits_diff(s);
981
            }
982

    
983
            if(mb_type == 0){
984
                assert(s->mv_dir & MV_DIRECT);
985
                ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
986
                s->b_count++;
987
                s->f_count++;
988
            }else{
989
                assert(mb_type > 0 && mb_type < 4);
990
                if(s->mv_type != MV_TYPE_FIELD){
991
                    if(s->mv_dir & MV_DIR_FORWARD){
992
                        ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
993
                                                        s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
994
                        s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
995
                        s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
996
                        s->f_count++;
997
                    }
998
                    if(s->mv_dir & MV_DIR_BACKWARD){
999
                        ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
1000
                                                        s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
1001
                        s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
1002
                        s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
1003
                        s->b_count++;
1004
                    }
1005
                }else{
1006
                    if(s->mv_dir & MV_DIR_FORWARD){
1007
                        put_bits(&s->pb, 1, s->field_select[0][0]);
1008
                        put_bits(&s->pb, 1, s->field_select[0][1]);
1009
                    }
1010
                    if(s->mv_dir & MV_DIR_BACKWARD){
1011
                        put_bits(&s->pb, 1, s->field_select[1][0]);
1012
                        put_bits(&s->pb, 1, s->field_select[1][1]);
1013
                    }
1014
                    if(s->mv_dir & MV_DIR_FORWARD){
1015
                        for(i=0; i<2; i++){
1016
                            ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0]  ,
1017
                                                            s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1018
                            s->last_mv[0][i][0]= s->mv[0][i][0];
1019
                            s->last_mv[0][i][1]= s->mv[0][i][1]*2;
1020
                        }
1021
                        s->f_count++;
1022
                    }
1023
                    if(s->mv_dir & MV_DIR_BACKWARD){
1024
                        for(i=0; i<2; i++){
1025
                            ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0]  ,
1026
                                                            s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1027
                            s->last_mv[1][i][0]= s->mv[1][i][0];
1028
                            s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1029
                        }
1030
                        s->b_count++;
1031
                    }
1032
                }
1033
            }
1034

    
1035
            if(interleaved_stats){
1036
                s->mv_bits+= get_bits_diff(s);
1037
            }
1038

    
1039
            mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1040

    
1041
            if(interleaved_stats){
1042
                s->p_tex_bits+= get_bits_diff(s);
1043
            }
1044

    
1045
        }else{ /* s->pict_type==B_TYPE */
1046
            cbp= get_p_cbp(s, block, motion_x, motion_y);
1047

    
1048
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1049
                /* check if the B frames can skip it too, as we must skip it if we skip here
1050
                   why didn't they just compress the skip-mb bits instead of reusing them ?! */
1051
                if(s->max_b_frames>0){
1052
                    int i;
1053
                    int x,y, offset;
1054
                    uint8_t *p_pic;
1055

    
1056
                    x= s->mb_x*16;
1057
                    y= s->mb_y*16;
1058
                    if(x+16 > s->width)  x= s->width-16;
1059
                    if(y+16 > s->height) y= s->height-16;
1060

    
1061
                    offset= x + y*s->linesize;
1062
                    p_pic= s->new_picture.data[0] + offset;
1063

    
1064
                    s->mb_skipped=1;
1065
                    for(i=0; i<s->max_b_frames; i++){
1066
                        uint8_t *b_pic;
1067
                        int diff;
1068
                        Picture *pic= s->reordered_input_picture[i+1];
1069

    
1070
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
1071

    
1072
                        b_pic= pic->data[0] + offset;
1073
                        if(pic->type != FF_BUFFER_TYPE_SHARED)
1074
                            b_pic+= INPLACE_OFFSET;
1075
                        diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1076
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1077
                            s->mb_skipped=0;
1078
                            break;
1079
                        }
1080
                    }
1081
                }else
1082
                    s->mb_skipped=1;
1083

    
1084
                if(s->mb_skipped==1){
1085
                    /* skip macroblock */
1086
                    put_bits(&s->pb, 1, 1);
1087

    
1088
                    if(interleaved_stats){
1089
                        s->misc_bits++;
1090
                        s->last_bits++;
1091
                    }
1092
                    s->skip_count++;
1093

    
1094
                    return;
1095
                }
1096
            }
1097

    
1098
            put_bits(&s->pb, 1, 0);     /* mb coded */
1099
            cbpc = cbp & 3;
1100
            cbpy = cbp >> 2;
1101
            cbpy ^= 0xf;
1102
            if(s->mv_type==MV_TYPE_16X16){
1103
                if(s->dquant) cbpc+= 8;
1104
                put_bits(&s->pb,
1105
                        inter_MCBPC_bits[cbpc],
1106
                        inter_MCBPC_code[cbpc]);
1107

    
1108
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1109
                if(s->dquant)
1110
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
1111

    
1112
                if(!s->progressive_sequence){
1113
                    if(cbp)
1114
                        put_bits(pb2, 1, s->interlaced_dct);
1115
                    put_bits(pb2, 1, 0);
1116
                }
1117

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

    
1122
                /* motion vectors: 16x16 mode */
1123
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1124

    
1125
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
1126
                                                motion_y - pred_y, s->f_code);
1127
            }else if(s->mv_type==MV_TYPE_FIELD){
1128
                if(s->dquant) cbpc+= 8;
1129
                put_bits(&s->pb,
1130
                        inter_MCBPC_bits[cbpc],
1131
                        inter_MCBPC_code[cbpc]);
1132

    
1133
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1134
                if(s->dquant)
1135
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
1136

    
1137
                assert(!s->progressive_sequence);
1138
                if(cbp)
1139
                    put_bits(pb2, 1, s->interlaced_dct);
1140
                put_bits(pb2, 1, 1);
1141

    
1142
                if(interleaved_stats){
1143
                    s->misc_bits+= get_bits_diff(s);
1144
                }
1145

    
1146
                /* motion vectors: 16x8 interlaced mode */
1147
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1148
                pred_y /=2;
1149

    
1150
                put_bits(&s->pb, 1, s->field_select[0][0]);
1151
                put_bits(&s->pb, 1, s->field_select[0][1]);
1152

    
1153
                ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1154
                                                s->mv[0][0][1] - pred_y, s->f_code);
1155
                ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1156
                                                s->mv[0][1][1] - pred_y, s->f_code);
1157
            }else{
1158
                assert(s->mv_type==MV_TYPE_8X8);
1159
                put_bits(&s->pb,
1160
                        inter_MCBPC_bits[cbpc+16],
1161
                        inter_MCBPC_code[cbpc+16]);
1162
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1163

    
1164
                if(!s->progressive_sequence){
1165
                    if(cbp)
1166
                        put_bits(pb2, 1, s->interlaced_dct);
1167
                }
1168

    
1169
                if(interleaved_stats){
1170
                    s->misc_bits+= get_bits_diff(s);
1171
                }
1172

    
1173
                for(i=0; i<4; i++){
1174
                    /* motion vectors: 8x8 mode*/
1175
                    h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1176

    
1177
                    ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1178
                                                    s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1179
                }
1180
            }
1181

    
1182
            if(interleaved_stats){
1183
                s->mv_bits+= get_bits_diff(s);
1184
            }
1185

    
1186
            mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1187

    
1188
            if(interleaved_stats){
1189
                s->p_tex_bits+= get_bits_diff(s);
1190
            }
1191
            s->f_count++;
1192
        }
1193
    } else {
1194
        int cbp;
1195
        int dc_diff[6];   //dc values with the dc prediction subtracted
1196
        int dir[6];  //prediction direction
1197
        int zigzag_last_index[6];
1198
        uint8_t *scan_table[6];
1199
        int i;
1200

    
1201
        for(i=0; i<6; i++){
1202
            dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1203
        }
1204

    
1205
        if(s->flags & CODEC_FLAG_AC_PRED){
1206
            s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1207
            if(!s->ac_pred)
1208
                restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1209
        }else{
1210
            for(i=0; i<6; i++)
1211
                scan_table[i]= s->intra_scantable.permutated;
1212
        }
1213

    
1214
        /* compute cbp */
1215
        cbp = 0;
1216
        for (i = 0; i < 6; i++) {
1217
            if (s->block_last_index[i] >= 1)
1218
                cbp |= 1 << (5 - i);
1219
        }
1220

    
1221
        cbpc = cbp & 3;
1222
        if (s->pict_type == I_TYPE) {
1223
            if(s->dquant) cbpc+=4;
1224
            put_bits(&s->pb,
1225
                intra_MCBPC_bits[cbpc],
1226
                intra_MCBPC_code[cbpc]);
1227
        } else {
1228
            if(s->dquant) cbpc+=8;
1229
            put_bits(&s->pb, 1, 0);     /* mb coded */
1230
            put_bits(&s->pb,
1231
                inter_MCBPC_bits[cbpc + 4],
1232
                inter_MCBPC_code[cbpc + 4]);
1233
        }
1234
        put_bits(pb2, 1, s->ac_pred);
1235
        cbpy = cbp >> 2;
1236
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1237
        if(s->dquant)
1238
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1239

    
1240
        if(!s->progressive_sequence){
1241
            put_bits(dc_pb, 1, s->interlaced_dct);
1242
        }
1243

    
1244
        if(interleaved_stats){
1245
            s->misc_bits+= get_bits_diff(s);
1246
        }
1247

    
1248
        mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1249

    
1250
        if(interleaved_stats){
1251
            s->i_tex_bits+= get_bits_diff(s);
1252
        }
1253
        s->i_count++;
1254

    
1255
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1256
        if(s->ac_pred)
1257
            restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1258
    }
1259
}
1260

    
1261
void h263_encode_mb(MpegEncContext * s,
1262
                    DCTELEM block[6][64],
1263
                    int motion_x, int motion_y)
1264
{
1265
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
1266
    int16_t pred_dc;
1267
    int16_t rec_intradc[6];
1268
    int16_t *dc_ptr[6];
1269
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1270
    const int dquant_code[5]= {1,0,9,2,3};
1271

    
1272
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1273
    if (!s->mb_intra) {
1274
        /* compute cbp */
1275
        cbp= get_p_cbp(s, block, motion_x, motion_y);
1276

    
1277
        if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1278
            /* skip macroblock */
1279
            put_bits(&s->pb, 1, 1);
1280
            if(interleaved_stats){
1281
                s->misc_bits++;
1282
                s->last_bits++;
1283
            }
1284
            s->skip_count++;
1285

    
1286
            return;
1287
        }
1288
        put_bits(&s->pb, 1, 0);         /* mb coded */
1289

    
1290
        cbpc = cbp & 3;
1291
        cbpy = cbp >> 2;
1292
        if(s->alt_inter_vlc==0 || cbpc!=3)
1293
            cbpy ^= 0xF;
1294
        if(s->dquant) cbpc+= 8;
1295
        if(s->mv_type==MV_TYPE_16X16){
1296
            put_bits(&s->pb,
1297
                    inter_MCBPC_bits[cbpc],
1298
                    inter_MCBPC_code[cbpc]);
1299

    
1300
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1301
            if(s->dquant)
1302
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1303

    
1304
            if(interleaved_stats){
1305
                s->misc_bits+= get_bits_diff(s);
1306
            }
1307

    
1308
            /* motion vectors: 16x16 mode */
1309
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1310

    
1311
            if (!s->umvplus) {
1312
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
1313
                                                motion_y - pred_y, 1);
1314
            }
1315
            else {
1316
                h263p_encode_umotion(s, motion_x - pred_x);
1317
                h263p_encode_umotion(s, motion_y - pred_y);
1318
                if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1319
                    /* To prevent Start Code emulation */
1320
                    put_bits(&s->pb,1,1);
1321
            }
1322
        }else{
1323
            put_bits(&s->pb,
1324
                    inter_MCBPC_bits[cbpc+16],
1325
                    inter_MCBPC_code[cbpc+16]);
1326
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1327
            if(s->dquant)
1328
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1329

    
1330
            if(interleaved_stats){
1331
                s->misc_bits+= get_bits_diff(s);
1332
            }
1333

    
1334
            for(i=0; i<4; i++){
1335
                /* motion vectors: 8x8 mode*/
1336
                h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1337

    
1338
                motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1339
                motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1340
                if (!s->umvplus) {
1341
                    ff_h263_encode_motion_vector(s, motion_x - pred_x,
1342
                                                    motion_y - pred_y, 1);
1343
                }
1344
                else {
1345
                    h263p_encode_umotion(s, motion_x - pred_x);
1346
                    h263p_encode_umotion(s, motion_y - pred_y);
1347
                    if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1348
                        /* To prevent Start Code emulation */
1349
                        put_bits(&s->pb,1,1);
1350
                }
1351
            }
1352
        }
1353

    
1354
        if(interleaved_stats){
1355
            s->mv_bits+= get_bits_diff(s);
1356
        }
1357
    } else {
1358
        assert(s->mb_intra);
1359

    
1360
        cbp = 0;
1361
        if (s->h263_aic) {
1362
            /* Predict DC */
1363
            for(i=0; i<6; i++) {
1364
                int16_t level = block[i][0];
1365
                int scale;
1366

    
1367
                if(i<4) scale= s->y_dc_scale;
1368
                else    scale= s->c_dc_scale;
1369

    
1370
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1371
                level -= pred_dc;
1372
                /* Quant */
1373
                if (level >= 0)
1374
                    level = (level + (scale>>1))/scale;
1375
                else
1376
                    level = (level - (scale>>1))/scale;
1377

    
1378
                /* AIC can change CBP */
1379
                if (level == 0 && s->block_last_index[i] == 0)
1380
                    s->block_last_index[i] = -1;
1381

    
1382
                if(!s->modified_quant){
1383
                    if (level < -127)
1384
                        level = -127;
1385
                    else if (level > 127)
1386
                        level = 127;
1387
                }
1388

    
1389
                block[i][0] = level;
1390
                /* Reconstruction */
1391
                rec_intradc[i] = scale*level + pred_dc;
1392
                /* Oddify */
1393
                rec_intradc[i] |= 1;
1394
                //if ((rec_intradc[i] % 2) == 0)
1395
                //    rec_intradc[i]++;
1396
                /* Clipping */
1397
                if (rec_intradc[i] < 0)
1398
                    rec_intradc[i] = 0;
1399
                else if (rec_intradc[i] > 2047)
1400
                    rec_intradc[i] = 2047;
1401

    
1402
                /* Update AC/DC tables */
1403
                *dc_ptr[i] = rec_intradc[i];
1404
                if (s->block_last_index[i] >= 0)
1405
                    cbp |= 1 << (5 - i);
1406
            }
1407
        }else{
1408
            for(i=0; i<6; i++) {
1409
                /* compute cbp */
1410
                if (s->block_last_index[i] >= 1)
1411
                    cbp |= 1 << (5 - i);
1412
            }
1413
        }
1414

    
1415
        cbpc = cbp & 3;
1416
        if (s->pict_type == I_TYPE) {
1417
            if(s->dquant) cbpc+=4;
1418
            put_bits(&s->pb,
1419
                intra_MCBPC_bits[cbpc],
1420
                intra_MCBPC_code[cbpc]);
1421
        } else {
1422
            if(s->dquant) cbpc+=8;
1423
            put_bits(&s->pb, 1, 0);     /* mb coded */
1424
            put_bits(&s->pb,
1425
                inter_MCBPC_bits[cbpc + 4],
1426
                inter_MCBPC_code[cbpc + 4]);
1427
        }
1428
        if (s->h263_aic) {
1429
            /* XXX: currently, we do not try to use ac prediction */
1430
            put_bits(&s->pb, 1, 0);     /* no AC prediction */
1431
        }
1432
        cbpy = cbp >> 2;
1433
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1434
        if(s->dquant)
1435
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1436

    
1437
        if(interleaved_stats){
1438
            s->misc_bits+= get_bits_diff(s);
1439
        }
1440
    }
1441

    
1442
    for(i=0; i<6; i++) {
1443
        /* encode each block */
1444
        h263_encode_block(s, block[i], i);
1445

    
1446
        /* Update INTRADC for decoding */
1447
        if (s->h263_aic && s->mb_intra) {
1448
            block[i][0] = rec_intradc[i];
1449

    
1450
        }
1451
    }
1452

    
1453
    if(interleaved_stats){
1454
        if (!s->mb_intra) {
1455
            s->p_tex_bits+= get_bits_diff(s);
1456
            s->f_count++;
1457
        }else{
1458
            s->i_tex_bits+= get_bits_diff(s);
1459
            s->i_count++;
1460
        }
1461
    }
1462
}
1463
#endif
1464

    
1465
void ff_h263_loop_filter(MpegEncContext * s){
1466
    int qp_c;
1467
    const int linesize  = s->linesize;
1468
    const int uvlinesize= s->uvlinesize;
1469
    const int xy = s->mb_y * s->mb_stride + s->mb_x;
1470
    uint8_t *dest_y = s->dest[0];
1471
    uint8_t *dest_cb= s->dest[1];
1472
    uint8_t *dest_cr= s->dest[2];
1473

    
1474
//    if(s->pict_type==B_TYPE && !s->readable) return;
1475

    
1476
    /*
1477
       Diag Top
1478
       Left Center
1479
    */
1480
    if(!IS_SKIP(s->current_picture.mb_type[xy])){
1481
        qp_c= s->qscale;
1482
        s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
1483
        s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1484
    }else
1485
        qp_c= 0;
1486

    
1487
    if(s->mb_y){
1488
        int qp_dt, qp_t, qp_tc;
1489

    
1490
        if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1491
            qp_t=0;
1492
        else
1493
            qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1494

    
1495
        if(qp_c)
1496
            qp_tc= qp_c;
1497
        else
1498
            qp_tc= qp_t;
1499

    
1500
        if(qp_tc){
1501
            const int chroma_qp= s->chroma_qscale_table[qp_tc];
1502
            s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
1503
            s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
1504

    
1505
            s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1506
            s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1507
        }
1508

    
1509
        if(qp_t)
1510
            s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_t);
1511

    
1512
        if(s->mb_x){
1513
            if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1514
                qp_dt= qp_t;
1515
            else
1516
                qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1517

    
1518
            if(qp_dt){
1519
                const int chroma_qp= s->chroma_qscale_table[qp_dt];
1520
                s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
1521
                s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1522
                s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1523
            }
1524
        }
1525
    }
1526

    
1527
    if(qp_c){
1528
        s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
1529
        if(s->mb_y + 1 == s->mb_height)
1530
            s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
1531
    }
1532

    
1533
    if(s->mb_x){
1534
        int qp_lc;
1535
        if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1536
            qp_lc= qp_c;
1537
        else
1538
            qp_lc= s->current_picture.qscale_table[xy-1];
1539

    
1540
        if(qp_lc){
1541
            s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
1542
            if(s->mb_y + 1 == s->mb_height){
1543
                const int chroma_qp= s->chroma_qscale_table[qp_lc];
1544
                s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
1545
                s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
1546
                s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
1547
            }
1548
        }
1549
    }
1550
}
1551

    
1552
#ifdef CONFIG_ENCODERS
1553
static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1554
{
1555
    int x, y, wrap, a, c, pred_dc, scale;
1556
    int16_t *dc_val;
1557

    
1558
    /* find prediction */
1559
    if (n < 4) {
1560
        x = 2 * s->mb_x + (n & 1);
1561
        y = 2 * s->mb_y + ((n & 2) >> 1);
1562
        wrap = s->b8_stride;
1563
        dc_val = s->dc_val[0];
1564
        scale = s->y_dc_scale;
1565
    } else {
1566
        x = s->mb_x;
1567
        y = s->mb_y;
1568
        wrap = s->mb_stride;
1569
        dc_val = s->dc_val[n - 4 + 1];
1570
        scale = s->c_dc_scale;
1571
    }
1572
    /* B C
1573
     * A X
1574
     */
1575
    a = dc_val[(x - 1) + (y) * wrap];
1576
    c = dc_val[(x) + (y - 1) * wrap];
1577

    
1578
    /* No prediction outside GOB boundary */
1579
    if(s->first_slice_line && n!=3){
1580
        if(n!=2) c= 1024;
1581
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1582
    }
1583
    pred_dc = 1024;
1584
    /* just DC prediction */
1585
    if (a != 1024 && c != 1024)
1586
        pred_dc = (a + c) >> 1;
1587
    else if (a != 1024)
1588
        pred_dc = a;
1589
    else
1590
        pred_dc = c;
1591

    
1592
    /* we assume pred is positive */
1593
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1594
    *dc_val_ptr = &dc_val[x + y * wrap];
1595
    return pred_dc;
1596
}
1597
#endif /* CONFIG_ENCODERS */
1598

    
1599
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1600
{
1601
    int x, y, wrap, a, c, pred_dc, scale, i;
1602
    int16_t *dc_val, *ac_val, *ac_val1;
1603

    
1604
    /* find prediction */
1605
    if (n < 4) {
1606
        x = 2 * s->mb_x + (n & 1);
1607
        y = 2 * s->mb_y + (n>> 1);
1608
        wrap = s->b8_stride;
1609
        dc_val = s->dc_val[0];
1610
        ac_val = s->ac_val[0][0];
1611
        scale = s->y_dc_scale;
1612
    } else {
1613
        x = s->mb_x;
1614
        y = s->mb_y;
1615
        wrap = s->mb_stride;
1616
        dc_val = s->dc_val[n - 4 + 1];
1617
        ac_val = s->ac_val[n - 4 + 1][0];
1618
        scale = s->c_dc_scale;
1619
    }
1620

    
1621
    ac_val += ((y) * wrap + (x)) * 16;
1622
    ac_val1 = ac_val;
1623

    
1624
    /* B C
1625
     * A X
1626
     */
1627
    a = dc_val[(x - 1) + (y) * wrap];
1628
    c = dc_val[(x) + (y - 1) * wrap];
1629

    
1630
    /* No prediction outside GOB boundary */
1631
    if(s->first_slice_line && n!=3){
1632
        if(n!=2) c= 1024;
1633
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1634
    }
1635

    
1636
    if (s->ac_pred) {
1637
        pred_dc = 1024;
1638
        if (s->h263_aic_dir) {
1639
            /* left prediction */
1640
            if (a != 1024) {
1641
                ac_val -= 16;
1642
                for(i=1;i<8;i++) {
1643
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1644
                }
1645
                pred_dc = a;
1646
            }
1647
        } else {
1648
            /* top prediction */
1649
            if (c != 1024) {
1650
                ac_val -= 16 * wrap;
1651
                for(i=1;i<8;i++) {
1652
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1653
                }
1654
                pred_dc = c;
1655
            }
1656
        }
1657
    } else {
1658
        /* just DC prediction */
1659
        if (a != 1024 && c != 1024)
1660
            pred_dc = (a + c) >> 1;
1661
        else if (a != 1024)
1662
            pred_dc = a;
1663
        else
1664
            pred_dc = c;
1665
    }
1666

    
1667
    /* we assume pred is positive */
1668
    block[0]=block[0]*scale + pred_dc;
1669

    
1670
    if (block[0] < 0)
1671
        block[0] = 0;
1672
    else
1673
        block[0] |= 1;
1674

    
1675
    /* Update AC/DC tables */
1676
    dc_val[(x) + (y) * wrap] = block[0];
1677

    
1678
    /* left copy */
1679
    for(i=1;i<8;i++)
1680
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1681
    /* top copy */
1682
    for(i=1;i<8;i++)
1683
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1684
}
1685

    
1686
int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1687
                        int *px, int *py)
1688
{
1689
    int wrap;
1690
    int16_t *A, *B, *C, (*mot_val)[2];
1691
    static const int off[4]= {2, 1, 1, -1};
1692

    
1693
    wrap = s->b8_stride;
1694
    mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1695

    
1696
    A = mot_val[ - 1];
1697
    /* special case for first (slice) line */
1698
    if (s->first_slice_line && block<3) {
1699
        // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1700
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1701
        if(block==0){ //most common case
1702
            if(s->mb_x  == s->resync_mb_x){ //rare
1703
                *px= *py = 0;
1704
            }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1705
                C = mot_val[off[block] - wrap];
1706
                if(s->mb_x==0){
1707
                    *px = C[0];
1708
                    *py = C[1];
1709
                }else{
1710
                    *px = mid_pred(A[0], 0, C[0]);
1711
                    *py = mid_pred(A[1], 0, C[1]);
1712
                }
1713
            }else{
1714
                *px = A[0];
1715
                *py = A[1];
1716
            }
1717
        }else if(block==1){
1718
            if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1719
                C = mot_val[off[block] - wrap];
1720
                *px = mid_pred(A[0], 0, C[0]);
1721
                *py = mid_pred(A[1], 0, C[1]);
1722
            }else{
1723
                *px = A[0];
1724
                *py = A[1];
1725
            }
1726
        }else{ /* block==2*/
1727
            B = mot_val[ - wrap];
1728
            C = mot_val[off[block] - wrap];
1729
            if(s->mb_x == s->resync_mb_x) //rare
1730
                A[0]=A[1]=0;
1731

    
1732
            *px = mid_pred(A[0], B[0], C[0]);
1733
            *py = mid_pred(A[1], B[1], C[1]);
1734
        }
1735
    } else {
1736
        B = mot_val[ - wrap];
1737
        C = mot_val[off[block] - wrap];
1738
        *px = mid_pred(A[0], B[0], C[0]);
1739
        *py = mid_pred(A[1], B[1], C[1]);
1740
    }
1741
    return *mot_val;
1742
}
1743

    
1744
#ifdef CONFIG_ENCODERS
1745
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1746
{
1747
    int range, l, bit_size, sign, code, bits;
1748

    
1749
    if (val == 0) {
1750
        /* zero vector */
1751
        code = 0;
1752
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1753
    } else {
1754
        bit_size = f_code - 1;
1755
        range = 1 << bit_size;
1756
        /* modulo encoding */
1757
        l= INT_BIT - 6 - bit_size;
1758
        val = (val<<l)>>l;
1759
        sign = val>>31;
1760
        val= (val^sign)-sign;
1761
        sign&=1;
1762

    
1763
        val--;
1764
        code = (val >> bit_size) + 1;
1765
        bits = val & (range - 1);
1766

    
1767
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1768
        if (bit_size > 0) {
1769
            put_bits(&s->pb, bit_size, bits);
1770
        }
1771
    }
1772
}
1773

    
1774
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1775
static void h263p_encode_umotion(MpegEncContext * s, int val)
1776
{
1777
    short sval = 0;
1778
    short i = 0;
1779
    short n_bits = 0;
1780
    short temp_val;
1781
    int code = 0;
1782
    int tcode;
1783

    
1784
    if ( val == 0)
1785
        put_bits(&s->pb, 1, 1);
1786
    else if (val == 1)
1787
        put_bits(&s->pb, 3, 0);
1788
    else if (val == -1)
1789
        put_bits(&s->pb, 3, 2);
1790
    else {
1791

    
1792
        sval = ((val < 0) ? (short)(-val):(short)val);
1793
        temp_val = sval;
1794

    
1795
        while (temp_val != 0) {
1796
            temp_val = temp_val >> 1;
1797
            n_bits++;
1798
        }
1799

    
1800
        i = n_bits - 1;
1801
        while (i > 0) {
1802
            tcode = (sval & (1 << (i-1))) >> (i-1);
1803
            tcode = (tcode << 1) | 1;
1804
            code = (code << 2) | tcode;
1805
            i--;
1806
        }
1807
        code = ((code << 1) | (val < 0)) << 1;
1808
        put_bits(&s->pb, (2*n_bits)+1, code);
1809
        //printf("\nVal = %d\tCode = %d", sval, code);
1810
    }
1811
}
1812

    
1813
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1814
{
1815
    int f_code;
1816
    int mv;
1817

    
1818
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1819
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1820
            int len;
1821

    
1822
            if(mv==0) len= mvtab[0][1];
1823
            else{
1824
                int val, bit_size, range, code;
1825

    
1826
                bit_size = f_code - 1;
1827
                range = 1 << bit_size;
1828

    
1829
                val=mv;
1830
                if (val < 0)
1831
                    val = -val;
1832
                val--;
1833
                code = (val >> bit_size) + 1;
1834
                if(code<33){
1835
                    len= mvtab[code][1] + 1 + bit_size;
1836
                }else{
1837
                    len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1838
                }
1839
            }
1840

    
1841
            mv_penalty[f_code][mv+MAX_MV]= len;
1842
        }
1843
    }
1844

    
1845
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1846
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1847
            fcode_tab[mv+MAX_MV]= f_code;
1848
        }
1849
    }
1850

    
1851
    for(mv=0; mv<MAX_MV*2+1; mv++){
1852
        umv_fcode_tab[mv]= 1;
1853
    }
1854
}
1855
#endif
1856

    
1857
#ifdef CONFIG_ENCODERS
1858

    
1859
static void init_uni_dc_tab(void)
1860
{
1861
    int level, uni_code, uni_len;
1862

    
1863
    for(level=-256; level<256; level++){
1864
        int size, v, l;
1865
        /* find number of bits */
1866
        size = 0;
1867
        v = abs(level);
1868
        while (v) {
1869
            v >>= 1;
1870
            size++;
1871
        }
1872

    
1873
        if (level < 0)
1874
            l= (-level) ^ ((1 << size) - 1);
1875
        else
1876
            l= level;
1877

    
1878
        /* luminance */
1879
        uni_code= DCtab_lum[size][0];
1880
        uni_len = DCtab_lum[size][1];
1881

    
1882
        if (size > 0) {
1883
            uni_code<<=size; uni_code|=l;
1884
            uni_len+=size;
1885
            if (size > 8){
1886
                uni_code<<=1; uni_code|=1;
1887
                uni_len++;
1888
            }
1889
        }
1890
        uni_DCtab_lum_bits[level+256]= uni_code;
1891
        uni_DCtab_lum_len [level+256]= uni_len;
1892

    
1893
        /* chrominance */
1894
        uni_code= DCtab_chrom[size][0];
1895
        uni_len = DCtab_chrom[size][1];
1896

    
1897
        if (size > 0) {
1898
            uni_code<<=size; uni_code|=l;
1899
            uni_len+=size;
1900
            if (size > 8){
1901
                uni_code<<=1; uni_code|=1;
1902
                uni_len++;
1903
            }
1904
        }
1905
        uni_DCtab_chrom_bits[level+256]= uni_code;
1906
        uni_DCtab_chrom_len [level+256]= uni_len;
1907

    
1908
    }
1909
}
1910

    
1911
#endif //CONFIG_ENCODERS
1912

    
1913
#ifdef CONFIG_ENCODERS
1914
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1915
    int slevel, run, last;
1916

    
1917
    assert(MAX_LEVEL >= 64);
1918
    assert(MAX_RUN   >= 63);
1919

    
1920
    for(slevel=-64; slevel<64; slevel++){
1921
        if(slevel==0) continue;
1922
        for(run=0; run<64; run++){
1923
            for(last=0; last<=1; last++){
1924
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1925
                int level= slevel < 0 ? -slevel : slevel;
1926
                int sign= slevel < 0 ? 1 : 0;
1927
                int bits, len, code;
1928
                int level1, run1;
1929

    
1930
                len_tab[index]= 100;
1931

    
1932
                /* ESC0 */
1933
                code= get_rl_index(rl, last, run, level);
1934
                bits= rl->table_vlc[code][0];
1935
                len=  rl->table_vlc[code][1];
1936
                bits=bits*2+sign; len++;
1937

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

    
1955
                    if(code!=rl->n && len < len_tab[index]){
1956
                        bits_tab[index]= bits;
1957
                        len_tab [index]= len;
1958
                    }
1959
                }
1960
#endif
1961
#if 1
1962
                /* ESC2 */
1963
                bits= rl->table_vlc[rl->n][0];
1964
                len=  rl->table_vlc[rl->n][1];
1965
                bits=bits*4+2;    len+=2; //esc2
1966
                run1 = run - rl->max_run[last][level] - 1;
1967
                if(run1>=0){
1968
                    code= get_rl_index(rl, last, run1, level);
1969
                    bits<<= rl->table_vlc[code][1];
1970
                    len  += rl->table_vlc[code][1];
1971
                    bits += rl->table_vlc[code][0];
1972
                    bits=bits*2+sign; len++;
1973

    
1974
                    if(code!=rl->n && len < len_tab[index]){
1975
                        bits_tab[index]= bits;
1976
                        len_tab [index]= len;
1977
                    }
1978
                }
1979
#endif
1980
                /* ESC3 */
1981
                bits= rl->table_vlc[rl->n][0];
1982
                len = rl->table_vlc[rl->n][1];
1983
                bits=bits*4+3;    len+=2; //esc3
1984
                bits=bits*2+last; len++;
1985
                bits=bits*64+run; len+=6;
1986
                bits=bits*2+1;    len++;  //marker
1987
                bits=bits*4096+(slevel&0xfff); len+=12;
1988
                bits=bits*2+1;    len++;  //marker
1989

    
1990
                if(len < len_tab[index]){
1991
                    bits_tab[index]= bits;
1992
                    len_tab [index]= len;
1993
                }
1994
            }
1995
        }
1996
    }
1997
}
1998

    
1999
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
2000
    int slevel, run, last;
2001

    
2002
    assert(MAX_LEVEL >= 64);
2003
    assert(MAX_RUN   >= 63);
2004

    
2005
    for(slevel=-64; slevel<64; slevel++){
2006
        if(slevel==0) continue;
2007
        for(run=0; run<64; run++){
2008
            for(last=0; last<=1; last++){
2009
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
2010
                int level= slevel < 0 ? -slevel : slevel;
2011
                int sign= slevel < 0 ? 1 : 0;
2012
                int bits, len, code;
2013

    
2014
                len_tab[index]= 100;
2015

    
2016
                /* ESC0 */
2017
                code= get_rl_index(rl, last, run, level);
2018
                bits= rl->table_vlc[code][0];
2019
                len=  rl->table_vlc[code][1];
2020
                bits=bits*2+sign; len++;
2021

    
2022
                if(code!=rl->n && len < len_tab[index]){
2023
                    if(bits_tab) bits_tab[index]= bits;
2024
                    len_tab [index]= len;
2025
                }
2026
                /* ESC */
2027
                bits= rl->table_vlc[rl->n][0];
2028
                len = rl->table_vlc[rl->n][1];
2029
                bits=bits*2+last; len++;
2030
                bits=bits*64+run; len+=6;
2031
                bits=bits*256+(level&0xff); len+=8;
2032

    
2033
                if(len < len_tab[index]){
2034
                    if(bits_tab) bits_tab[index]= bits;
2035
                    len_tab [index]= len;
2036
                }
2037
            }
2038
        }
2039
    }
2040
}
2041

    
2042
void h263_encode_init(MpegEncContext *s)
2043
{
2044
    static int done = 0;
2045

    
2046
    if (!done) {
2047
        done = 1;
2048

    
2049
        init_uni_dc_tab();
2050

    
2051
        init_rl(&rl_inter, static_rl_table_store[0]);
2052
        init_rl(&rl_intra, static_rl_table_store[1]);
2053
        init_rl(&rl_intra_aic, static_rl_table_store[2]);
2054

    
2055
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2056
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2057

    
2058
        init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2059
        init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
2060

    
2061
        init_mv_penalty_and_fcode(s);
2062
    }
2063
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2064

    
2065
    s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
2066
    s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2067
    if(s->h263_aic){
2068
        s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
2069
        s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2070
    }
2071
    s->ac_esc_length= 7+1+6+8;
2072

    
2073
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2074
    switch(s->codec_id){
2075
    case CODEC_ID_MPEG4:
2076
        s->fcode_tab= fcode_tab;
2077
        s->min_qcoeff= -2048;
2078
        s->max_qcoeff=  2047;
2079
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
2080
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2081
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
2082
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2083
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
2084
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2085
        s->ac_esc_length= 7+2+1+6+1+12+1;
2086
        s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2087
        s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2088

    
2089
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2090

    
2091
            s->avctx->extradata= av_malloc(1024);
2092
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
2093

    
2094
            if(!(s->workaround_bugs & FF_BUG_MS))
2095
                mpeg4_encode_visual_object_header(s);
2096
            mpeg4_encode_vol_header(s, 0, 0);
2097

    
2098
//            ff_mpeg4_stuffing(&s->pb); ?
2099
            flush_put_bits(&s->pb);
2100
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2101
        }
2102

    
2103
        break;
2104
    case CODEC_ID_H263P:
2105
        if(s->umvplus)
2106
            s->fcode_tab= umv_fcode_tab;
2107
        if(s->modified_quant){
2108
            s->min_qcoeff= -2047;
2109
            s->max_qcoeff=  2047;
2110
        }else{
2111
            s->min_qcoeff= -127;
2112
            s->max_qcoeff=  127;
2113
        }
2114
        break;
2115
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2116
    case CODEC_ID_FLV1:
2117
        if (s->h263_flv > 1) {
2118
            s->min_qcoeff= -1023;
2119
            s->max_qcoeff=  1023;
2120
        } else {
2121
            s->min_qcoeff= -127;
2122
            s->max_qcoeff=  127;
2123
        }
2124
        s->y_dc_scale_table=
2125
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2126
        break;
2127
    default: //nothing needed - default table already set in mpegvideo.c
2128
        s->min_qcoeff= -127;
2129
        s->max_qcoeff=  127;
2130
        s->y_dc_scale_table=
2131
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2132
    }
2133
}
2134

    
2135
/**
2136
 * encodes a 8x8 block.
2137
 * @param block the 8x8 block
2138
 * @param n block index (0-3 are luma, 4-5 are chroma)
2139
 */
2140
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2141
{
2142
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2143
    RLTable *rl;
2144

    
2145
    rl = &rl_inter;
2146
    if (s->mb_intra && !s->h263_aic) {
2147
        /* DC coef */
2148
        level = block[0];
2149
        /* 255 cannot be represented, so we clamp */
2150
        if (level > 254) {
2151
            level = 254;
2152
            block[0] = 254;
2153
        }
2154
        /* 0 cannot be represented also */
2155
        else if (level < 1) {
2156
            level = 1;
2157
            block[0] = 1;
2158
        }
2159
        if (level == 128) //FIXME check rv10
2160
            put_bits(&s->pb, 8, 0xff);
2161
        else
2162
            put_bits(&s->pb, 8, level);
2163
        i = 1;
2164
    } else {
2165
        i = 0;
2166
        if (s->h263_aic && s->mb_intra)
2167
            rl = &rl_intra_aic;
2168

    
2169
        if(s->alt_inter_vlc && !s->mb_intra){
2170
            int aic_vlc_bits=0;
2171
            int inter_vlc_bits=0;
2172
            int wrong_pos=-1;
2173
            int aic_code;
2174

    
2175
            last_index = s->block_last_index[n];
2176
            last_non_zero = i - 1;
2177
            for (; i <= last_index; i++) {
2178
                j = s->intra_scantable.permutated[i];
2179
                level = block[j];
2180
                if (level) {
2181
                    run = i - last_non_zero - 1;
2182
                    last = (i == last_index);
2183

    
2184
                    if(level<0) level= -level;
2185

    
2186
                    code = get_rl_index(rl, last, run, level);
2187
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2188
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2189
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2190

    
2191
                    if (code == rl->n) {
2192
                        inter_vlc_bits += 1+6+8-1;
2193
                    }
2194
                    if (aic_code == rl_intra_aic.n) {
2195
                        aic_vlc_bits += 1+6+8-1;
2196
                        wrong_pos += run + 1;
2197
                    }else
2198
                        wrong_pos += wrong_run[aic_code];
2199
                    last_non_zero = i;
2200
                }
2201
            }
2202
            i = 0;
2203
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2204
                rl = &rl_intra_aic;
2205
        }
2206
    }
2207

    
2208
    /* AC coefs */
2209
    last_index = s->block_last_index[n];
2210
    last_non_zero = i - 1;
2211
    for (; i <= last_index; i++) {
2212
        j = s->intra_scantable.permutated[i];
2213
        level = block[j];
2214
        if (level) {
2215
            run = i - last_non_zero - 1;
2216
            last = (i == last_index);
2217
            sign = 0;
2218
            slevel = level;
2219
            if (level < 0) {
2220
                sign = 1;
2221
                level = -level;
2222
            }
2223
            code = get_rl_index(rl, last, run, level);
2224
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2225
            if (code == rl->n) {
2226
              if(s->h263_flv <= 1){
2227
                put_bits(&s->pb, 1, last);
2228
                put_bits(&s->pb, 6, run);
2229

    
2230
                assert(slevel != 0);
2231

    
2232
                if(level < 128)
2233
                    put_bits(&s->pb, 8, slevel & 0xff);
2234
                else{
2235
                    put_bits(&s->pb, 8, 128);
2236
                    put_bits(&s->pb, 5, slevel & 0x1f);
2237
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2238
                }
2239
              }else{
2240
                if(level < 64) { // 7-bit level
2241
                        put_bits(&s->pb, 1, 0);
2242
                        put_bits(&s->pb, 1, last);
2243
                        put_bits(&s->pb, 6, run);
2244

    
2245
                        put_bits(&s->pb, 7, slevel & 0x7f);
2246
                    } else {
2247
                        /* 11-bit level */
2248
                        put_bits(&s->pb, 1, 1);
2249
                        put_bits(&s->pb, 1, last);
2250
                        put_bits(&s->pb, 6, run);
2251

    
2252
                        put_bits(&s->pb, 11, slevel & 0x7ff);
2253
                    }
2254
              }
2255
            } else {
2256
                put_bits(&s->pb, 1, sign);
2257
            }
2258
            last_non_zero = i;
2259
        }
2260
    }
2261
}
2262
#endif
2263

    
2264
#ifdef CONFIG_ENCODERS
2265

    
2266
/***************************************************/
2267
/**
2268
 * add mpeg4 stuffing bits (01...1)
2269
 */
2270
void ff_mpeg4_stuffing(PutBitContext * pbc)
2271
{
2272
    int length;
2273
    put_bits(pbc, 1, 0);
2274
    length= (-put_bits_count(pbc))&7;
2275
    if(length) put_bits(pbc, length, (1<<length)-1);
2276
}
2277

    
2278
/* must be called before writing the header */
2279
void ff_set_mpeg4_time(MpegEncContext * s){
2280
    if(s->pict_type==B_TYPE){
2281
        ff_mpeg4_init_direct_mv(s);
2282
    }else{
2283
        s->last_time_base= s->time_base;
2284
        s->time_base= s->time/s->avctx->time_base.den;
2285
    }
2286
}
2287

    
2288
static void mpeg4_encode_gop_header(MpegEncContext * s){
2289
    int hours, minutes, seconds;
2290
    int64_t time;
2291

    
2292
    put_bits(&s->pb, 16, 0);
2293
    put_bits(&s->pb, 16, GOP_STARTCODE);
2294

    
2295
    time= s->current_picture_ptr->pts;
2296
    if(s->reordered_input_picture[1])
2297
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2298
    time= time*s->avctx->time_base.num;
2299

    
2300
    seconds= time/s->avctx->time_base.den;
2301
    minutes= seconds/60; seconds %= 60;
2302
    hours= minutes/60; minutes %= 60;
2303
    hours%=24;
2304

    
2305
    put_bits(&s->pb, 5, hours);
2306
    put_bits(&s->pb, 6, minutes);
2307
    put_bits(&s->pb, 1, 1);
2308
    put_bits(&s->pb, 6, seconds);
2309

    
2310
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2311
    put_bits(&s->pb, 1, 0); //broken link == NO
2312

    
2313
    s->last_time_base= time / s->avctx->time_base.den;
2314

    
2315
    ff_mpeg4_stuffing(&s->pb);
2316
}
2317

    
2318
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2319
    int profile_and_level_indication;
2320
    int vo_ver_id;
2321

    
2322
    if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2323
        profile_and_level_indication = s->avctx->profile << 4;
2324
    }else if(s->max_b_frames || s->quarter_sample){
2325
        profile_and_level_indication= 0xF0; // adv simple
2326
    }else{
2327
        profile_and_level_indication= 0x00; // simple
2328
    }
2329

    
2330
    if(s->avctx->level != FF_LEVEL_UNKNOWN){
2331
        profile_and_level_indication |= s->avctx->level;
2332
    }else{
2333
        profile_and_level_indication |= 1; //level 1
2334
    }
2335

    
2336
    if(profile_and_level_indication>>4 == 0xF){
2337
        vo_ver_id= 5;
2338
    }else{
2339
        vo_ver_id= 1;
2340
    }
2341

    
2342
    //FIXME levels
2343

    
2344
    put_bits(&s->pb, 16, 0);
2345
    put_bits(&s->pb, 16, VOS_STARTCODE);
2346

    
2347
    put_bits(&s->pb, 8, profile_and_level_indication);
2348

    
2349
    put_bits(&s->pb, 16, 0);
2350
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2351

    
2352
    put_bits(&s->pb, 1, 1);
2353
        put_bits(&s->pb, 4, vo_ver_id);
2354
        put_bits(&s->pb, 3, 1); //priority
2355

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

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

    
2360
    ff_mpeg4_stuffing(&s->pb);
2361
}
2362

    
2363
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2364
{
2365
    int vo_ver_id;
2366

    
2367
    if (!ENABLE_MPEG4_ENCODER)  return;
2368

    
2369
    if(s->max_b_frames || s->quarter_sample){
2370
        vo_ver_id= 5;
2371
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2372
    }else{
2373
        vo_ver_id= 1;
2374
        s->vo_type= SIMPLE_VO_TYPE;
2375
    }
2376

    
2377
    put_bits(&s->pb, 16, 0);
2378
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2379
    put_bits(&s->pb, 16, 0);
2380
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2381

    
2382
    put_bits(&s->pb, 1, 0);             /* random access vol */
2383
    put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
2384
    if(s->workaround_bugs & FF_BUG_MS) {
2385
        put_bits(&s->pb, 1, 0);         /* is obj layer id= no */
2386
    } else {
2387
        put_bits(&s->pb, 1, 1);         /* is obj layer id= yes */
2388
        put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2389
        put_bits(&s->pb, 3, 1);         /* is obj layer priority */
2390
    }
2391

    
2392
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2393

    
2394
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2395
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2396
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2397
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2398
    }
2399

    
2400
    if(s->workaround_bugs & FF_BUG_MS) { //
2401
        put_bits(&s->pb, 1, 0);         /* vol control parameters= no @@@ */
2402
    } else {
2403
        put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
2404
        put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
2405
        put_bits(&s->pb, 1, s->low_delay);
2406
        put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
2407
    }
2408

    
2409
    put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2410
    put_bits(&s->pb, 1, 1);             /* marker bit */
2411

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

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

    
2433
    if(s->mpeg_quant){
2434
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2435
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2436
    }
2437

    
2438
    if (vo_ver_id != 1)
2439
        put_bits(&s->pb, 1, s->quarter_sample);
2440
    put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
2441
    s->resync_marker= s->rtp_mode;
2442
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2443
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2444
    if(s->data_partitioning){
2445
        put_bits(&s->pb, 1, 0);         /* no rvlc */
2446
    }
2447

    
2448
    if (vo_ver_id != 1){
2449
        put_bits(&s->pb, 1, 0);         /* newpred */
2450
        put_bits(&s->pb, 1, 0);         /* reduced res vop */
2451
    }
2452
    put_bits(&s->pb, 1, 0);             /* scalability */
2453

    
2454
    ff_mpeg4_stuffing(&s->pb);
2455

    
2456
    /* user data */
2457
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2458
        put_bits(&s->pb, 16, 0);
2459
        put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2460
        ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2461
    }
2462
}
2463

    
2464
/* write mpeg4 VOP header */
2465
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2466
{
2467
    int time_incr;
2468
    int time_div, time_mod;
2469

    
2470
    if(s->pict_type==I_TYPE){
2471
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2472
            if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2473
                mpeg4_encode_visual_object_header(s);
2474
            if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2475
                mpeg4_encode_vol_header(s, 0, 0);
2476
        }
2477
        if(!(s->workaround_bugs & FF_BUG_MS))
2478
            mpeg4_encode_gop_header(s);
2479
    }
2480

    
2481
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2482

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

    
2485
    put_bits(&s->pb, 16, 0);                /* vop header */
2486
    put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
2487
    put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
2488

    
2489
    assert(s->time>=0);
2490
    time_div= s->time/s->avctx->time_base.den;
2491
    time_mod= s->time%s->avctx->time_base.den;
2492
    time_incr= time_div - s->last_time_base;
2493
    assert(time_incr >= 0);
2494
    while(time_incr--)
2495
        put_bits(&s->pb, 1, 1);
2496

    
2497
    put_bits(&s->pb, 1, 0);
2498

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

    
2514
    put_bits(&s->pb, 5, s->qscale);
2515

    
2516
    if (s->pict_type != I_TYPE)
2517
        put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2518
    if (s->pict_type == B_TYPE)
2519
        put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2520
    //    printf("****frame %d\n", picture_number);
2521
}
2522

    
2523
#endif //CONFIG_ENCODERS
2524

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

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

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

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

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

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

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

    
2601
    return ret;
2602
}
2603

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

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

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

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

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

    
2662
}
2663

    
2664
#ifdef CONFIG_ENCODERS
2665

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

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

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

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

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

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

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

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

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

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

    
2890
    return len;
2891
}
2892

    
2893
#endif
2894

    
2895

    
2896
/***********************************************/
2897
/* decoding */
2898

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

    
2909
/* init vlcs */
2910

    
2911
/* XXX: find a better solution to handle static init */
2912
void h263_decode_init_vlc(MpegEncContext *s)
2913
{
2914
    static int done = 0;
2915

    
2916
    if (!done) {
2917
        done = 1;
2918

    
2919
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2920
                 intra_MCBPC_bits, 1, 1,
2921
                 intra_MCBPC_code, 1, 1, 1);
2922
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2923
                 inter_MCBPC_bits, 1, 1,
2924
                 inter_MCBPC_code, 1, 1, 1);
2925
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2926
                 &cbpy_tab[0][1], 2, 1,
2927
                 &cbpy_tab[0][0], 2, 1, 1);
2928
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2929
                 &mvtab[0][1], 2, 1,
2930
                 &mvtab[0][0], 2, 1, 1);
2931
        init_rl(&rl_inter, static_rl_table_store[0]);
2932
        init_rl(&rl_intra, static_rl_table_store[1]);
2933
        init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2934
        init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2935
        init_rl(&rl_intra_aic, static_rl_table_store[2]);
2936
        init_vlc_rl(&rl_inter, 1);
2937
        init_vlc_rl(&rl_intra, 1);
2938
        init_vlc_rl(&rvlc_rl_inter, 1);
2939
        init_vlc_rl(&rvlc_rl_intra, 1);
2940
        init_vlc_rl(&rl_intra_aic, 1);
2941
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2942
                 &DCtab_lum[0][1], 2, 1,
2943
                 &DCtab_lum[0][0], 2, 1, 1);
2944
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2945
                 &DCtab_chrom[0][1], 2, 1,
2946
                 &DCtab_chrom[0][0], 2, 1, 1);
2947
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2948
                 &sprite_trajectory_tab[0][1], 4, 2,
2949
                 &sprite_trajectory_tab[0][0], 4, 2, 1);
2950
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2951
                 &mb_type_b_tab[0][1], 2, 1,
2952
                 &mb_type_b_tab[0][0], 2, 1, 1);
2953
        init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2954
                 &h263_mbtype_b_tab[0][1], 2, 1,
2955
                 &h263_mbtype_b_tab[0][0], 2, 1, 1);
2956
        init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2957
                 &cbpc_b_tab[0][1], 2, 1,
2958
                 &cbpc_b_tab[0][0], 2, 1, 1);
2959
    }
2960
}
2961

    
2962
/**
2963
 * Get the GOB height based on picture height.
2964
 */
2965
int ff_h263_get_gob_height(MpegEncContext *s){
2966
    if (s->height <= 400)
2967
        return 1;
2968
    else if (s->height <= 800)
2969
        return  2;
2970
    else
2971
        return 4;
2972
}
2973

    
2974
int ff_h263_decode_mba(MpegEncContext *s)
2975
{
2976
    int i, mb_pos;
2977

    
2978
    for(i=0; i<6; i++){
2979
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2980
    }
2981
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2982
    s->mb_x= mb_pos % s->mb_width;
2983
    s->mb_y= mb_pos / s->mb_width;
2984

    
2985
    return mb_pos;
2986
}
2987

    
2988
void ff_h263_encode_mba(MpegEncContext *s)
2989
{
2990
    int i, mb_pos;
2991

    
2992
    for(i=0; i<6; i++){
2993
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2994
    }
2995
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
2996
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
2997
}
2998

    
2999
/**
3000
 * decodes the group of blocks header or slice header.
3001
 * @return <0 if an error occured
3002
 */
3003
static int h263_decode_gob_header(MpegEncContext *s)
3004
{
3005
    unsigned int val, gfid, gob_number;
3006
    int left;
3007

    
3008
    /* Check for GOB Start Code */
3009
    val = show_bits(&s->gb, 16);
3010
    if(val)
3011
        return -1;
3012

    
3013
        /* We have a GBSC probably with GSTUFF */
3014
    skip_bits(&s->gb, 16); /* Drop the zeros */
3015
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3016
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3017
    for(;left>13; left--){
3018
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3019
    }
3020
    if(left<=13)
3021
        return -1;
3022

    
3023
    if(s->h263_slice_structured){
3024
        if(get_bits1(&s->gb)==0)
3025
            return -1;
3026

    
3027
        ff_h263_decode_mba(s);
3028

    
3029
        if(s->mb_num > 1583)
3030
            if(get_bits1(&s->gb)==0)
3031
                return -1;
3032

    
3033
        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3034
        if(get_bits1(&s->gb)==0)
3035
            return -1;
3036
        gfid = get_bits(&s->gb, 2); /* GFID */
3037
    }else{
3038
        gob_number = get_bits(&s->gb, 5); /* GN */
3039
        s->mb_x= 0;
3040
        s->mb_y= s->gob_index* gob_number;
3041
        gfid = get_bits(&s->gb, 2); /* GFID */
3042
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3043
    }
3044

    
3045
    if(s->mb_y >= s->mb_height)
3046
        return -1;
3047

    
3048
    if(s->qscale==0)
3049
        return -1;
3050

    
3051
    return 0;
3052
}
3053

    
3054
static inline void memsetw(short *tab, int val, int n)
3055
{
3056
    int i;
3057
    for(i=0;i<n;i++)
3058
        tab[i] = val;
3059
}
3060

    
3061
#ifdef CONFIG_ENCODERS
3062

    
3063
void ff_mpeg4_init_partitions(MpegEncContext *s)
3064
{
3065
    uint8_t *start= pbBufPtr(&s->pb);
3066
    uint8_t *end= s->pb.buf_end;
3067
    int size= end - start;
3068
    int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3069
    int tex_size= (size - 2*pb_size)&(~3);
3070

    
3071
    set_put_bits_buffer_size(&s->pb, pb_size);
3072
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3073
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3074
}
3075

    
3076
void ff_mpeg4_merge_partitions(MpegEncContext *s)
3077
{
3078
    const int pb2_len   = put_bits_count(&s->pb2   );
3079
    const int tex_pb_len= put_bits_count(&s->tex_pb);
3080
    const int bits= put_bits_count(&s->pb);
3081

    
3082
    if(s->pict_type==I_TYPE){
3083
        put_bits(&s->pb, 19, DC_MARKER);
3084
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3085
        s->i_tex_bits+= tex_pb_len;
3086
    }else{
3087
        put_bits(&s->pb, 17, MOTION_MARKER);
3088
        s->misc_bits+=17 + pb2_len;
3089
        s->mv_bits+= bits - s->last_bits;
3090
        s->p_tex_bits+= tex_pb_len;
3091
    }
3092

    
3093
    flush_put_bits(&s->pb2);
3094
    flush_put_bits(&s->tex_pb);
3095

    
3096
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3097
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3098
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3099
    s->last_bits= put_bits_count(&s->pb);
3100
}
3101

    
3102
#endif //CONFIG_ENCODERS
3103

    
3104
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3105
    switch(s->pict_type){
3106
        case I_TYPE:
3107
            return 16;
3108
        case P_TYPE:
3109
        case S_TYPE:
3110
            return s->f_code+15;
3111
        case B_TYPE:
3112
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3113
        default:
3114
            return -1;
3115
    }
3116
}
3117

    
3118
#ifdef CONFIG_ENCODERS
3119

    
3120
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3121
{
3122
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3123

    
3124
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3125
    put_bits(&s->pb, 1, 1);
3126

    
3127
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3128
    put_bits(&s->pb, s->quant_precision, s->qscale);
3129
    put_bits(&s->pb, 1, 0); /* no HEC */
3130
}
3131

    
3132
#endif //CONFIG_ENCODERS
3133

    
3134
/**
3135
 * check if the next stuff is a resync marker or the end.
3136
 * @return 0 if not
3137
 */
3138
static inline int mpeg4_is_resync(MpegEncContext *s){
3139
    int bits_count= get_bits_count(&s->gb);
3140
    int v= show_bits(&s->gb, 16);
3141

    
3142
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3143
        return 0;
3144
    }
3145

    
3146
    while(v<=0xFF){
3147
        if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3148
            break;
3149
        skip_bits(&s->gb, 8+s->pict_type);
3150
        bits_count+= 8+s->pict_type;
3151
        v= show_bits(&s->gb, 16);
3152
    }
3153

    
3154
    if(bits_count + 8 >= s->gb.size_in_bits){
3155
        v>>=8;
3156
        v|= 0x7F >> (7-(bits_count&7));
3157

    
3158
        if(v==0x7F)
3159
            return 1;
3160
    }else{
3161
        if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3162
            int len;
3163
            GetBitContext gb= s->gb;
3164

    
3165
            skip_bits(&s->gb, 1);
3166
            align_get_bits(&s->gb);
3167

    
3168
            for(len=0; len<32; len++){
3169
                if(get_bits1(&s->gb)) break;
3170
            }
3171

    
3172
            s->gb= gb;
3173

    
3174
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3175
                return 1;
3176
        }
3177
    }
3178
    return 0;
3179
}
3180

    
3181
/**
3182
 * decodes the next video packet.
3183
 * @return <0 if something went wrong
3184
 */
3185
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3186
{
3187
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3188
    int header_extension=0, mb_num, len;
3189

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

    
3193
    for(len=0; len<32; len++){
3194
        if(get_bits1(&s->gb)) break;
3195
    }
3196

    
3197
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3198
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3199
        return -1;
3200
    }
3201

    
3202
    if(s->shape != RECT_SHAPE){
3203
        header_extension= get_bits1(&s->gb);
3204
        //FIXME more stuff here
3205
    }
3206

    
3207
    mb_num= get_bits(&s->gb, mb_num_bits);
3208
    if(mb_num>=s->mb_num){
3209
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3210
        return -1;
3211
    }
3212
    if(s->pict_type == B_TYPE){
3213
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3214
        if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3215
    }
3216

    
3217
    s->mb_x= mb_num % s->mb_width;
3218
    s->mb_y= mb_num / s->mb_width;
3219

    
3220
    if(s->shape != BIN_ONLY_SHAPE){
3221
        int qscale= get_bits(&s->gb, s->quant_precision);
3222
        if(qscale)
3223
            s->chroma_qscale=s->qscale= qscale;
3224
    }
3225

    
3226
    if(s->shape == RECT_SHAPE){
3227
        header_extension= get_bits1(&s->gb);
3228
    }
3229
    if(header_extension){
3230
        int time_increment;
3231
        int time_incr=0;
3232

    
3233
        while (get_bits1(&s->gb) != 0)
3234
            time_incr++;
3235

    
3236
        check_marker(&s->gb, "before time_increment in video packed header");
3237
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3238
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3239

    
3240
        skip_bits(&s->gb, 2); /* vop coding type */
3241
        //FIXME not rect stuff here
3242

    
3243
        if(s->shape != BIN_ONLY_SHAPE){
3244
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3245
//FIXME don't just ignore everything
3246
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3247
                mpeg4_decode_sprite_trajectory(s, &s->gb);
3248
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3249
            }
3250

    
3251
            //FIXME reduced res stuff here
3252

    
3253
            if (s->pict_type != I_TYPE) {
3254
                int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3255
                if(f_code==0){
3256
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3257
                }
3258
            }
3259
            if (s->pict_type == B_TYPE) {
3260
                int b_code = get_bits(&s->gb, 3);
3261
                if(b_code==0){
3262
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3263
                }
3264
            }
3265
        }
3266
    }
3267
    //FIXME new-pred stuff
3268

    
3269
//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));
3270

    
3271
    return 0;
3272
}
3273

    
3274
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3275
{
3276
    int c_wrap, c_xy, l_wrap, l_xy;
3277

    
3278
    l_wrap= s->b8_stride;
3279
    l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3280
    c_wrap= s->mb_stride;
3281
    c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3282

    
3283
#if 0
3284
    /* clean DC */
3285
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3286
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3287
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3288
#endif
3289

    
3290
    /* clean AC */
3291
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3292
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3293
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3294

    
3295
    /* clean MV */
3296
    // we can't clear the MVs as they might be needed by a b frame
3297
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3298
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3299
    s->last_mv[0][0][0]=
3300
    s->last_mv[0][0][1]=
3301
    s->last_mv[1][0][0]=
3302
    s->last_mv[1][0][1]= 0;
3303
}
3304

    
3305
/**
3306
 * decodes the group of blocks / video packet header.
3307
 * @return <0 if no resync found
3308
 */
3309
int ff_h263_resync(MpegEncContext *s){
3310
    int left, ret;
3311

    
3312
    if(s->codec_id==CODEC_ID_MPEG4){
3313
        skip_bits1(&s->gb);
3314
        align_get_bits(&s->gb);
3315
    }
3316

    
3317
    if(show_bits(&s->gb, 16)==0){
3318
        if(s->codec_id==CODEC_ID_MPEG4)
3319
            ret= mpeg4_decode_video_packet_header(s);
3320
        else
3321
            ret= h263_decode_gob_header(s);
3322
        if(ret>=0)
3323
            return 0;
3324
    }
3325
    //OK, it's not where it is supposed to be ...
3326
    s->gb= s->last_resync_gb;
3327
    align_get_bits(&s->gb);
3328
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3329

    
3330
    for(;left>16+1+5+5; left-=8){
3331
        if(show_bits(&s->gb, 16)==0){
3332
            GetBitContext bak= s->gb;
3333

    
3334
            if(s->codec_id==CODEC_ID_MPEG4)
3335
                ret= mpeg4_decode_video_packet_header(s);
3336
            else
3337
                ret= h263_decode_gob_header(s);
3338
            if(ret>=0)
3339
                return 0;
3340

    
3341
            s->gb= bak;
3342
        }
3343
        skip_bits(&s->gb, 8);
3344
    }
3345

    
3346
    return -1;
3347
}
3348

    
3349
/**
3350
 * gets the average motion vector for a GMC MB.
3351
 * @param n either 0 for the x component or 1 for y
3352
 * @returns the average MV for a GMC MB
3353
 */
3354
static inline int get_amv(MpegEncContext *s, int n){
3355
    int x, y, mb_v, sum, dx, dy, shift;
3356
    int len = 1 << (s->f_code + 4);
3357
    const int a= s->sprite_warping_accuracy;
3358

    
3359
    if(s->workaround_bugs & FF_BUG_AMV)
3360
        len >>= s->quarter_sample;
3361

    
3362
    if(s->real_sprite_warping_points==1){
3363
        if(s->divx_version==500 && s->divx_build==413)
3364
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3365
        else
3366
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3367
    }else{
3368
        dx= s->sprite_delta[n][0];
3369
        dy= s->sprite_delta[n][1];
3370
        shift= s->sprite_shift[0];
3371
        if(n) dy -= 1<<(shift + a + 1);
3372
        else  dx -= 1<<(shift + a + 1);
3373
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3374

    
3375
        sum=0;
3376
        for(y=0; y<16; y++){
3377
            int v;
3378

    
3379
            v= mb_v + dy*y;
3380
            //XXX FIXME optimize
3381
            for(x=0; x<16; x++){
3382
                sum+= v>>shift;
3383
                v+= dx;
3384
            }
3385
        }
3386
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3387
    }
3388

    
3389
    if      (sum < -len) sum= -len;
3390
    else if (sum >= len) sum= len-1;
3391

    
3392
    return sum;
3393
}
3394

    
3395
/**
3396
 * decodes first partition.
3397
 * @return number of MBs decoded or <0 if an error occured
3398
 */
3399
static int mpeg4_decode_partition_a(MpegEncContext *s){
3400
    int mb_num;
3401
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3402

    
3403
    /* decode first partition */
3404
    mb_num=0;
3405
    s->first_slice_line=1;
3406
    for(; s->mb_y<s->mb_height; s->mb_y++){
3407
        ff_init_block_index(s);
3408
        for(; s->mb_x<s->mb_width; s->mb_x++){
3409
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3410
            int cbpc;
3411
            int dir=0;
3412

    
3413
            mb_num++;
3414
            ff_update_block_index(s);
3415
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3416
                s->first_slice_line=0;
3417

    
3418
            if(s->pict_type==I_TYPE){
3419
                int i;
3420

    
3421
                do{
3422
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
3423
                        return mb_num-1;
3424
                    }
3425

    
3426
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3427
                    if (cbpc < 0){
3428
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3429
                        return -1;
3430
                    }
3431
                }while(cbpc == 8);
3432

    
3433
                s->cbp_table[xy]= cbpc & 3;
3434
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3435
                s->mb_intra = 1;
3436

    
3437
                if(cbpc & 4) {
3438
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3439
                }
3440
                s->current_picture.qscale_table[xy]= s->qscale;
3441

    
3442
                s->mbintra_table[xy]= 1;
3443
                for(i=0; i<6; i++){
3444
                    int dc_pred_dir;
3445
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3446
                    if(dc < 0){
3447
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3448
                        return -1;
3449
                    }
3450
                    dir<<=1;
3451
                    if(dc_pred_dir) dir|=1;
3452
                }
3453
                s->pred_dir_table[xy]= dir;
3454
            }else{ /* P/S_TYPE */
3455
                int mx, my, pred_x, pred_y, bits;
3456
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3457
                const int stride= s->b8_stride*2;
3458

    
3459
try_again:
3460
                bits= show_bits(&s->gb, 17);
3461
                if(bits==MOTION_MARKER){
3462
                    return mb_num-1;
3463
                }
3464
                skip_bits1(&s->gb);
3465
                if(bits&0x10000){
3466
                    /* skip mb */
3467
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3468
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3469
                        mx= get_amv(s, 0);
3470
                        my= get_amv(s, 1);
3471
                    }else{
3472
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3473
                        mx=my=0;
3474
                    }
3475
                    mot_val[0       ]= mot_val[2       ]=
3476
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3477
                    mot_val[1       ]= mot_val[3       ]=
3478
                    mot_val[1+stride]= mot_val[3+stride]= my;
3479

    
3480
                    if(s->mbintra_table[xy])
3481
                        ff_clean_intra_table_entries(s);
3482
                    continue;
3483
                }
3484

    
3485
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3486
                if (cbpc < 0){
3487
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3488
                    return -1;
3489
                }
3490
                if(cbpc == 20)
3491
                    goto try_again;
3492

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

    
3495
                s->mb_intra = ((cbpc & 4) != 0);
3496

    
3497
                if(s->mb_intra){
3498
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3499
                    s->mbintra_table[xy]= 1;
3500
                    mot_val[0       ]= mot_val[2       ]=
3501
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3502
                    mot_val[1       ]= mot_val[3       ]=
3503
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3504
                }else{
3505
                    if(s->mbintra_table[xy])
3506
                        ff_clean_intra_table_entries(s);
3507

    
3508
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3509
                        s->mcsel= get_bits1(&s->gb);
3510
                    else s->mcsel= 0;
3511

    
3512
                    if ((cbpc & 16) == 0) {
3513
                        /* 16x16 motion prediction */
3514

    
3515
                        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3516
                        if(!s->mcsel){
3517
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3518
                            if (mx >= 0xffff)
3519
                                return -1;
3520

    
3521
                            my = h263_decode_motion(s, pred_y, s->f_code);
3522
                            if (my >= 0xffff)
3523
                                return -1;
3524
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3525
                        } else {
3526
                            mx = get_amv(s, 0);
3527
                            my = get_amv(s, 1);
3528
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3529
                        }
3530

    
3531
                        mot_val[0       ]= mot_val[2       ] =
3532
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3533
                        mot_val[1       ]= mot_val[3       ]=
3534
                        mot_val[1+stride]= mot_val[3+stride]= my;
3535
                    } else {
3536
                        int i;
3537
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3538
                        for(i=0;i<4;i++) {
3539
                            int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3540
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3541
                            if (mx >= 0xffff)
3542
                                return -1;
3543

    
3544
                            my = h263_decode_motion(s, pred_y, s->f_code);
3545
                            if (my >= 0xffff)
3546
                                return -1;
3547
                            mot_val[0] = mx;
3548
                            mot_val[1] = my;
3549
                        }
3550
                    }
3551
                }
3552
            }
3553
        }
3554
        s->mb_x= 0;
3555
    }
3556

    
3557
    return mb_num;
3558
}
3559

    
3560
/**
3561
 * decode second partition.
3562
 * @return <0 if an error occured
3563
 */
3564
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3565
    int mb_num=0;
3566
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3567

    
3568
    s->mb_x= s->resync_mb_x;
3569
    s->first_slice_line=1;
3570
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3571
        ff_init_block_index(s);
3572
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3573
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3574

    
3575
            mb_num++;
3576
            ff_update_block_index(s);
3577
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3578
                s->first_slice_line=0;
3579

    
3580
            if(s->pict_type==I_TYPE){
3581
                int ac_pred= get_bits1(&s->gb);
3582
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3583
                if(cbpy<0){
3584
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3585
                    return -1;
3586
                }
3587

    
3588
                s->cbp_table[xy]|= cbpy<<2;
3589
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3590
            }else{ /* P || S_TYPE */
3591
                if(IS_INTRA(s->current_picture.mb_type[xy])){
3592
                    int dir=0,i;
3593
                    int ac_pred = get_bits1(&s->gb);
3594
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3595

    
3596
                    if(cbpy<0){
3597
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3598
                        return -1;
3599
                    }
3600

    
3601
                    if(s->cbp_table[xy] & 8) {
3602
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3603
                    }
3604
                    s->current_picture.qscale_table[xy]= s->qscale;
3605

    
3606
                    for(i=0; i<6; i++){
3607
                        int dc_pred_dir;
3608
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3609
                        if(dc < 0){
3610
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3611
                            return -1;
3612
                        }
3613
                        dir<<=1;
3614
                        if(dc_pred_dir) dir|=1;
3615
                    }
3616
                    s->cbp_table[xy]&= 3; //remove dquant
3617
                    s->cbp_table[xy]|= cbpy<<2;
3618
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3619
                    s->pred_dir_table[xy]= dir;
3620
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3621
                    s->current_picture.qscale_table[xy]= s->qscale;
3622
                    s->cbp_table[xy]= 0;
3623
                }else{
3624
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3625

    
3626
                    if(cbpy<0){
3627
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3628
                        return -1;
3629
                    }
3630

    
3631
                    if(s->cbp_table[xy] & 8) {
3632
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3633
                    }
3634
                    s->current_picture.qscale_table[xy]= s->qscale;
3635

    
3636
                    s->cbp_table[xy]&= 3; //remove dquant
3637
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3638
                }
3639
            }
3640
        }
3641
        if(mb_num >= mb_count) return 0;
3642
        s->mb_x= 0;
3643
    }
3644
    return 0;
3645
}
3646

    
3647
/**
3648
 * decodes the first & second partition
3649
 * @return <0 if error (and sets error type in the error_status_table)
3650
 */
3651
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3652
{
3653
    int mb_num;
3654
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3655
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3656

    
3657
    mb_num= mpeg4_decode_partition_a(s);
3658
    if(mb_num<0){
3659
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3660
        return -1;
3661
    }
3662

    
3663
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3664
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3665
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3666
        return -1;
3667
    }
3668

    
3669
    s->mb_num_left= mb_num;
3670

    
3671
    if(s->pict_type==I_TYPE){
3672
        while(show_bits(&s->gb, 9) == 1)
3673
            skip_bits(&s->gb, 9);
3674
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3675
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3676
            return -1;
3677
        }
3678
    }else{
3679
        while(show_bits(&s->gb, 10) == 1)
3680
            skip_bits(&s->gb, 10);
3681
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3682
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3683
            return -1;
3684
        }
3685
    }
3686
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3687

    
3688
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3689
        if(s->pict_type==P_TYPE)
3690
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3691
        return -1;
3692
    }else{
3693
        if(s->pict_type==P_TYPE)
3694
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3695
    }
3696

    
3697
    return 0;
3698
}
3699

    
3700
/**
3701
 * decode partition C of one MB.
3702
 * @return <0 if an error occured
3703
 */
3704
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3705
{
3706
    int cbp, mb_type;
3707
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3708

    
3709
    mb_type= s->current_picture.mb_type[xy];
3710
    cbp = s->cbp_table[xy];
3711

    
3712
    s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3713

    
3714
    if(s->current_picture.qscale_table[xy] != s->qscale){
3715
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3716
    }
3717

    
3718
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3719
        int i;
3720
        for(i=0; i<4; i++){
3721
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3722
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3723
        }
3724
        s->mb_intra = IS_INTRA(mb_type);
3725

    
3726
        if (IS_SKIP(mb_type)) {
3727
            /* skip mb */
3728
            for(i=0;i<6;i++)
3729
                s->block_last_index[i] = -1;
3730
            s->mv_dir = MV_DIR_FORWARD;
3731
            s->mv_type = MV_TYPE_16X16;
3732
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3733
                s->mcsel=1;
3734
                s->mb_skipped = 0;
3735
            }else{
3736
                s->mcsel=0;
3737
                s->mb_skipped = 1;
3738
            }
3739
        }else if(s->mb_intra){
3740
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3741
        }else if(!s->mb_intra){
3742
//            s->mcsel= 0; //FIXME do we need to init that
3743

    
3744
            s->mv_dir = MV_DIR_FORWARD;
3745
            if (IS_8X8(mb_type)) {
3746
                s->mv_type = MV_TYPE_8X8;
3747
            } else {
3748
                s->mv_type = MV_TYPE_16X16;
3749
            }
3750
        }
3751
    } else { /* I-Frame */
3752
        s->mb_intra = 1;
3753
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3754
    }
3755

    
3756
    if (!IS_SKIP(mb_type)) {
3757
        int i;
3758
        s->dsp.clear_blocks(s->block[0]);
3759
        /* decode each block */
3760
        for (i = 0; i < 6; i++) {
3761
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3762
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3763
                return -1;
3764
            }
3765
            cbp+=cbp;
3766
        }
3767
    }
3768

    
3769
    /* per-MB end of slice check */
3770

    
3771
    if(--s->mb_num_left <= 0){
3772
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3773
        if(mpeg4_is_resync(s))
3774
            return SLICE_END;
3775
        else
3776
            return SLICE_NOEND;
3777
    }else{
3778
        if(mpeg4_is_resync(s)){
3779
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3780
            if(s->cbp_table[xy+delta])
3781
                return SLICE_END;
3782
        }
3783
        return SLICE_OK;
3784
    }
3785
}
3786

    
3787
/**
3788
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3789
 */
3790
static void preview_obmc(MpegEncContext *s){
3791
    GetBitContext gb= s->gb;
3792

    
3793
    int cbpc, i, pred_x, pred_y, mx, my;
3794
    int16_t *mot_val;
3795
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3796
    const int stride= s->b8_stride*2;
3797

    
3798
    for(i=0; i<4; i++)
3799
        s->block_index[i]+= 2;
3800
    for(i=4; i<6; i++)
3801
        s->block_index[i]+= 1;
3802
    s->mb_x++;
3803

    
3804
    assert(s->pict_type == P_TYPE);
3805

    
3806
    do{
3807
        if (get_bits1(&s->gb)) {
3808
            /* skip mb */
3809
            mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3810
            mot_val[0       ]= mot_val[2       ]=
3811
            mot_val[0+stride]= mot_val[2+stride]= 0;
3812
            mot_val[1       ]= mot_val[3       ]=
3813
            mot_val[1+stride]= mot_val[3+stride]= 0;
3814

    
3815
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3816
            goto end;
3817
        }
3818
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3819
    }while(cbpc == 20);
3820

    
3821
    if(cbpc & 4){
3822
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3823
    }else{
3824
        get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3825
        if (cbpc & 8) {
3826
            if(s->modified_quant){
3827
                if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3828
                else                  skip_bits(&s->gb, 5);
3829
            }else
3830
                skip_bits(&s->gb, 2);
3831
        }
3832

    
3833
        if ((cbpc & 16) == 0) {
3834
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3835
                /* 16x16 motion prediction */
3836
                mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3837
                if (s->umvplus)
3838
                   mx = h263p_decode_umotion(s, pred_x);
3839
                else
3840
                   mx = h263_decode_motion(s, pred_x, 1);
3841

    
3842
                if (s->umvplus)
3843
                   my = h263p_decode_umotion(s, pred_y);
3844
                else
3845
                   my = h263_decode_motion(s, pred_y, 1);
3846

    
3847
                mot_val[0       ]= mot_val[2       ]=
3848
                mot_val[0+stride]= mot_val[2+stride]= mx;
3849
                mot_val[1       ]= mot_val[3       ]=
3850
                mot_val[1+stride]= mot_val[3+stride]= my;
3851
        } else {
3852
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3853
            for(i=0;i<4;i++) {
3854
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3855
                if (s->umvplus)
3856
                  mx = h263p_decode_umotion(s, pred_x);
3857
                else
3858
                  mx = h263_decode_motion(s, pred_x, 1);
3859

    
3860
                if (s->umvplus)
3861
                  my = h263p_decode_umotion(s, pred_y);
3862
                else
3863
                  my = h263_decode_motion(s, pred_y, 1);
3864
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3865
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3866
                mot_val[0] = mx;
3867
                mot_val[1] = my;
3868
            }
3869
        }
3870
    }
3871
end:
3872

    
3873
    for(i=0; i<4; i++)
3874
        s->block_index[i]-= 2;
3875
    for(i=4; i<6; i++)
3876
        s->block_index[i]-= 1;
3877
    s->mb_x--;
3878

    
3879
    s->gb= gb;
3880
}
3881

    
3882
static void h263_decode_dquant(MpegEncContext *s){
3883
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3884

    
3885
    if(s->modified_quant){
3886
        if(get_bits1(&s->gb))
3887
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3888
        else
3889
            s->qscale= get_bits(&s->gb, 5);
3890
    }else
3891
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3892
    ff_set_qscale(s, s->qscale);
3893
}
3894

    
3895
int ff_h263_decode_mb(MpegEncContext *s,
3896
                      DCTELEM block[6][64])
3897
{
3898
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3899
    int16_t *mot_val;
3900
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3901

    
3902
    assert(!s->h263_pred);
3903

    
3904
    if (s->pict_type == P_TYPE) {
3905
        do{
3906
            if (get_bits1(&s->gb)) {
3907
                /* skip mb */
3908
                s->mb_intra = 0;
3909
                for(i=0;i<6;i++)
3910
                    s->block_last_index[i] = -1;
3911
                s->mv_dir = MV_DIR_FORWARD;
3912
                s->mv_type = MV_TYPE_16X16;
3913
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3914
                s->mv[0][0][0] = 0;
3915
                s->mv[0][0][1] = 0;
3916
                s->mb_skipped = !(s->obmc | s->loop_filter);
3917
                goto end;
3918
            }
3919
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3920
            //fprintf(stderr, "\tCBPC: %d", cbpc);
3921
            if (cbpc < 0){
3922
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3923
                return -1;
3924
            }
3925
        }while(cbpc == 20);
3926

    
3927
        s->dsp.clear_blocks(s->block[0]);
3928

    
3929
        dquant = cbpc & 8;
3930
        s->mb_intra = ((cbpc & 4) != 0);
3931
        if (s->mb_intra) goto intra;
3932

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

    
3935
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3936
            cbpy ^= 0xF;
3937

    
3938
        cbp = (cbpc & 3) | (cbpy << 2);
3939
        if (dquant) {
3940
            h263_decode_dquant(s);
3941
        }
3942

    
3943
        s->mv_dir = MV_DIR_FORWARD;
3944
        if ((cbpc & 16) == 0) {
3945
            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3946
            /* 16x16 motion prediction */
3947
            s->mv_type = MV_TYPE_16X16;
3948
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3949
            if (s->umvplus)
3950
               mx = h263p_decode_umotion(s, pred_x);
3951
            else
3952
               mx = h263_decode_motion(s, pred_x, 1);
3953

    
3954
            if (mx >= 0xffff)
3955
                return -1;
3956

    
3957
            if (s->umvplus)
3958
               my = h263p_decode_umotion(s, pred_y);
3959
            else
3960
               my = h263_decode_motion(s, pred_y, 1);
3961

    
3962
            if (my >= 0xffff)
3963
                return -1;
3964
            s->mv[0][0][0] = mx;
3965
            s->mv[0][0][1] = my;
3966

    
3967
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3968
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3969
        } else {
3970
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3971
            s->mv_type = MV_TYPE_8X8;
3972
            for(i=0;i<4;i++) {
3973
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3974
                if (s->umvplus)
3975
                  mx = h263p_decode_umotion(s, pred_x);
3976
                else
3977
                  mx = h263_decode_motion(s, pred_x, 1);
3978
                if (mx >= 0xffff)
3979
                    return -1;
3980

    
3981
                if (s->umvplus)
3982
                  my = h263p_decode_umotion(s, pred_y);
3983
                else
3984
                  my = h263_decode_motion(s, pred_y, 1);
3985
                if (my >= 0xffff)
3986
                    return -1;
3987
                s->mv[0][i][0] = mx;
3988
                s->mv[0][i][1] = my;
3989
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3990
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3991
                mot_val[0] = mx;
3992
                mot_val[1] = my;
3993
            }
3994
        }
3995

    
3996
        /* decode each block */
3997
        for (i = 0; i < 6; i++) {
3998
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3999
                return -1;
4000
            cbp+=cbp;
4001
        }
4002

    
4003
        if(s->obmc){
4004
            if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4005
                preview_obmc(s);
4006
        }
4007
    } else if(s->pict_type==B_TYPE) {
4008
        int mb_type;
4009
        const int stride= s->b8_stride;
4010
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4011
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4012
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4013

    
4014
        //FIXME ugly
4015
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4016
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4017
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4018
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4019

    
4020
        do{
4021
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4022
            if (mb_type < 0){
4023
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4024
                return -1;
4025
            }
4026

    
4027
            mb_type= h263_mb_type_b_map[ mb_type ];
4028
        }while(!mb_type);
4029

    
4030
        s->mb_intra = IS_INTRA(mb_type);
4031
        if(HAS_CBP(mb_type)){
4032
            s->dsp.clear_blocks(s->block[0]);
4033
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4034
            if(s->mb_intra){
4035
                dquant = IS_QUANT(mb_type);
4036
                goto intra;
4037
            }
4038

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

    
4041
            if (cbpy < 0){
4042
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4043
                return -1;
4044
            }
4045

    
4046
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4047
                cbpy ^= 0xF;
4048

    
4049
            cbp = (cbpc & 3) | (cbpy << 2);
4050
        }else
4051
            cbp=0;
4052

    
4053
        assert(!s->mb_intra);
4054

    
4055
        if(IS_QUANT(mb_type)){
4056
            h263_decode_dquant(s);
4057
        }
4058

    
4059
        if(IS_DIRECT(mb_type)){
4060
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4061
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4062
        }else{
4063
            s->mv_dir = 0;
4064
            s->mv_type= MV_TYPE_16X16;
4065
//FIXME UMV
4066

    
4067
            if(USES_LIST(mb_type, 0)){
4068
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4069
                s->mv_dir = MV_DIR_FORWARD;
4070

    
4071
                mx = h263_decode_motion(s, mx, 1);
4072
                my = h263_decode_motion(s, my, 1);
4073

    
4074
                s->mv[0][0][0] = mx;
4075
                s->mv[0][0][1] = my;
4076
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4077
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4078
            }
4079

    
4080
            if(USES_LIST(mb_type, 1)){
4081
                int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4082
                s->mv_dir |= MV_DIR_BACKWARD;
4083

    
4084
                mx = h263_decode_motion(s, mx, 1);
4085
                my = h263_decode_motion(s, my, 1);
4086

    
4087
                s->mv[1][0][0] = mx;
4088
                s->mv[1][0][1] = my;
4089
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4090
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4091
            }
4092
        }
4093

    
4094
        s->current_picture.mb_type[xy]= mb_type;
4095

    
4096
        /* decode each block */
4097
        for (i = 0; i < 6; i++) {
4098
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4099
                return -1;
4100
            cbp+=cbp;
4101
        }
4102
    } else { /* I-Frame */
4103
        do{
4104
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4105
            if (cbpc < 0){
4106
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4107
                return -1;
4108
            }
4109
        }while(cbpc == 8);
4110

    
4111
        s->dsp.clear_blocks(s->block[0]);
4112

    
4113
        dquant = cbpc & 4;
4114
        s->mb_intra = 1;
4115
intra:
4116
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4117
        if (s->h263_aic) {
4118
            s->ac_pred = get_bits1(&s->gb);
4119
            if(s->ac_pred){
4120
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4121

    
4122
                s->h263_aic_dir = get_bits1(&s->gb);
4123
            }
4124
        }else
4125
            s->ac_pred = 0;
4126

    
4127
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4128
        if(cbpy<0){
4129
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4130
            return -1;
4131
        }
4132
        cbp = (cbpc & 3) | (cbpy << 2);
4133
        if (dquant) {
4134
            h263_decode_dquant(s);
4135
        }
4136

    
4137
        /* decode each block */
4138
        for (i = 0; i < 6; i++) {
4139
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4140
                return -1;
4141
            cbp+=cbp;
4142
        }
4143
    }
4144
end:
4145

    
4146
        /* per-MB end of slice check */
4147
    {
4148
        int v= show_bits(&s->gb, 16);
4149

    
4150
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4151
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4152
        }
4153

    
4154
        if(v==0)
4155
            return SLICE_END;
4156
    }
4157

    
4158
    return SLICE_OK;
4159
}
4160

    
4161
int ff_mpeg4_decode_mb(MpegEncContext *s,
4162
                      DCTELEM block[6][64])
4163
{
4164
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4165
    int16_t *mot_val;
4166
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4167
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4168

    
4169
    assert(s->h263_pred);
4170

    
4171
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4172
        do{
4173
            if (get_bits1(&s->gb)) {
4174
                /* skip mb */
4175
                s->mb_intra = 0;
4176
                for(i=0;i<6;i++)
4177
                    s->block_last_index[i] = -1;
4178
                s->mv_dir = MV_DIR_FORWARD;
4179
                s->mv_type = MV_TYPE_16X16;
4180
                if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4181
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4182
                    s->mcsel=1;
4183
                    s->mv[0][0][0]= get_amv(s, 0);
4184
                    s->mv[0][0][1]= get_amv(s, 1);
4185

    
4186
                    s->mb_skipped = 0;
4187
                }else{
4188
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4189
                    s->mcsel=0;
4190
                    s->mv[0][0][0] = 0;
4191
                    s->mv[0][0][1] = 0;
4192
                    s->mb_skipped = 1;
4193
                }
4194
                goto end;
4195
            }
4196
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4197
            //fprintf(stderr, "\tCBPC: %d", cbpc);
4198
            if (cbpc < 0){
4199
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4200
                return -1;
4201
            }
4202
        }while(cbpc == 20);
4203

    
4204
        s->dsp.clear_blocks(s->block[0]);
4205
        dquant = cbpc & 8;
4206
        s->mb_intra = ((cbpc & 4) != 0);
4207
        if (s->mb_intra) goto intra;
4208

    
4209
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4210
            s->mcsel= get_bits1(&s->gb);
4211
        else s->mcsel= 0;
4212
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4213

    
4214
        cbp = (cbpc & 3) | (cbpy << 2);
4215
        if (dquant) {
4216
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4217
        }
4218
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4219
            s->interlaced_dct= get_bits1(&s->gb);
4220

    
4221
        s->mv_dir = MV_DIR_FORWARD;
4222
        if ((cbpc & 16) == 0) {
4223
            if(s->mcsel){
4224
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4225
                /* 16x16 global motion prediction */
4226
                s->mv_type = MV_TYPE_16X16;
4227
                mx= get_amv(s, 0);
4228
                my= get_amv(s, 1);
4229
                s->mv[0][0][0] = mx;
4230
                s->mv[0][0][1] = my;
4231
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4232
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4233
                /* 16x8 field motion prediction */
4234
                s->mv_type= MV_TYPE_FIELD;
4235

    
4236
                s->field_select[0][0]= get_bits1(&s->gb);
4237
                s->field_select[0][1]= get_bits1(&s->gb);
4238

    
4239
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4240

    
4241
                for(i=0; i<2; i++){
4242
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4243
                    if (mx >= 0xffff)
4244
                        return -1;
4245

    
4246
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4247
                    if (my >= 0xffff)
4248
                        return -1;
4249

    
4250
                    s->mv[0][i][0] = mx;
4251
                    s->mv[0][i][1] = my;
4252
                }
4253
            }else{
4254
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4255
                /* 16x16 motion prediction */
4256
                s->mv_type = MV_TYPE_16X16;
4257
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4258
                mx = h263_decode_motion(s, pred_x, s->f_code);
4259

    
4260
                if (mx >= 0xffff)
4261
                    return -1;
4262

    
4263
                my = h263_decode_motion(s, pred_y, s->f_code);
4264

    
4265
                if (my >= 0xffff)
4266
                    return -1;
4267
                s->mv[0][0][0] = mx;
4268
                s->mv[0][0][1] = my;
4269
            }
4270
        } else {
4271
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4272
            s->mv_type = MV_TYPE_8X8;
4273
            for(i=0;i<4;i++) {
4274
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4275
                mx = h263_decode_motion(s, pred_x, s->f_code);
4276
                if (mx >= 0xffff)
4277
                    return -1;
4278

    
4279
                my = h263_decode_motion(s, pred_y, s->f_code);
4280
                if (my >= 0xffff)
4281
                    return -1;
4282
                s->mv[0][i][0] = mx;
4283
                s->mv[0][i][1] = my;
4284
                mot_val[0] = mx;
4285
                mot_val[1] = my;
4286
            }
4287
        }
4288
    } else if(s->pict_type==B_TYPE) {
4289
        int modb1; // first bit of modb
4290
        int modb2; // second bit of modb
4291
        int mb_type;
4292

    
4293
        s->mb_intra = 0; //B-frames never contain intra blocks
4294
        s->mcsel=0;      //     ...               true gmc blocks
4295

    
4296
        if(s->mb_x==0){
4297
            for(i=0; i<2; i++){
4298
                s->last_mv[i][0][0]=
4299
                s->last_mv[i][0][1]=
4300
                s->last_mv[i][1][0]=
4301
                s->last_mv[i][1][1]= 0;
4302
            }
4303
        }
4304

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

    
4308
        if(s->mb_skipped){
4309
                /* skip mb */
4310
            for(i=0;i<6;i++)
4311
                s->block_last_index[i] = -1;
4312

    
4313
            s->mv_dir = MV_DIR_FORWARD;
4314
            s->mv_type = MV_TYPE_16X16;
4315
            s->mv[0][0][0] = 0;
4316
            s->mv[0][0][1] = 0;
4317
            s->mv[1][0][0] = 0;
4318
            s->mv[1][0][1] = 0;
4319
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4320
            goto end;
4321
        }
4322

    
4323
        modb1= get_bits1(&s->gb);
4324
        if(modb1){
4325
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4326
            cbp=0;
4327
        }else{
4328
            modb2= get_bits1(&s->gb);
4329
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4330
            if(mb_type<0){
4331
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4332
                return -1;
4333
            }
4334
            mb_type= mb_type_b_map[ mb_type ];
4335
            if(modb2) cbp= 0;
4336
            else{
4337
                s->dsp.clear_blocks(s->block[0]);
4338
                cbp= get_bits(&s->gb, 6);
4339
            }
4340

    
4341
            if ((!IS_DIRECT(mb_type)) && cbp) {
4342
                if(get_bits1(&s->gb)){
4343
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4344
                }
4345
            }
4346

    
4347
            if(!s->progressive_sequence){
4348
                if(cbp)
4349
                    s->interlaced_dct= get_bits1(&s->gb);
4350

    
4351
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4352
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4353
                    mb_type &= ~MB_TYPE_16x16;
4354

    
4355
                    if(USES_LIST(mb_type, 0)){
4356
                        s->field_select[0][0]= get_bits1(&s->gb);
4357
                        s->field_select[0][1]= get_bits1(&s->gb);
4358
                    }
4359
                    if(USES_LIST(mb_type, 1)){
4360
                        s->field_select[1][0]= get_bits1(&s->gb);
4361
                        s->field_select[1][1]= get_bits1(&s->gb);
4362
                    }
4363
                }
4364
            }
4365

    
4366
            s->mv_dir = 0;
4367
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4368
                s->mv_type= MV_TYPE_16X16;
4369

    
4370
                if(USES_LIST(mb_type, 0)){
4371
                    s->mv_dir = MV_DIR_FORWARD;
4372

    
4373
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4374
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4375
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4376
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4377
                }
4378

    
4379
                if(USES_LIST(mb_type, 1)){
4380
                    s->mv_dir |= MV_DIR_BACKWARD;
4381

    
4382
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4383
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4384
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4385
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4386
                }
4387
            }else if(!IS_DIRECT(mb_type)){
4388
                s->mv_type= MV_TYPE_FIELD;
4389

    
4390
                if(USES_LIST(mb_type, 0)){
4391
                    s->mv_dir = MV_DIR_FORWARD;
4392

    
4393
                    for(i=0; i<2; i++){
4394
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4395
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4396
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4397
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4398
                    }
4399
                }
4400

    
4401
                if(USES_LIST(mb_type, 1)){
4402
                    s->mv_dir |= MV_DIR_BACKWARD;
4403

    
4404
                    for(i=0; i<2; i++){
4405
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4406
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4407
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4408
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4409
                    }
4410
                }
4411
            }
4412
        }
4413

    
4414
        if(IS_DIRECT(mb_type)){
4415
            if(IS_SKIP(mb_type))
4416
                mx=my=0;
4417
            else{
4418
                mx = h263_decode_motion(s, 0, 1);
4419
                my = h263_decode_motion(s, 0, 1);
4420
            }
4421

    
4422
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4423
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4424
        }
4425
        s->current_picture.mb_type[xy]= mb_type;
4426
    } else { /* I-Frame */
4427
        do{
4428
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4429
            if (cbpc < 0){
4430
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4431
                return -1;
4432
            }
4433
        }while(cbpc == 8);
4434

    
4435
        dquant = cbpc & 4;
4436
        s->mb_intra = 1;
4437
intra:
4438
        s->ac_pred = get_bits1(&s->gb);
4439
        if(s->ac_pred)
4440
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4441
        else
4442
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4443

    
4444
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4445
        if(cbpy<0){
4446
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4447
            return -1;
4448
        }
4449
        cbp = (cbpc & 3) | (cbpy << 2);
4450

    
4451
        s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4452

    
4453
        if (dquant) {
4454
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4455
        }
4456

    
4457
        if(!s->progressive_sequence)
4458
            s->interlaced_dct= get_bits1(&s->gb);
4459

    
4460
        s->dsp.clear_blocks(s->block[0]);
4461
        /* decode each block */
4462
        for (i = 0; i < 6; i++) {
4463
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4464
                return -1;
4465
            cbp+=cbp;
4466
        }
4467
        goto end;
4468
    }
4469

    
4470
    /* decode each block */
4471
    for (i = 0; i < 6; i++) {
4472
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4473
            return -1;
4474
        cbp+=cbp;
4475
    }
4476
end:
4477

    
4478
        /* per-MB end of slice check */
4479
    if(s->codec_id==CODEC_ID_MPEG4){
4480
        if(mpeg4_is_resync(s)){
4481
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4482
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4483
                return SLICE_OK;
4484
            return SLICE_END;
4485
        }
4486
    }
4487

    
4488
    return SLICE_OK;
4489
}
4490

    
4491
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4492
{
4493
    int code, val, sign, shift, l;
4494
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4495

    
4496
    if (code == 0)
4497
        return pred;
4498
    if (code < 0)
4499
        return 0xffff;
4500

    
4501
    sign = get_bits1(&s->gb);
4502
    shift = f_code - 1;
4503
    val = code;
4504
    if (shift) {
4505
        val = (val - 1) << shift;
4506
        val |= get_bits(&s->gb, shift);
4507
        val++;
4508
    }
4509
    if (sign)
4510
        val = -val;
4511
    val += pred;
4512

    
4513
    /* modulo decoding */
4514
    if (!s->h263_long_vectors) {
4515
        l = INT_BIT - 5 - f_code;
4516
        val = (val<<l)>>l;
4517
    } else {
4518
        /* horrible h263 long vector mode */
4519
        if (pred < -31 && val < -63)
4520
            val += 64;
4521
        if (pred > 32 && val > 63)
4522
            val -= 64;
4523

    
4524
    }
4525
    return val;
4526
}
4527

    
4528
/* Decodes RVLC of H.263+ UMV */
4529
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4530
{
4531
   int code = 0, sign;
4532

    
4533
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4534
      return pred;
4535

    
4536
   code = 2 + get_bits1(&s->gb);
4537

    
4538
   while (get_bits1(&s->gb))
4539
   {
4540
      code <<= 1;
4541
      code += get_bits1(&s->gb);
4542
   }
4543
   sign = code & 1;
4544
   code >>= 1;
4545

    
4546
   code = (sign) ? (pred - code) : (pred + code);
4547
#ifdef DEBUG
4548
   av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4549
#endif
4550
   return code;
4551

    
4552
}
4553

    
4554
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4555
                             int n, int coded)
4556
{
4557
    int code, level, i, j, last, run;
4558
    RLTable *rl = &rl_inter;
4559
    const uint8_t *scan_table;
4560
    GetBitContext gb= s->gb;
4561

    
4562
    scan_table = s->intra_scantable.permutated;
4563
    if (s->h263_aic && s->mb_intra) {
4564
        rl = &rl_intra_aic;
4565
        i = 0;
4566
        if (s->ac_pred) {
4567
            if (s->h263_aic_dir)
4568
                scan_table = s->intra_v_scantable.permutated; /* left */
4569
            else
4570
                scan_table = s->intra_h_scantable.permutated; /* top */
4571
        }
4572
    } else if (s->mb_intra) {
4573
        /* DC coef */
4574
        if(s->codec_id == CODEC_ID_RV10){
4575
#ifdef CONFIG_RV10_DECODER
4576
          if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4577
            int component, diff;
4578
            component = (n <= 3 ? 0 : n - 4 + 1);
4579
            level = s->last_dc[component];
4580
            if (s->rv10_first_dc_coded[component]) {
4581
                diff = rv_decode_dc(s, n);
4582
                if (diff == 0xffff)
4583
                    return -1;
4584
                level += diff;
4585
                level = level & 0xff; /* handle wrap round */
4586
                s->last_dc[component] = level;
4587
            } else {
4588
                s->rv10_first_dc_coded[component] = 1;
4589
            }
4590
          } else {
4591
                level = get_bits(&s->gb, 8);
4592
                if (level == 255)
4593
                    level = 128;
4594
          }
4595
#endif
4596
        }else{
4597
            level = get_bits(&s->gb, 8);
4598
            if((level&0x7F) == 0){
4599
                av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4600
                if(s->error_resilience >= FF_ER_COMPLIANT)
4601
                    return -1;
4602
            }
4603
            if (level == 255)
4604
                level = 128;
4605
        }
4606
        block[0] = level;
4607
        i = 1;
4608
    } else {
4609
        i = 0;
4610
    }
4611
    if (!coded) {
4612
        if (s->mb_intra && s->h263_aic)
4613
            goto not_coded;
4614
        s->block_last_index[n] = i - 1;
4615
        return 0;
4616
    }
4617
retry:
4618
    for(;;) {
4619
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4620
        if (code < 0){
4621
            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4622
            return -1;
4623
        }
4624
        if (code == rl->n) {
4625
            /* escape */
4626
            if (s->h263_flv > 1) {
4627
                int is11 = get_bits1(&s->gb);
4628
                last = get_bits1(&s->gb);
4629
                run = get_bits(&s->gb, 6);
4630
                if(is11){
4631
                    level = get_sbits(&s->gb, 11);
4632
                } else {
4633
                    level = get_sbits(&s->gb, 7);
4634
                }
4635
            } else {
4636
                last = get_bits1(&s->gb);
4637
                run = get_bits(&s->gb, 6);
4638
                level = (int8_t)get_bits(&s->gb, 8);
4639
                if(level == -128){
4640
                    if (s->codec_id == CODEC_ID_RV10) {
4641
                        /* XXX: should patch encoder too */
4642
                        level = get_sbits(&s->gb, 12);
4643
                    }else{
4644
                        level = get_bits(&s->gb, 5);
4645
                        level |= get_sbits(&s->gb, 6)<<5;
4646
                    }
4647
                }
4648
            }
4649
        } else {
4650
            run = rl->table_run[code];
4651
            level = rl->table_level[code];
4652
            last = code >= rl->last;
4653
            if (get_bits1(&s->gb))
4654
                level = -level;
4655
        }
4656
        i += run;
4657
        if (i >= 64){
4658
            if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4659
                //Looks like a hack but no, it's the way it is supposed to work ...
4660
                rl = &rl_intra_aic;
4661
                i = 0;
4662
                s->gb= gb;
4663
                memset(block, 0, sizeof(DCTELEM)*64);
4664
                goto retry;
4665
            }
4666
            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4667
            return -1;
4668
        }
4669
        j = scan_table[i];
4670
        block[j] = level;
4671
        if (last)
4672
            break;
4673
        i++;
4674
    }
4675
not_coded:
4676
    if (s->mb_intra && s->h263_aic) {
4677
        h263_pred_acdc(s, block, n);
4678
        i = 63;
4679
    }
4680
    s->block_last_index[n] = i;
4681
    return 0;
4682
}
4683

    
4684
/**
4685
 * decodes the dc value.
4686
 * @param n block index (0-3 are luma, 4-5 are chroma)
4687
 * @param dir_ptr the prediction direction will be stored here
4688
 * @return the quantized dc
4689
 */
4690
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4691
{
4692
    int level, code;
4693

    
4694
    if (n < 4)
4695
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4696
    else
4697
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4698
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4699
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4700
        return -1;
4701
    }
4702
    if (code == 0) {
4703
        level = 0;
4704
    } else {
4705
        if(IS_3IV1){
4706
            if(code==1)
4707
                level= 2*get_bits1(&s->gb)-1;
4708
            else{
4709
                if(get_bits1(&s->gb))
4710
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4711
                else
4712
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4713
            }
4714
        }else{
4715
            level = get_xbits(&s->gb, code);
4716
        }
4717

    
4718
        if (code > 8){
4719
            if(get_bits1(&s->gb)==0){ /* marker */
4720
                if(s->error_resilience>=2){
4721
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4722
                    return -1;
4723
                }
4724
            }
4725
        }
4726
    }
4727

    
4728
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4729
}
4730

    
4731
/**
4732
 * decodes a block.
4733
 * @return <0 if an error occured
4734
 */
4735
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4736
                              int n, int coded, int intra, int rvlc)
4737
{
4738
    int level, i, last, run;
4739
    int dc_pred_dir;
4740
    RLTable * rl;
4741
    RL_VLC_ELEM * rl_vlc;
4742
    const uint8_t * scan_table;
4743
    int qmul, qadd;
4744

    
4745
    //Note intra & rvlc should be optimized away if this is inlined
4746

    
4747
    if(intra) {
4748
      if(s->use_intra_dc_vlc){
4749
        /* DC coef */
4750
        if(s->partitioned_frame){
4751
            level = s->dc_val[0][ s->block_index[n] ];
4752
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4753
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4754
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4755
        }else{
4756
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4757
            if (level < 0)
4758
                return -1;
4759
        }
4760
        block[0] = level;
4761
        i = 0;
4762
      }else{
4763
            i = -1;
4764
            ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4765
      }
4766
        if (!coded)
4767
            goto not_coded;
4768

    
4769
        if(rvlc){
4770
            rl = &rvlc_rl_intra;
4771
            rl_vlc = rvlc_rl_intra.rl_vlc[0];
4772
        }else{
4773
            rl = &rl_intra;
4774
            rl_vlc = rl_intra.rl_vlc[0];
4775
        }
4776
        if (s->ac_pred) {
4777
            if (dc_pred_dir == 0)
4778
                scan_table = s->intra_v_scantable.permutated; /* left */
4779
            else
4780