Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 199436b9

History | View | Annotate | Download (214 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
#include "mathops.h"
43

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

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

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

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

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

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

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

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

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

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

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

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

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

    
142
static void show_pict_info(MpegEncContext *s){
143
    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",
144
         s->qscale, av_get_pict_type_char(s->pict_type),
145
         s->gb.size_in_bits, 1-s->no_rounding,
146
         s->obmc ? " AP" : "",
147
         s->umvplus ? " UMV" : "",
148
         s->h263_long_vectors ? " LONG" : "",
149
         s->h263_plus ? " +" : "",
150
         s->h263_aic ? " AIC" : "",
151
         s->alt_inter_vlc ? " AIV" : "",
152
         s->modified_quant ? " MQ" : "",
153
         s->loop_filter ? " LOOP" : "",
154
         s->h263_slice_structured ? " SS" : "",
155
         s->avctx->time_base.den, s->avctx->time_base.num
156
    );
157
}
158

    
159
#if CONFIG_ENCODERS
160

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

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

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

    
173
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
174
}
175

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

    
180
      align_put_bits(&s->pb);
181

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

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

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

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

    
246
    align_put_bits(&s->pb);
247

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

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

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

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

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

    
301
        put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE);
302

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

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

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

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

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

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

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

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

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

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

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

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

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

    
374
        ff_h263_encode_mba(s);
375

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

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

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

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

    
407
            last= j;
408
        }
409
    }
410

    
411
    return rate;
412
}
413

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

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

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

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

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

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

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

    
482
    return score < 0;
483
}
484

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

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

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

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

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

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

    
529
    ff_init_qscale_tab(s);
530

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

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

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

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

    
558
    ff_clean_h263_qscales(s);
559

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

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

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

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

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

    
589
#endif //CONFIG_ENCODERS
590

    
591
#define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0]))
592
#define tab_bias (tab_size/2)
593

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

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

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

    
630
#undef tab_size
631
#undef tab_bias
632

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

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

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

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

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

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

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

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

    
740
#if CONFIG_ENCODERS
741

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

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

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

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

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

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

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

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

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

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

    
811
        for (i = 0; i < 6; i++) {
812
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
813
                s->block_last_index[i]= -1;
814
                s->dsp.clear_block(s->block[i]);
815
            }
816
        }
817
    }else{
818
        cbp= 0;
819
        for (i = 0; i < 6; i++) {
820
            if (s->block_last_index[i] >= 0)
821
                cbp |= 1 << (5 - i);
822
        }
823
    }
824
    return cbp;
825
}
826

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

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

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

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

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

    
854
        for (i = 0; i < 6; i++) {
855
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
856
                s->block_last_index[i]= -1;
857
                s->dsp.clear_block(s->block[i]);
858
            }
859
        }
860
    }else{
861
        for (i = 0; i < 6; i++) {
862
            if (s->block_last_index[i] >= 0)
863
                cbp |= 1 << (5 - i);
864
        }
865
    }
866
    return cbp;
867
}
868

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

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

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

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

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

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

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

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

    
941
                return;
942
            }
943

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1071
                        if(pic==NULL || pic->pict_type!=FF_B_TYPE) break;
1072

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

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

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

    
1095
                    return;
1096
                }
1097
            }
1098

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1451
        }
1452
    }
1453

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

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

    
1475
//    if(s->pict_type==FF_B_TYPE && !s->readable) return;
1476

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

    
1488
    if(s->mb_y){
1489
        int qp_dt, qp_tt, qp_tc;
1490

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

    
1496
        if(qp_c)
1497
            qp_tc= qp_c;
1498
        else
1499
            qp_tc= qp_tt;
1500

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1857
static void init_uni_dc_tab(void)
1858
{
1859
    int level, uni_code, uni_len;
1860

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

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

    
1876
        /* luminance */
1877
        uni_code= DCtab_lum[size][0];
1878
        uni_len = DCtab_lum[size][1];
1879

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

    
1891
        /* chrominance */
1892
        uni_code= DCtab_chrom[size][0];
1893
        uni_len = DCtab_chrom[size][1];
1894

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

    
1906
    }
1907
}
1908

    
1909
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1910
    int slevel, run, last;
1911

    
1912
    assert(MAX_LEVEL >= 64);
1913
    assert(MAX_RUN   >= 63);
1914

    
1915
    for(slevel=-64; slevel<64; slevel++){
1916
        if(slevel==0) continue;
1917
        for(run=0; run<64; run++){
1918
            for(last=0; last<=1; last++){
1919
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1920
                int level= slevel < 0 ? -slevel : slevel;
1921
                int sign= slevel < 0 ? 1 : 0;
1922
                int bits, len, code;
1923
                int level1, run1;
1924

    
1925
                len_tab[index]= 100;
1926

    
1927
                /* ESC0 */
1928
                code= get_rl_index(rl, last, run, level);
1929
                bits= rl->table_vlc[code][0];
1930
                len=  rl->table_vlc[code][1];
1931
                bits=bits*2+sign; len++;
1932

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

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

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

    
1985
                if(len < len_tab[index]){
1986
                    bits_tab[index]= bits;
1987
                    len_tab [index]= len;
1988
                }
1989
            }
1990
        }
1991
    }
1992
}
1993

    
1994
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1995
    int slevel, run, last;
1996

    
1997
    assert(MAX_LEVEL >= 64);
1998
    assert(MAX_RUN   >= 63);
1999

    
2000
    for(slevel=-64; slevel<64; slevel++){
2001
        if(slevel==0) continue;
2002
        for(run=0; run<64; run++){
2003
            for(last=0; last<=1; last++){
2004
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
2005
                int level= slevel < 0 ? -slevel : slevel;
2006
                int sign= slevel < 0 ? 1 : 0;
2007
                int bits, len, code;
2008

    
2009
                len_tab[index]= 100;
2010

    
2011
                /* ESC0 */
2012
                code= get_rl_index(rl, last, run, level);
2013
                bits= rl->table_vlc[code][0];
2014
                len=  rl->table_vlc[code][1];
2015
                bits=bits*2+sign; len++;
2016

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

    
2028
                if(len < len_tab[index]){
2029
                    if(bits_tab) bits_tab[index]= bits;
2030
                    len_tab [index]= len;
2031
                }
2032
            }
2033
        }
2034
    }
2035
}
2036

    
2037
void h263_encode_init(MpegEncContext *s)
2038
{
2039
    static int done = 0;
2040

    
2041
    if (!done) {
2042
        done = 1;
2043

    
2044
        init_uni_dc_tab();
2045

    
2046
        init_rl(&rl_inter, static_rl_table_store[0]);
2047
        init_rl(&rl_intra, static_rl_table_store[1]);
2048
        init_rl(&rl_intra_aic, static_rl_table_store[2]);
2049

    
2050
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2051
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2052

    
2053
        init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2054
        init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
2055

    
2056
        init_mv_penalty_and_fcode(s);
2057
    }
2058
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2059

    
2060
    s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
2061
    s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2062
    if(s->h263_aic){
2063
        s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
2064
        s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2065
    }
2066
    s->ac_esc_length= 7+1+6+8;
2067

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

    
2084
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2085

    
2086
            s->avctx->extradata= av_malloc(1024);
2087
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
2088

    
2089
            if(!(s->workaround_bugs & FF_BUG_MS))
2090
                mpeg4_encode_visual_object_header(s);
2091
            mpeg4_encode_vol_header(s, 0, 0);
2092

    
2093
//            ff_mpeg4_stuffing(&s->pb); ?
2094
            flush_put_bits(&s->pb);
2095
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2096
        }
