Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ b2aba2e6

History | View | Annotate | Download (210 KB)

1
/*
2
 * H263/MPEG4 backend for ffmpeg encoder and decoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 * H263+ support.
5
 * Copyright (c) 2001 Juan J. Sierralta P.
6
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7
 *
8
 * ac prediction encoding, B-frame support, error resilience, optimizations,
9
 * qpel decoding, gmc decoding, interlaced decoding
10
 * by Michael Niedermayer <michaelni@gmx.at>
11
 *
12
 * This file is part of FFmpeg.
13
 *
14
 * FFmpeg is free software; you can redistribute it and/or
15
 * modify it under the terms of the GNU Lesser General Public
16
 * License as published by the Free Software Foundation; either
17
 * version 2.1 of the License, or (at your option) any later version.
18
 *
19
 * FFmpeg is distributed in the hope that it will be useful,
20
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22
 * Lesser General Public License for more details.
23
 *
24
 * You should have received a copy of the GNU Lesser General Public
25
 * License along with FFmpeg; if not, write to the Free Software
26
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27
 */
28

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
158
#ifdef CONFIG_ENCODERS
159

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

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

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

    
172
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
173
}
174

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

    
179
      align_put_bits(&s->pb);
180

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

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

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

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

    
245
    align_put_bits(&s->pb);
246

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
373
        ff_h263_encode_mba(s);
374

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

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

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

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

    
406
            last= j;
407
        }
408
    }
409

    
410
    return rate;
411
}
412

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

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

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

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

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

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

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

    
481
    return score < 0;
482
}
483

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

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

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

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

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

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

    
528
    ff_init_qscale_tab(s);
529

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

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

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

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

    
557
    ff_clean_h263_qscales(s);
558

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

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

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

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

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

    
588
#endif //CONFIG_ENCODERS
589

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

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

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

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

    
629
#undef tab_size
630
#undef tab_bias
631

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

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

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

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

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

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

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

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

    
739
#ifdef CONFIG_ENCODERS
740

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
940
                return;
941
            }
942

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1094
                    return;
1095
                }
1096
            }
1097

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1450
        }
1451
    }
1452

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1905
    }
1906
}
1907

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

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

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

    
1924
                len_tab[index]= 100;
1925

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

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

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

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

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

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

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

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

    
2008
                len_tab[index]= 100;
2009

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

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

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

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

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

    
2043
        init_uni_dc_tab();
2044

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2224
                assert(slevel != 0);
2225

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2333
    //FIXME levels
2334

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

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

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

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

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

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

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

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

    
2358
    if (!ENABLE_MPEG4_ENCODER)  return;
2359

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

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

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

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

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

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

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

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

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

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

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

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

    
2445
    ff_mpeg4_stuffing(&s->pb);
2446

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

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

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

    
2472
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2473

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

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

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

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

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

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

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

    
2514
#endif //CONFIG_ENCODERS
2515

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

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

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

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

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

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

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

    
2592
    return ret;
2593
}
2594

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

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

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

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

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

    
2653
}
2654

    
2655
#ifdef CONFIG_ENCODERS
2656

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

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

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

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

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

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

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

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

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

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

    
2881
    return len;
2882
}
2883

    
2884
#endif
2885

    
2886

    
2887
/***********************************************/
2888
/* decoding */
2889

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

    
2900
/* init vlcs */
2901

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

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

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

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

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

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

    
2976
    return mb_pos;
2977
}
2978

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

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

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

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

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

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

    
3018
        ff_h263_decode_mba(s);
3019

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

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

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

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

    
3042
    return 0;
3043
}
3044

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

    
3052
#ifdef CONFIG_ENCODERS
3053

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

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

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

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

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

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

    
3093
#endif //CONFIG_ENCODERS
3094

    
3095
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3096
    switch(s->pict_type){
3097
        case I_TYPE:
3098
            return 16;
3099
        case P_TYPE:
3100
        case S_TYPE:
3101
            return s->f_code+15;
3102
        case B_TYPE:
3103
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3104
        default:
3105
            return -1;
3106
    }
3107
}
3108

    
3109
#ifdef CONFIG_ENCODERS
3110

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

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

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

    
3123
#endif //CONFIG_ENCODERS
3124

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

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

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

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

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

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

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

    
3163
            s->gb= gb;
3164

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3242
            //FIXME reduced res stuff here
3243

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

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

    
3262
    return 0;
3263
}
3264

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

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

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

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

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

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

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

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

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

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

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

    
3337
    return -1;
3338
}
3339

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

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

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

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

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

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

    
3383
    return sum;
3384
}
3385

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

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

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

    
3409
            if(s->pict_type==I_TYPE){
3410
                int i;
3411

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3548
    return mb_num;
3549
}
3550

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3660
    s->mb_num_left= mb_num;
3661

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

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

    
3688
    return 0;
3689
}
3690

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3795
    assert(s->pict_type == P_TYPE);
3796

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

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

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

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

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

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

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

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

    
3870
    s->gb= gb;
3871
}
3872

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

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

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

    
3893
    assert(!s->h263_pred);
3894

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4044
        assert(!s->mb_intra);
4045

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4149
    return SLICE_OK;
4150
}
4151

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

    
4160
    assert(s->h263_pred);
4161

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4479
    return SLICE_OK;
4480
}
4481

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

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

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

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

    
4515
    }
4516
    return val;
4517
}
4518

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

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

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

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

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

    
4543
}
4544

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

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

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

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

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

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

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

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

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

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