2097

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

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

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

    
2164
        if(s->alt_inter_vlc && !s->mb_intra){
2165
            int aic_vlc_bits=0;
2166
            int inter_vlc_bits=0;
2167
            int wrong_pos=-1;
2168
            int aic_code;
2169

    
2170
            last_index = s->block_last_index[n];
2171
            last_non_zero = i - 1;
2172
            for (; i <= last_index; i++) {
2173
                j = s->intra_scantable.permutated[i];
2174
                level = block[j];
2175
                if (level) {
2176
                    run = i - last_non_zero - 1;
2177
                    last = (i == last_index);
2178

    
2179
                    if(level<0) level= -level;
2180

    
2181
                    code = get_rl_index(rl, last, run, level);
2182
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2183
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2184
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2185

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

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

    
2225
                assert(slevel != 0);
2226

    
2227
                if(level < 128)
2228
                    put_sbits(&s->pb, 8, slevel);
2229
                else{
2230
                    put_bits(&s->pb, 8, 128);
2231
                    put_sbits(&s->pb, 5, slevel);
2232
                    put_sbits(&s->pb, 6, slevel>>5);
2233
                }
2234
              }else{
2235
                if(level < 64) { // 7-bit level
2236
                        put_bits(&s->pb, 1, 0);
2237
                        put_bits(&s->pb, 1, last);
2238
                        put_bits(&s->pb, 6, run);
2239

    
2240
                        put_sbits(&s->pb, 7, slevel);
2241
                    } else {
2242
                        /* 11-bit level */
2243
                        put_bits(&s->pb, 1, 1);
2244
                        put_bits(&s->pb, 1, last);
2245
                        put_bits(&s->pb, 6, run);
2246

    
2247
                        put_sbits(&s->pb, 11, slevel);
2248
                    }
2249
              }
2250
            } else {
2251
                put_bits(&s->pb, 1, sign);
2252
            }
2253
            last_non_zero = i;
2254
        }
2255
    }
2256
}
2257

    
2258
/***************************************************/
2259
/**
2260
 * add mpeg4 stuffing bits (01...1)
2261
 */
2262
void ff_mpeg4_stuffing(PutBitContext * pbc)
2263
{
2264
    int length;
2265
    put_bits(pbc, 1, 0);
2266
    length= (-put_bits_count(pbc))&7;
2267
    if(length) put_bits(pbc, length, (1<<length)-1);
2268
}
2269

    
2270
/* must be called before writing the header */
2271
void ff_set_mpeg4_time(MpegEncContext * s){
2272
    if(s->pict_type==FF_B_TYPE){
2273
        ff_mpeg4_init_direct_mv(s);
2274
    }else{
2275
        s->last_time_base= s->time_base;
2276
        s->time_base= s->time/s->avctx->time_base.den;
2277
    }
2278
}
2279

    
2280
static void mpeg4_encode_gop_header(MpegEncContext * s){
2281
    int hours, minutes, seconds;
2282
    int64_t time;
2283

    
2284
    put_bits(&s->pb, 16, 0);
2285
    put_bits(&s->pb, 16, GOP_STARTCODE);
2286

    
2287
    time= s->current_picture_ptr->pts;
2288
    if(s->reordered_input_picture[1])
2289
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2290
    time= time*s->avctx->time_base.num;
2291

    
2292
    seconds= time/s->avctx->time_base.den;
2293
    minutes= seconds/60; seconds %= 60;
2294
    hours= minutes/60; minutes %= 60;
2295
    hours%=24;
2296

    
2297
    put_bits(&s->pb, 5, hours);
2298
    put_bits(&s->pb, 6, minutes);
2299
    put_bits(&s->pb, 1, 1);
2300
    put_bits(&s->pb, 6, seconds);
2301

    
2302
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2303
    put_bits(&s->pb, 1, 0); //broken link == NO
2304

    
2305
    s->last_time_base= time / s->avctx->time_base.den;
2306

    
2307
    ff_mpeg4_stuffing(&s->pb);
2308
}
2309

    
2310
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2311
    int profile_and_level_indication;
2312
    int vo_ver_id;
2313

    
2314
    if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2315
        profile_and_level_indication = s->avctx->profile << 4;
2316
    }else if(s->max_b_frames || s->quarter_sample){
2317
        profile_and_level_indication= 0xF0; // adv simple
2318
    }else{
2319
        profile_and_level_indication= 0x00; // simple
2320
    }
2321

    
2322
    if(s->avctx->level != FF_LEVEL_UNKNOWN){
2323
        profile_and_level_indication |= s->avctx->level;
2324
    }else{
2325
        profile_and_level_indication |= 1; //level 1
2326
    }
2327

    
2328
    if(profile_and_level_indication>>4 == 0xF){
2329
        vo_ver_id= 5;
2330
    }else{
2331
        vo_ver_id= 1;
2332
    }
2333

    
2334
    //FIXME levels
2335

    
2336
    put_bits(&s->pb, 16, 0);
2337
    put_bits(&s->pb, 16, VOS_STARTCODE);
2338

    
2339
    put_bits(&s->pb, 8, profile_and_level_indication);
2340

    
2341
    put_bits(&s->pb, 16, 0);
2342
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2343

    
2344
    put_bits(&s->pb, 1, 1);
2345
        put_bits(&s->pb, 4, vo_ver_id);
2346
        put_bits(&s->pb, 3, 1); //priority
2347

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

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

    
2352
    ff_mpeg4_stuffing(&s->pb);
2353
}
2354

    
2355
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2356
{
2357
    int vo_ver_id;
2358

    
2359
    if (!CONFIG_MPEG4_ENCODER)  return;
2360

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

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

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

    
2384
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2385

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

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

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

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

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

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

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

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

    
2446
    ff_mpeg4_stuffing(&s->pb);
2447

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

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

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

    
2473
    s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE;
2474

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

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

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

    
2489
    put_bits(&s->pb, 1, 0);
2490

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

    
2506
    put_bits(&s->pb, 5, s->qscale);
2507

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

    
2515
#endif //CONFIG_ENCODERS
2516

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

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

    
2538
    wrap= s->block_wrap[n];
2539
    dc_val = s->dc_val[0] + s->block_index[n];
2540

    
2541
    /* B C
2542
     * A X
2543
     */
2544
    a = dc_val[ - 1];
2545
    b = dc_val[ - 1 - wrap];
2546
    c = dc_val[ - wrap];
2547

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

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

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

    
2593
    return ret;
2594
}
2595

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

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

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

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

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

    
2654
}
2655

    
2656
#if CONFIG_ENCODERS
2657

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

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

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

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

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

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

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

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

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

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

    
2882
    return len;
2883
}
2884

    
2885
#endif
2886

    
2887

    
2888
/***********************************************/
2889
/* decoding */
2890

    
2891
static VLC intra_MCBPC_vlc;
2892
static VLC inter_MCBPC_vlc;
2893
static VLC cbpy_vlc;
2894
static VLC mv_vlc;
2895
static VLC dc_lum, dc_chrom;
2896
static VLC sprite_trajectory;
2897
static VLC mb_type_b_vlc;
2898
static VLC h263_mbtype_b_vlc;
2899
static VLC cbpc_b_vlc;
2900

    
2901
/* init vlcs */
2902

    
2903
/* XXX: find a better solution to handle static init */
2904
void h263_decode_init_vlc(MpegEncContext *s)
2905
{
2906
    static int done = 0;
2907

    
2908
    if (!done) {
2909
        done = 1;
2910

    
2911
        INIT_VLC_STATIC(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2912
                 intra_MCBPC_bits, 1, 1,
2913
                 intra_MCBPC_code, 1, 1, 72);
2914
        INIT_VLC_STATIC(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2915
                 inter_MCBPC_bits, 1, 1,
2916
                 inter_MCBPC_code, 1, 1, 198);
2917
        INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16,
2918
                 &cbpy_tab[0][1], 2, 1,
2919
                 &cbpy_tab[0][0], 2, 1, 64);
2920
        INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33,
2921
                 &mvtab[0][1], 2, 1,
2922
                 &mvtab[0][0], 2, 1, 538);
2923
        init_rl(&rl_inter, static_rl_table_store[0]);
2924
        init_rl(&rl_intra, static_rl_table_store[1]);
2925
        init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2926
        init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2927
        init_rl(&rl_intra_aic, static_rl_table_store[2]);
2928
        INIT_VLC_RL(rl_inter, 554);
2929
        INIT_VLC_RL(rl_intra, 554);
2930
        INIT_VLC_RL(rvlc_rl_inter, 1072);
2931
        INIT_VLC_RL(rvlc_rl_intra, 1072);
2932
        INIT_VLC_RL(rl_intra_aic, 554);
2933
        INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2934
                 &DCtab_lum[0][1], 2, 1,
2935
                 &DCtab_lum[0][0], 2, 1, 512);
2936
        INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2937
                 &DCtab_chrom[0][1], 2, 1,
2938
                 &DCtab_chrom[0][0], 2, 1, 512);
2939
        INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2940
                 &sprite_trajectory_tab[0][1], 4, 2,
2941
                 &sprite_trajectory_tab[0][0], 4, 2, 128);
2942
        INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2943
                 &mb_type_b_tab[0][1], 2, 1,
2944
                 &mb_type_b_tab[0][0], 2, 1, 16);
2945
        INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2946
                 &h263_mbtype_b_tab[0][1], 2, 1,
2947
                 &h263_mbtype_b_tab[0][0], 2, 1, 80);
2948
        INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2949
                 &cbpc_b_tab[0][1], 2, 1,
2950
                 &cbpc_b_tab[0][0], 2, 1, 8);
2951
    }
2952
}
2953

    
2954
/**
2955
 * Get the GOB height based on picture height.
2956
 */
2957
int ff_h263_get_gob_height(MpegEncContext *s){
2958
    if (s->height <= 400)
2959
        return 1;
2960
    else if (s->height <= 800)
2961
        return  2;
2962
    else
2963
        return 4;
2964
}
2965

    
2966
int ff_h263_decode_mba(MpegEncContext *s)
2967
{
2968
    int i, mb_pos;
2969

    
2970
    for(i=0; i<6; i++){
2971
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2972
    }
2973
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2974
    s->mb_x= mb_pos % s->mb_width;
2975
    s->mb_y= mb_pos / s->mb_width;
2976

    
2977
    return mb_pos;
2978
}
2979

    
2980
void ff_h263_encode_mba(MpegEncContext *s)
2981
{
2982
    int i, mb_pos;
2983

    
2984
    for(i=0; i<6; i++){
2985
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2986
    }
2987
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
2988
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
2989
}
2990

    
2991
/**
2992
 * decodes the group of blocks header or slice header.
2993
 * @return <0 if an error occurred
2994
 */
2995
static int h263_decode_gob_header(MpegEncContext *s)
2996
{
2997
    unsigned int val, gfid, gob_number;
2998
    int left;
2999

    
3000
    /* Check for GOB Start Code */
3001
    val = show_bits(&s->gb, 16);
3002
    if(val)
3003
        return -1;
3004

    
3005
        /* We have a GBSC probably with GSTUFF */
3006
    skip_bits(&s->gb, 16); /* Drop the zeros */
3007
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3008
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3009
    for(;left>13; left--){
3010
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3011
    }
3012
    if(left<=13)
3013
        return -1;
3014

    
3015
    if(s->h263_slice_structured){
3016
        if(get_bits1(&s->gb)==0)
3017
            return -1;
3018

    
3019
        ff_h263_decode_mba(s);
3020

    
3021
        if(s->mb_num > 1583)
3022
            if(get_bits1(&s->gb)==0)
3023
                return -1;
3024

    
3025
        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3026
        if(get_bits1(&s->gb)==0)
3027
            return -1;
3028
        gfid = get_bits(&s->gb, 2); /* GFID */
3029
    }else{
3030
        gob_number = get_bits(&s->gb, 5); /* GN */
3031
        s->mb_x= 0;
3032
        s->mb_y= s->gob_index* gob_number;
3033
        gfid = get_bits(&s->gb, 2); /* GFID */
3034
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3035
    }
3036

    
3037
    if(s->mb_y >= s->mb_height)
3038
        return -1;
3039

    
3040
    if(s->qscale==0)
3041
        return -1;
3042

    
3043
    return 0;
3044
}
3045

    
3046
static inline void memsetw(short *tab, int val, int n)
3047
{
3048
    int i;
3049
    for(i=0;i<n;i++)
3050
        tab[i] = val;
3051
}
3052

    
3053
#if CONFIG_ENCODERS
3054

    
3055
void ff_mpeg4_init_partitions(MpegEncContext *s)
3056
{
3057
    uint8_t *start= pbBufPtr(&s->pb);
3058
    uint8_t *end= s->pb.buf_end;
3059
    int size= end - start;
3060
    int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3061
    int tex_size= (size - 2*pb_size)&(~3);
3062

    
3063
    set_put_bits_buffer_size(&s->pb, pb_size);
3064
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3065
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3066
}
3067

    
3068
void ff_mpeg4_merge_partitions(MpegEncContext *s)
3069
{
3070
    const int pb2_len   = put_bits_count(&s->pb2   );
3071
    const int tex_pb_len= put_bits_count(&s->tex_pb);
3072
    const int bits= put_bits_count(&s->pb);
3073

    
3074
    if(s->pict_type==FF_I_TYPE){
3075
        put_bits(&s->pb, 19, DC_MARKER);
3076
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3077
        s->i_tex_bits+= tex_pb_len;
3078
    }else{
3079
        put_bits(&s->pb, 17, MOTION_MARKER);
3080
        s->misc_bits+=17 + pb2_len;
3081
        s->mv_bits+= bits - s->last_bits;
3082
        s->p_tex_bits+= tex_pb_len;
3083
    }
3084

    
3085
    flush_put_bits(&s->pb2);
3086
    flush_put_bits(&s->tex_pb);
3087

    
3088
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3089
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3090
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3091
    s->last_bits= put_bits_count(&s->pb);
3092
}
3093

    
3094
#endif //CONFIG_ENCODERS
3095

    
3096
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3097
    switch(s->pict_type){
3098
        case FF_I_TYPE:
3099
            return 16;
3100
        case FF_P_TYPE:
3101
        case FF_S_TYPE:
3102
            return s->f_code+15;
3103
        case FF_B_TYPE:
3104
            return FFMAX3(s->f_code, s->b_code, 2) + 15;
3105
        default:
3106
            return -1;
3107
    }
3108
}
3109

    
3110
#if CONFIG_ENCODERS
3111

    
3112
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3113
{
3114
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3115

    
3116
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3117
    put_bits(&s->pb, 1, 1);
3118

    
3119
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3120
    put_bits(&s->pb, s->quant_precision, s->qscale);
3121
    put_bits(&s->pb, 1, 0); /* no HEC */
3122
}
3123

    
3124
#endif //CONFIG_ENCODERS
3125

    
3126
/**
3127
 * check if the next stuff is a resync marker or the end.
3128
 * @return 0 if not
3129
 */
3130
static inline int mpeg4_is_resync(MpegEncContext *s){
3131
    int bits_count= get_bits_count(&s->gb);
3132
    int v= show_bits(&s->gb, 16);
3133

    
3134
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3135
        return 0;
3136
    }
3137

    
3138
    while(v<=0xFF){
3139
        if(s->pict_type==FF_B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3140
            break;
3141
        skip_bits(&s->gb, 8+s->pict_type);
3142
        bits_count+= 8+s->pict_type;
3143
        v= show_bits(&s->gb, 16);
3144
    }
3145

    
3146
    if(bits_count + 8 >= s->gb.size_in_bits){
3147
        v>>=8;
3148
        v|= 0x7F >> (7-(bits_count&7));
3149

    
3150
        if(v==0x7F)
3151
            return 1;
3152
    }else{
3153
        if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3154
            int len;
3155
            GetBitContext gb= s->gb;
3156

    
3157
            skip_bits(&s->gb, 1);
3158
            align_get_bits(&s->gb);
3159

    
3160
            for(len=0; len<32; len++){
3161
                if(get_bits1(&s->gb)) break;
3162
            }
3163

    
3164
            s->gb= gb;
3165

    
3166
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3167
                return 1;
3168
        }
3169
    }
3170
    return 0;
3171
}
3172

    
3173
/**
3174
 * decodes the next video packet.
3175
 * @return <0 if something went wrong
3176
 */
3177
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3178
{
3179
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3180
    int header_extension=0, mb_num, len;
3181

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

    
3185
    for(len=0; len<32; len++){
3186
        if(get_bits1(&s->gb)) break;
3187
    }
3188

    
3189
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3190
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3191
        return -1;
3192
    }
3193

    
3194
    if(s->shape != RECT_SHAPE){
3195
        header_extension= get_bits1(&s->gb);
3196
        //FIXME more stuff here
3197
    }
3198

    
3199
    mb_num= get_bits(&s->gb, mb_num_bits);
3200
    if(mb_num>=s->mb_num){
3201
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3202
        return -1;
3203
    }
3204
    if(s->pict_type == FF_B_TYPE){
3205
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3206
        if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded
3207
    }
3208

    
3209
    s->mb_x= mb_num % s->mb_width;
3210
    s->mb_y= mb_num / s->mb_width;
3211

    
3212
    if(s->shape != BIN_ONLY_SHAPE){
3213
        int qscale= get_bits(&s->gb, s->quant_precision);
3214
        if(qscale)
3215
            s->chroma_qscale=s->qscale= qscale;
3216
    }
3217

    
3218
    if(s->shape == RECT_SHAPE){
3219
        header_extension= get_bits1(&s->gb);
3220
    }
3221
    if(header_extension){
3222
        int time_increment;
3223
        int time_incr=0;
3224

    
3225
        while (get_bits1(&s->gb) != 0)
3226
            time_incr++;
3227

    
3228
        check_marker(&s->gb, "before time_increment in video packed header");
3229
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3230
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3231

    
3232
        skip_bits(&s->gb, 2); /* vop coding type */
3233
        //FIXME not rect stuff here
3234

    
3235
        if(s->shape != BIN_ONLY_SHAPE){
3236
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3237
//FIXME don't just ignore everything
3238
            if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3239
                mpeg4_decode_sprite_trajectory(s, &s->gb);
3240
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3241
            }
3242

    
3243
            //FIXME reduced res stuff here
3244

    
3245
            if (s->pict_type != FF_I_TYPE) {
3246
                int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3247
                if(f_code==0){
3248
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3249
                }
3250
            }
3251
            if (s->pict_type == FF_B_TYPE) {
3252
                int b_code = get_bits(&s->gb, 3);
3253
                if(b_code==0){
3254
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3255
                }
3256
            }
3257
        }
3258
    }
3259
    //FIXME new-pred stuff
3260

    
3261
//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));
3262

    
3263
    return 0;
3264
}
3265

    
3266
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3267
{
3268
    int c_wrap, c_xy, l_wrap, l_xy;
3269

    
3270
    l_wrap= s->b8_stride;
3271
    l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3272
    c_wrap= s->mb_stride;
3273
    c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3274

    
3275
#if 0
3276
    /* clean DC */
3277
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3278
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3279
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3280
#endif
3281

    
3282
    /* clean AC */
3283
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3284
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3285
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3286

    
3287
    /* clean MV */
3288
    // we can't clear the MVs as they might be needed by a b frame
3289
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3290
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3291
    s->last_mv[0][0][0]=
3292
    s->last_mv[0][0][1]=
3293
    s->last_mv[1][0][0]=
3294
    s->last_mv[1][0][1]= 0;
3295
}
3296

    
3297
/**
3298
 * decodes the group of blocks / video packet header.
3299
 * @return <0 if no resync found
3300
 */
3301
int ff_h263_resync(MpegEncContext *s){
3302
    int left, ret;
3303

    
3304
    if(s->codec_id==CODEC_ID_MPEG4){
3305
        skip_bits1(&s->gb);
3306
        align_get_bits(&s->gb);
3307
    }
3308

    
3309
    if(show_bits(&s->gb, 16)==0){
3310
        if(s->codec_id==CODEC_ID_MPEG4)
3311
            ret= mpeg4_decode_video_packet_header(s);
3312
        else
3313
            ret= h263_decode_gob_header(s);
3314
        if(ret>=0)
3315
            return 0;
3316
    }
3317
    //OK, it's not where it is supposed to be ...
3318
    s->gb= s->last_resync_gb;
3319
    align_get_bits(&s->gb);
3320
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3321

    
3322
    for(;left>16+1+5+5; left-=8){
3323
        if(show_bits(&s->gb, 16)==0){
3324
            GetBitContext bak= s->gb;
3325

    
3326
            if(s->codec_id==CODEC_ID_MPEG4)
3327
                ret= mpeg4_decode_video_packet_header(s);
3328
            else
3329
                ret= h263_decode_gob_header(s);
3330
            if(ret>=0)
3331
                return 0;
3332

    
3333
            s->gb= bak;
3334
        }
3335
        skip_bits(&s->gb, 8);
3336
    }
3337

    
3338
    return -1;
3339
}
3340

    
3341
/**
3342
 * gets the average motion vector for a GMC MB.
3343
 * @param n either 0 for the x component or 1 for y
3344
 * @returns the average MV for a GMC MB
3345
 */
3346
static inline int get_amv(MpegEncContext *s, int n){
3347
    int x, y, mb_v, sum, dx, dy, shift;
3348
    int len = 1 << (s->f_code + 4);
3349
    const int a= s->sprite_warping_accuracy;
3350

    
3351
    if(s->workaround_bugs & FF_BUG_AMV)
3352
        len >>= s->quarter_sample;
3353

    
3354
    if(s->real_sprite_warping_points==1){
3355
        if(s->divx_version==500 && s->divx_build==413)
3356
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3357
        else
3358
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3359
    }else{
3360
        dx= s->sprite_delta[n][0];
3361
        dy= s->sprite_delta[n][1];
3362
        shift= s->sprite_shift[0];
3363
        if(n) dy -= 1<<(shift + a + 1);
3364
        else  dx -= 1<<(shift + a + 1);
3365
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3366

    
3367
        sum=0;
3368
        for(y=0; y<16; y++){
3369
            int v;
3370

    
3371
            v= mb_v + dy*y;
3372
            //XXX FIXME optimize
3373
            for(x=0; x<16; x++){
3374
                sum+= v>>shift;
3375
                v+= dx;
3376
            }
3377
        }
3378
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3379
    }
3380

    
3381
    if      (sum < -len) sum= -len;
3382
    else if (sum >= len) sum= len-1;
3383

    
3384
    return sum;
3385
}
3386

    
3387
/**
3388
 * decodes first partition.
3389
 * @return number of MBs decoded or <0 if an error occurred
3390
 */
3391
static int mpeg4_decode_partition_a(MpegEncContext *s){
3392
    int mb_num;
3393
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3394

    
3395
    /* decode first partition */
3396
    mb_num=0;
3397
    s->first_slice_line=1;
3398
    for(; s->mb_y<s->mb_height; s->mb_y++){
3399
        ff_init_block_index(s);
3400
        for(; s->mb_x<s->mb_width; s->mb_x++){
3401
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3402
            int cbpc;
3403
            int dir=0;
3404

    
3405
            mb_num++;
3406
            ff_update_block_index(s);
3407
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3408
                s->first_slice_line=0;
3409

    
3410
            if(s->pict_type==FF_I_TYPE){
3411
                int i;
3412

    
3413
                do{
3414
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
3415
                        return mb_num-1;
3416
                    }
3417

    
3418
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3419
                    if (cbpc < 0){
3420
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3421
                        return -1;
3422
                    }
3423
                }while(cbpc == 8);
3424

    
3425
                s->cbp_table[xy]= cbpc & 3;
3426
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3427
                s->mb_intra = 1;
3428

    
3429
                if(cbpc & 4) {
3430
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3431
                }
3432
                s->current_picture.qscale_table[xy]= s->qscale;
3433

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

    
3451
try_again:
3452
                bits= show_bits(&s->gb, 17);
3453
                if(bits==MOTION_MARKER){
3454
                    return mb_num-1;
3455
                }
3456
                skip_bits1(&s->gb);
3457
                if(bits&0x10000){
3458
                    /* skip mb */
3459
                    if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3460
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3461
                        mx= get_amv(s, 0);
3462
                        my= get_amv(s, 1);
3463
                    }else{
3464
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3465
                        mx=my=0;
3466
                    }
3467
                    mot_val[0       ]= mot_val[2       ]=
3468
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3469
                    mot_val[1       ]= mot_val[3       ]=
3470
                    mot_val[1+stride]= mot_val[3+stride]= my;
3471

    
3472
                    if(s->mbintra_table[xy])
3473
                        ff_clean_intra_table_entries(s);
3474
                    continue;
3475
                }
3476

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

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

    
3487
                s->mb_intra = ((cbpc & 4) != 0);
3488

    
3489
                if(s->mb_intra){
3490
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3491
                    s->mbintra_table[xy]= 1;
3492
                    mot_val[0       ]= mot_val[2       ]=
3493
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3494
                    mot_val[1       ]= mot_val[3       ]=
3495
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3496
                }else{
3497
                    if(s->mbintra_table[xy])
3498
                        ff_clean_intra_table_entries(s);
3499

    
3500
                    if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3501
                        s->mcsel= get_bits1(&s->gb);
3502
                    else s->mcsel= 0;
3503

    
3504
                    if ((cbpc & 16) == 0) {
3505
                        /* 16x16 motion prediction */
3506

    
3507
                        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3508
                        if(!s->mcsel){
3509
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3510
                            if (mx >= 0xffff)
3511
                                return -1;
3512

    
3513
                            my = h263_decode_motion(s, pred_y, s->f_code);
3514
                            if (my >= 0xffff)
3515
                                return -1;
3516
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3517
                        } else {
3518
                            mx = get_amv(s, 0);
3519
                            my = get_amv(s, 1);
3520
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3521
                        }
3522

    
3523
                        mot_val[0       ]= mot_val[2       ] =
3524
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3525
                        mot_val[1       ]= mot_val[3       ]=
3526
                        mot_val[1+stride]= mot_val[3+stride]= my;
3527
                    } else {
3528
                        int i;
3529
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3530
                        for(i=0;i<4;i++) {
3531
                            int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3532
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3533
                            if (mx >= 0xffff)
3534
                                return -1;
3535

    
3536
                            my = h263_decode_motion(s, pred_y, s->f_code);
3537
                            if (my >= 0xffff)
3538
                                return -1;
3539
                            mot_val[0] = mx;
3540
                            mot_val[1] = my;
3541
                        }
3542
                    }
3543
                }
3544
            }
3545
        }
3546
        s->mb_x= 0;
3547
    }
3548

    
3549
    return mb_num;
3550
}
3551

    
3552
/**
3553
 * decode second partition.
3554
 * @return <0 if an error occurred
3555
 */
3556
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3557
    int mb_num=0;
3558
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3559

    
3560
    s->mb_x= s->resync_mb_x;
3561
    s->first_slice_line=1;
3562
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3563
        ff_init_block_index(s);
3564
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3565
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3566

    
3567
            mb_num++;
3568
            ff_update_block_index(s);
3569
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3570
                s->first_slice_line=0;
3571

    
3572
            if(s->pict_type==FF_I_TYPE){
3573
                int ac_pred= get_bits1(&s->gb);
3574
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3575
                if(cbpy<0){
3576
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3577
                    return -1;
3578
                }
3579

    
3580
                s->cbp_table[xy]|= cbpy<<2;
3581
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3582
            }else{ /* P || S_TYPE */
3583
                if(IS_INTRA(s->current_picture.mb_type[xy])){
3584
                    int dir=0,i;
3585
                    int ac_pred = get_bits1(&s->gb);
3586
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3587

    
3588
                    if(cbpy<0){
3589
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3590
                        return -1;
3591
                    }
3592

    
3593
                    if(s->cbp_table[xy] & 8) {
3594
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3595
                    }
3596
                    s->current_picture.qscale_table[xy]= s->qscale;
3597

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

    
3618
                    if(cbpy<0){
3619
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3620
                        return -1;
3621
                    }
3622

    
3623
                    if(s->cbp_table[xy] & 8) {
3624
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3625
                    }
3626
                    s->current_picture.qscale_table[xy]= s->qscale;
3627

    
3628
                    s->cbp_table[xy]&= 3; //remove dquant
3629
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3630
                }
3631
            }
3632
        }
3633
        if(mb_num >= mb_count) return 0;
3634
        s->mb_x= 0;
3635
    }
3636
    return 0;
3637
}
3638

    
3639
/**
3640
 * decodes the first & second partition
3641
 * @return <0 if error (and sets error type in the error_status_table)
3642
 */
3643
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3644
{
3645
    int mb_num;
3646
    const int part_a_error= s->pict_type==FF_I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3647
    const int part_a_end  = s->pict_type==FF_I_TYPE ? (DC_END  |MV_END)   : MV_END;
3648

    
3649
    mb_num= mpeg4_decode_partition_a(s);
3650
    if(mb_num<0){
3651
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3652
        return -1;
3653
    }
3654

    
3655
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3656
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3657
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3658
        return -1;
3659
    }
3660

    
3661
    s->mb_num_left= mb_num;
3662

    
3663
    if(s->pict_type==FF_I_TYPE){
3664
        while(show_bits(&s->gb, 9) == 1)
3665
            skip_bits(&s->gb, 9);
3666
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3667
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3668
            return -1;
3669
        }
3670
    }else{
3671
        while(show_bits(&s->gb, 10) == 1)
3672
            skip_bits(&s->gb, 10);
3673
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3674
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3675
            return -1;
3676
        }
3677
    }
3678
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3679

    
3680
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3681
        if(s->pict_type==FF_P_TYPE)
3682
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3683
        return -1;
3684
    }else{
3685
        if(s->pict_type==FF_P_TYPE)
3686
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3687
    }
3688

    
3689
    return 0;
3690
}
3691

    
3692
/**
3693
 * decode partition C of one MB.
3694
 * @return <0 if an error occurred
3695
 */
3696
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3697
{
3698
    int cbp, mb_type;
3699
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3700

    
3701
    mb_type= s->current_picture.mb_type[xy];
3702
    cbp = s->cbp_table[xy];
3703

    
3704
    s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3705

    
3706
    if(s->current_picture.qscale_table[xy] != s->qscale){
3707
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3708
    }
3709

    
3710
    if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
3711
        int i;
3712
        for(i=0; i<4; i++){
3713
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3714
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3715
        }
3716
        s->mb_intra = IS_INTRA(mb_type);
3717

    
3718
        if (IS_SKIP(mb_type)) {
3719
            /* skip mb */
3720
            for(i=0;i<6;i++)
3721
                s->block_last_index[i] = -1;
3722
            s->mv_dir = MV_DIR_FORWARD;
3723
            s->mv_type = MV_TYPE_16X16;
3724
            if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3725
                s->mcsel=1;
3726
                s->mb_skipped = 0;
3727
            }else{
3728
                s->mcsel=0;
3729
                s->mb_skipped = 1;
3730
            }
3731
        }else if(s->mb_intra){
3732
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3733
        }else if(!s->mb_intra){
3734
//            s->mcsel= 0; //FIXME do we need to init that
3735

    
3736
            s->mv_dir = MV_DIR_FORWARD;
3737
            if (IS_8X8(mb_type)) {
3738
                s->mv_type = MV_TYPE_8X8;
3739
            } else {
3740
                s->mv_type = MV_TYPE_16X16;
3741
            }
3742
        }
3743
    } else { /* I-Frame */
3744
        s->mb_intra = 1;
3745
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3746
    }
3747

    
3748
    if (!IS_SKIP(mb_type)) {
3749
        int i;
3750
        s->dsp.clear_blocks(s->block[0]);
3751
        /* decode each block */
3752
        for (i = 0; i < 6; i++) {
3753
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3754
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3755
                return -1;
3756
            }
3757
            cbp+=cbp;
3758
        }
3759
    }
3760

    
3761
    /* per-MB end of slice check */
3762

    
3763
    if(--s->mb_num_left <= 0){
3764
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3765
        if(mpeg4_is_resync(s))
3766
            return SLICE_END;
3767
        else
3768
            return SLICE_NOEND;
3769
    }else{
3770
        if(mpeg4_is_resync(s)){
3771
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3772
            if(s->cbp_table[xy+delta])
3773
                return SLICE_END;
3774
        }
3775
        return SLICE_OK;
3776
    }
3777
}
3778

    
3779
/**
3780
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3781
 */
3782
static void preview_obmc(MpegEncContext *s){
3783
    GetBitContext gb= s->gb;
3784

    
3785
    int cbpc, i, pred_x, pred_y, mx, my;
3786
    int16_t *mot_val;
3787
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3788
    const int stride= s->b8_stride*2;
3789

    
3790
    for(i=0; i<4; i++)
3791
        s->block_index[i]+= 2;
3792
    for(i=4; i<6; i++)
3793
        s->block_index[i]+= 1;
3794
    s->mb_x++;
3795

    
3796
    assert(s->pict_type == FF_P_TYPE);
3797

    
3798
    do{
3799
        if (get_bits1(&s->gb)) {
3800
            /* skip mb */
3801
            mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3802
            mot_val[0       ]= mot_val[2       ]=
3803
            mot_val[0+stride]= mot_val[2+stride]= 0;
3804
            mot_val[1       ]= mot_val[3       ]=
3805
            mot_val[1+stride]= mot_val[3+stride]= 0;
3806

    
3807
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3808
            goto end;
3809
        }
3810
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3811
    }while(cbpc == 20);
3812

    
3813
    if(cbpc & 4){
3814
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3815
    }else{
3816
        get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3817
        if (cbpc & 8) {
3818
            if(s->modified_quant){
3819
                if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3820
                else                  skip_bits(&s->gb, 5);
3821
            }else
3822
                skip_bits(&s->gb, 2);
3823
        }
3824

    
3825
        if ((cbpc & 16) == 0) {
3826
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3827
                /* 16x16 motion prediction */
3828
                mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3829
                if (s->umvplus)
3830
                   mx = h263p_decode_umotion(s, pred_x);
3831
                else
3832
                   mx = h263_decode_motion(s, pred_x, 1);
3833

    
3834
                if (s->umvplus)
3835
                   my = h263p_decode_umotion(s, pred_y);
3836
                else
3837
                   my = h263_decode_motion(s, pred_y, 1);
3838

    
3839
                mot_val[0       ]= mot_val[2       ]=
3840
                mot_val[0+stride]= mot_val[2+stride]= mx;
3841
                mot_val[1       ]= mot_val[3       ]=
3842
                mot_val[1+stride]= mot_val[3+stride]= my;
3843
        } else {
3844
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3845
            for(i=0;i<4;i++) {
3846
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3847
                if (s->umvplus)
3848
                  mx = h263p_decode_umotion(s, pred_x);
3849
                else
3850
                  mx = h263_decode_motion(s, pred_x, 1);
3851

    
3852
                if (s->umvplus)
3853
                  my = h263p_decode_umotion(s, pred_y);
3854
                else
3855
                  my = h263_decode_motion(s, pred_y, 1);
3856
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3857
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3858
                mot_val[0] = mx;
3859
                mot_val[1] = my;
3860
            }
3861
        }
3862
    }
3863
end:
3864

    
3865
    for(i=0; i<4; i++)
3866
        s->block_index[i]-= 2;
3867
    for(i=4; i<6; i++)
3868
        s->block_index[i]-= 1;
3869
    s->mb_x--;
3870

    
3871
    s->gb= gb;
3872
}
3873

    
3874
static void h263_decode_dquant(MpegEncContext *s){
3875
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3876

    
3877
    if(s->modified_quant){
3878
        if(get_bits1(&s->gb))
3879
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3880
        else
3881
            s->qscale= get_bits(&s->gb, 5);
3882
    }else
3883
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3884
    ff_set_qscale(s, s->qscale);
3885
}
3886

    
3887
int ff_h263_decode_mb(MpegEncContext *s,
3888
                      DCTELEM block[6][64])
3889
{
3890
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3891
    int16_t *mot_val;
3892
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3893

    
3894
    assert(!s->h263_pred);
3895

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

    
3919
        s->dsp.clear_blocks(s->block[0]);
3920

    
3921
        dquant = cbpc & 8;
3922
        s->mb_intra = ((cbpc & 4) != 0);
3923
        if (s->mb_intra) goto intra;
3924

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

    
3927
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3928
            cbpy ^= 0xF;
3929

    
3930
        cbp = (cbpc & 3) | (cbpy << 2);
3931
        if (dquant) {
3932
            h263_decode_dquant(s);
3933
        }
3934

    
3935
        s->mv_dir = MV_DIR_FORWARD;
3936
        if ((cbpc & 16) == 0) {
3937
            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3938
            /* 16x16 motion prediction */
3939
            s->mv_type = MV_TYPE_16X16;
3940
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3941
            if (s->umvplus)
3942
               mx = h263p_decode_umotion(s, pred_x);
3943
            else
3944
               mx = h263_decode_motion(s, pred_x, 1);
3945

    
3946
            if (mx >= 0xffff)
3947
                return -1;
3948

    
3949
            if (s->umvplus)
3950
               my = h263p_decode_umotion(s, pred_y);
3951
            else
3952
               my = h263_decode_motion(s, pred_y, 1);
3953

    
3954
            if (my >= 0xffff)
3955
                return -1;
3956
            s->mv[0][0][0] = mx;
3957
            s->mv[0][0][1] = my;
3958

    
3959
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3960
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3961
        } else {
3962
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3963
            s->mv_type = MV_TYPE_8X8;
3964
            for(i=0;i<4;i++) {
3965
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3966
                if (s->umvplus)
3967
                  mx = h263p_decode_umotion(s, pred_x);
3968
                else
3969
                  mx = h263_decode_motion(s, pred_x, 1);
3970
                if (mx >= 0xffff)
3971
                    return -1;
3972

    
3973
                if (s->umvplus)
3974
                  my = h263p_decode_umotion(s, pred_y);
3975
                else
3976
                  my = h263_decode_motion(s, pred_y, 1);
3977
                if (my >= 0xffff)
3978
                    return -1;
3979
                s->mv[0][i][0] = mx;
3980
                s->mv[0][i][1] = my;
3981
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3982
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3983
                mot_val[0] = mx;
3984
                mot_val[1] = my;
3985
            }
3986
        }
3987

    
3988
        /* decode each block */
3989
        for (i = 0; i < 6; i++) {
3990
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3991
                return -1;
3992
            cbp+=cbp;
3993
        }
3994

    
3995
        if(s->obmc){
3996
            if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
3997
                preview_obmc(s);
3998
        }
3999
    } else if(s->pict_type==FF_B_TYPE) {
4000
        int mb_type;
4001
        const int stride= s->b8_stride;
4002
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4003
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4004
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4005

    
4006
        //FIXME ugly
4007
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4008
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4009
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4010
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4011

    
4012
        do{
4013
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4014
            if (mb_type < 0){
4015
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4016
                return -1;
4017
            }
4018

    
4019
            mb_type= h263_mb_type_b_map[ mb_type ];
4020
        }while(!mb_type);
4021

    
4022
        s->mb_intra = IS_INTRA(mb_type);
4023
        if(HAS_CBP(mb_type)){
4024
            s->dsp.clear_blocks(s->block[0]);
4025
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4026
            if(s->mb_intra){
4027
                dquant = IS_QUANT(mb_type);
4028
                goto intra;
4029
            }
4030

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

    
4033
            if (cbpy < 0){
4034
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4035
                return -1;
4036
            }
4037

    
4038
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4039
                cbpy ^= 0xF;
4040

    
4041
            cbp = (cbpc & 3) | (cbpy << 2);
4042
        }else
4043
            cbp=0;
4044

    
4045
        assert(!s->mb_intra);
4046

    
4047
        if(IS_QUANT(mb_type)){
4048
            h263_decode_dquant(s);
4049
        }
4050

    
4051
        if(IS_DIRECT(mb_type)){
4052
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4053
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4054
        }else{
4055
            s->mv_dir = 0;
4056
            s->mv_type= MV_TYPE_16X16;
4057
//FIXME UMV
4058

    
4059
            if(USES_LIST(mb_type, 0)){
4060
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4061
                s->mv_dir = MV_DIR_FORWARD;
4062

    
4063
                mx = h263_decode_motion(s, mx, 1);
4064
                my = h263_decode_motion(s, my, 1);
4065

    
4066
                s->mv[0][0][0] = mx;
4067
                s->mv[0][0][1] = my;
4068
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4069
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4070
            }
4071

    
4072
            if(USES_LIST(mb_type, 1)){
4073
                int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4074
                s->mv_dir |= MV_DIR_BACKWARD;
4075

    
4076
                mx = h263_decode_motion(s, mx, 1);
4077
                my = h263_decode_motion(s, my, 1);
4078

    
4079
                s->mv[1][0][0] = mx;
4080
                s->mv[1][0][1] = my;
4081
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4082
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4083
            }
4084
        }
4085

    
4086
        s->current_picture.mb_type[xy]= mb_type;
4087

    
4088
        /* decode each block */
4089
        for (i = 0; i < 6; i++) {
4090
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4091
                return -1;
4092
            cbp+=cbp;
4093
        }
4094
    } else { /* I-Frame */
4095
        do{
4096
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4097
            if (cbpc < 0){
4098
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4099
                return -1;
4100
            }
4101
        }while(cbpc == 8);
4102

    
4103
        s->dsp.clear_blocks(s->block[0]);
4104

    
4105
        dquant = cbpc & 4;
4106
        s->mb_intra = 1;
4107
intra:
4108
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4109
        if (s->h263_aic) {
4110
            s->ac_pred = get_bits1(&s->gb);
4111
            if(s->ac_pred){
4112
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4113

    
4114
                s->h263_aic_dir = get_bits1(&s->gb);
4115
            }
4116
        }else
4117
            s->ac_pred = 0;
4118

    
4119
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4120
        if(cbpy<0){
4121
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4122
            return -1;
4123
        }
4124
        cbp = (cbpc & 3) | (cbpy << 2);
4125
        if (dquant) {
4126
            h263_decode_dquant(s);
4127
        }
4128

    
4129
        /* decode each block */
4130
        for (i = 0; i < 6; i++) {
4131
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4132
                return -1;
4133
            cbp+=cbp;
4134
        }
4135
    }
4136
end:
4137

    
4138
        /* per-MB end of slice check */
4139
    {
4140
        int v= show_bits(&s->gb, 16);
4141

    
4142
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4143
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4144
        }
4145

    
4146
        if(v==0)
4147
            return SLICE_END;
4148
    }
4149

    
4150
    return SLICE_OK;
4151
}
4152

    
4153
int ff_mpeg4_decode_mb(MpegEncContext *s,
4154
                      DCTELEM block[6][64])
4155
{
4156
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4157
    int16_t *mot_val;
4158
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4159
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4160

    
4161
    assert(s->h263_pred);
4162

    
4163
    if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
4164
        do{
4165
            if (get_bits1(&s->gb)) {
4166
                /* skip mb */
4167
                s->mb_intra = 0;
4168
                for(i=0;i<6;i++)
4169
                    s->block_last_index[i] = -1;
4170
                s->mv_dir = MV_DIR_FORWARD;
4171
                s->mv_type = MV_TYPE_16X16;
4172
                if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4173
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4174
                    s->mcsel=1;
4175
                    s->mv[0][0][0]= get_amv(s, 0);
4176
                    s->mv[0][0][1]= get_amv(s, 1);
4177

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

    
4196
        s->dsp.clear_blocks(s->block[0]);
4197
        dquant = cbpc & 8;
4198
        s->mb_intra = ((cbpc & 4) != 0);
4199
        if (s->mb_intra) goto intra;
4200

    
4201
        if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4202
            s->mcsel= get_bits1(&s->gb);
4203
        else s->mcsel= 0;
4204
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4205

    
4206
        cbp = (cbpc & 3) | (cbpy << 2);
4207
        if (dquant) {
4208
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4209
        }
4210
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4211
            s->interlaced_dct= get_bits1(&s->gb);
4212

    
4213
        s->mv_dir = MV_DIR_FORWARD;
4214
        if ((cbpc & 16) == 0) {
4215
            if(s->mcsel){
4216
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4217
                /* 16x16 global motion prediction */
4218
                s->mv_type = MV_TYPE_16X16;
4219
                mx= get_amv(s, 0);
4220
                my= get_amv(s, 1);
4221
                s->mv[0][0][0] = mx;
4222
                s->mv[0][0][1] = my;
4223
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4224
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4225
                /* 16x8 field motion prediction */
4226
                s->mv_type= MV_TYPE_FIELD;
4227

    
4228
                s->field_select[0][0]= get_bits1(&s->gb);
4229
                s->field_select[0][1]= get_bits1(&s->gb);
4230

    
4231
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4232

    
4233
                for(i=0; i<2; i++){
4234
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4235
                    if (mx >= 0xffff)
4236
                        return -1;
4237

    
4238
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4239
                    if (my >= 0xffff)
4240
                        return -1;
4241

    
4242
                    s->mv[0][i][0] = mx;
4243
                    s->mv[0][i][1] = my;
4244
                }
4245
            }else{
4246
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4247
                /* 16x16 motion prediction */
4248
                s->mv_type = MV_TYPE_16X16;
4249
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4250
                mx = h263_decode_motion(s, pred_x, s->f_code);
4251

    
4252
                if (mx >= 0xffff)
4253
                    return -1;
4254

    
4255
                my = h263_decode_motion(s, pred_y, s->f_code);
4256

    
4257
                if (my >= 0xffff)
4258
                    return -1;
4259
                s->mv[0][0][0] = mx;
4260
                s->mv[0][0][1] = my;
4261
            }
4262
        } else {
4263
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4264
            s->mv_type = MV_TYPE_8X8;
4265
            for(i=0;i<4;i++) {
4266
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4267
                mx = h263_decode_motion(s, pred_x, s->f_code);
4268
                if (mx >= 0xffff)
4269
                    return -1;
4270

    
4271
                my = h263_decode_motion(s, pred_y, s->f_code);
4272
                if (my >= 0xffff)
4273
                    return -1;
4274
                s->mv[0][i][0] = mx;
4275
                s->mv[0][i][1] = my;
4276
                mot_val[0] = mx;
4277
                mot_val[1] = my;
4278
            }
4279
        }
4280
    } else if(s->pict_type==FF_B_TYPE) {
4281
        int modb1; // first bit of modb
4282
        int modb2; // second bit of modb
4283
        int mb_type;
4284

    
4285
        s->mb_intra = 0; //B-frames never contain intra blocks
4286
        s->mcsel=0;      //     ...               true gmc blocks
4287

    
4288
        if(s->mb_x==0){
4289
            for(i=0; i<2; i++){
4290
                s->last_mv[i][0][0]=
4291
                s->last_mv[i][0][1]=
4292
                s->last_mv[i][1][0]=
4293
                s->last_mv[i][1][1]= 0;
4294
            }
4295
        }
4296

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

    
4300
        if(s->mb_skipped){
4301
                /* skip mb */
4302
            for(i=0;i<6;i++)
4303
                s->block_last_index[i] = -1;
4304

    
4305
            s->mv_dir = MV_DIR_FORWARD;
4306
            s->mv_type = MV_TYPE_16X16;
4307
            s->mv[0][0][0] = 0;
4308
            s->mv[0][0][1] = 0;
4309
            s->mv[1][0][0] = 0;
4310
            s->mv[1][0][1] = 0;
4311
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4312
            goto end;
4313
        }
4314

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

    
4333
            if ((!IS_DIRECT(mb_type)) && cbp) {
4334
                if(get_bits1(&s->gb)){
4335
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4336
                }
4337
            }
4338

    
4339
            if(!s->progressive_sequence){
4340
                if(cbp)
4341
                    s->interlaced_dct= get_bits1(&s->gb);
4342

    
4343
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4344
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4345
                    mb_type &= ~MB_TYPE_16x16;
4346

    
4347
                    if(USES_LIST(mb_type, 0)){
4348
                        s->field_select[0][0]= get_bits1(&s->gb);
4349
                        s->field_select[0][1]= get_bits1(&s->gb);
4350
                    }
4351
                    if(USES_LIST(mb_type, 1)){
4352
                        s->field_select[1][0]= get_bits1(&s->gb);
4353
                        s->field_select[1][1]= get_bits1(&s->gb);
4354
                    }
4355
                }
4356
            }
4357

    
4358
            s->mv_dir = 0;
4359
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4360
                s->mv_type= MV_TYPE_16X16;
4361

    
4362
                if(USES_LIST(mb_type, 0)){
4363
                    s->mv_dir = MV_DIR_FORWARD;
4364

    
4365
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4366
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4367
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4368
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4369
                }
4370

    
4371
                if(USES_LIST(mb_type, 1)){
4372
                    s->mv_dir |= MV_DIR_BACKWARD;
4373

    
4374
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4375
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4376
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4377
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4378
                }
4379
            }else if(!IS_DIRECT(mb_type)){
4380
                s->mv_type= MV_TYPE_FIELD;
4381

    
4382
                if(USES_LIST(mb_type, 0)){
4383
                    s->mv_dir = MV_DIR_FORWARD;
4384

    
4385
                    for(i=0; i<2; i++){
4386
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4387
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4388
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4389
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4390
                    }
4391
                }
4392

    
4393
                if(USES_LIST(mb_type, 1)){
4394
                    s->mv_dir |= MV_DIR_BACKWARD;
4395

    
4396
                    for(i=0; i<2; i++){
4397
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4398
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4399
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4400
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4401
                    }
4402
                }
4403
            }
4404
        }
4405

    
4406
        if(IS_DIRECT(mb_type)){
4407
            if(IS_SKIP(mb_type))
4408
                mx=my=0;
4409
            else{
4410
                mx = h263_decode_motion(s, 0, 1);
4411
                my = h263_decode_motion(s, 0, 1);
4412
            }
4413

    
4414
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4415
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4416
        }
4417
        s->current_picture.mb_type[xy]= mb_type;
4418
    } else { /* I-Frame */
4419
        do{
4420
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4421
            if (cbpc < 0){
4422
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4423
                return -1;
4424
            }
4425
        }while(cbpc == 8);
4426

    
4427
        dquant = cbpc & 4;
4428
        s->mb_intra = 1;
4429
intra:
4430
        s->ac_pred = get_bits1(&s->gb);
4431
        if(s->ac_pred)
4432
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4433
        else
4434
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4435

    
4436
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4437
        if(cbpy<0){
4438
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4439
            return -1;
4440
        }
4441
        cbp = (cbpc & 3) | (cbpy << 2);
4442

    
4443
        s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4444

    
4445
        if (dquant) {
4446
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4447
        }
4448

    
4449
        if(!s->progressive_sequence)
4450
            s->interlaced_dct= get_bits1(&s->gb);
4451

    
4452
        s->dsp.clear_blocks(s->block[0]);
4453
        /* decode each block */
4454
        for (i = 0; i < 6; i++) {
4455
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4456
                return -1;
4457
            cbp+=cbp;
4458
        }
4459
        goto end;
4460
    }
4461

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

    
4470
        /* per-MB end of slice check */
4471
    if(s->codec_id==CODEC_ID_MPEG4){
4472
        if(mpeg4_is_resync(s)){
4473
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4474
            if(s->pict_type==FF_B_TYPE && s->next_picture.mbskip_table[xy + delta])
4475
                return SLICE_OK;
4476
            return SLICE_END;
4477
        }
4478
    }
4479

    
4480
    return SLICE_OK;
4481
}
4482

    
4483
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4484
{
4485
    int code, val, sign, shift, l;
4486
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4487

    
4488
    if (code == 0)
4489
        return pred;
4490
    if (code < 0)
4491
        return 0xffff;
4492

    
4493
    sign = get_bits1(&s->gb);
4494
    shift = f_code - 1;
4495
    val = code;
4496
    if (shift) {
4497
        val = (val - 1) << shift;
4498
        val |= get_bits(&s->gb, shift);
4499
        val++;
4500
    }
4501
    if (sign)
4502
        val = -val;
4503
    val += pred;
4504

    
4505
    /* modulo decoding */
4506
    if (!s->h263_long_vectors) {
4507
        l = INT_BIT - 5 - f_code;
4508
        val = (val<<l)>>l;
4509
    } else {
4510
        /* horrible h263 long vector mode */
4511
        if (pred < -31 && val < -63)
4512
            val += 64;
4513
        if (pred > 32 && val > 63)
4514
            val -= 64;
4515

    
4516
    }
4517
    return val;
4518
}
4519

    
4520
/* Decodes RVLC of H.263+ UMV */
4521
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4522
{
4523
   int code = 0, sign;
4524

    
4525
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4526
      return pred;
4527

    
4528
   code = 2 + get_bits1(&s->gb);
4529

    
4530
   while (get_bits1(&s->gb))
4531
   {
4532
      code <<= 1;
4533
      code += get_bits1(&s->gb);
4534
   }
4535
   sign = code & 1;
4536
   code >>= 1;
4537

    
4538
   code = (sign) ? (pred - code) : (pred + code);
4539
#ifdef DEBUG
4540
   av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4541
#endif
4542
   return code;
4543

    
4544
}
4545

    
4546
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4547
                             int n, int coded)
4548
{
4549
    int code, level, i, j, last, run;
4550
    RLTable *rl = &rl_inter;
4551
    const uint8_t *scan_table;
4552
    GetBitContext gb= s->gb;
4553

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

    
4676
/**
4677
 * decodes the dc value.
4678
 * @param n block index (0-3 are luma, 4-5 are chroma)
4679
 * @param dir_ptr the prediction direction will be stored here
4680
 * @return the quantized dc
4681
 */
4682
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4683
{
4684
    int level, code;
4685

    
4686
    if (n < 4)
4687
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4688
    else
4689
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4690
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4691
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4692
        return -1;
4693
    }
4694
    if (code == 0) {
4695
        level = 0;
4696
    } else {
4697
        if(IS_3IV1){
4698
            if(code==1)
4699
                level= 2*get_bits1(&s->gb)-1;
4700
            else{
4701
                if(get_bits1(&s->gb))
4702
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4703
                else
4704
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4705
            }
4706
        }else{
4707
            level = get_xbits(&s->gb, code);
4708
        }
4709

    
4710
        if (code > 8){
4711
            if(get_bits1(&s->gb)==0){ /* marker */
4712
                if(s->error_recognition>=2){
4713
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4714
                    return -1;
4715
                }
4716
            }
4717
        }
4718
    }
4719

    
4720
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4721
}
4722

    
4723
/**
4724
 * decodes a block.
4725
 * @return <0 if an error occurred
4726
 */
4727
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4728
                              int n, int coded, int intra, int rvlc)
4729
{
4730
    int level, i, last, run;
4731
    int dc_pred_dir;
4732
    RLTable * rl;
4733
    RL_VLC_ELEM * rl_vlc;
4734
    const uint8_t * scan_table;
4735
    int qmul, qadd;
4736

    
4737
    //Note intra & rvlc should be optimized away if this is inlined
4738

    
4739
    if(intra) {
4740
      if(s->use_intra_dc_vlc){
4741
        /* DC coef */
4742
        if(s->partitioned_frame){
4743
            level = s->dc_val[0][ s->block_index[n] ];
4744
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4745
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4746
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4747
        }else{
4748
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4749
            if (level < 0)
4750
                return -1;
4751
        }
4752
        block[0] = level;
4753
        i = 0;
4754
      }else{
4755
            i = -1;
4756
            ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4757
      }
4758
      if (!coded)
4759
          goto not_coded;
4760

    
4761
      if(rvlc){
4762
          rl = &rvlc_rl_intra;
4763
          rl_vlc = rvlc_rl_intra.rl_vlc[0];
4764
      }else{
4765
          rl = &rl_intra;
4766
          rl_vlc = rl_intra.rl_vlc[0];
4767
      }
4768
      if (s->ac_pred) {
4769
          if (dc_pred_dir == 0)
4770
              scan_table = s->intra_v_scantable.permutated; /* left */
4771
          else
4772
              scan_table = s->intra_h_scantable.permutated; /* top */
4773
      } else {
4774
            scan_table = s->intra_scantable.permutated;
4775
      }
4776
      qmul=1;
4777
      qadd=0;
4778
    } else {
4779
        i = -1;
4780
        if (!coded) {
4781
            s->block_last_index[n] = i;