← Back to branch summary

~diresu/blender/blender-command-port

« back to all changes in this revision

Viewing changes to extern/ffmpeg/libavcodec/msmpeg4.c

  • Committer: theeth
  • Date: 2008-10-14 16:52:04 UTC
  • Revision ID: vcs-imports@canonical.com-20081014165204-r32w2gm6s0osvdhn
copy back trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/ffmpeg/libavcodec/msmpeg4.c
 
1
/*
 
2
 * MSMPEG4 backend for ffmpeg encoder and decoder
 
3
 * Copyright (c) 2001 Fabrice Bellard.
 
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
 
5
 *
 
6
 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
 
7
 *
 
8
 * This file is part of FFmpeg.
 
9
 *
 
10
 * FFmpeg is free software; you can redistribute it and/or
 
11
 * modify it under the terms of the GNU Lesser General Public
 
12
 * License as published by the Free Software Foundation; either
 
13
 * version 2.1 of the License, or (at your option) any later version.
 
14
 *
 
15
 * FFmpeg is distributed in the hope that it will be useful,
 
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
18
 * Lesser General Public License for more details.
 
19
 *
 
20
 * You should have received a copy of the GNU Lesser General Public
 
21
 * License along with FFmpeg; if not, write to the Free Software
 
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
23
 */
 
24
 
 
25
/**
 
26
 * @file msmpeg4.c
 
27
 * MSMPEG4 backend for ffmpeg encoder and decoder.
 
28
 */
 
29
 
 
30
#include "avcodec.h"
 
31
#include "dsputil.h"
 
32
#include "mpegvideo.h"
 
33
 
 
34
/*
 
35
 * You can also call this codec : MPEG4 with a twist !
 
36
 *
 
37
 * TODO:
 
38
 *        - (encoding) select best mv table (two choices)
 
39
 *        - (encoding) select best vlc/dc table
 
40
 */
 
41
//#define DEBUG
 
42
 
 
43
#define DC_VLC_BITS 9
 
44
#define CBPY_VLC_BITS 6
 
45
#define INTER_INTRA_VLC_BITS 3
 
46
#define V1_INTRA_CBPC_VLC_BITS 6
 
47
#define V1_INTER_CBPC_VLC_BITS 6
 
48
#define V2_INTRA_CBPC_VLC_BITS 3
 
49
#define V2_MB_TYPE_VLC_BITS 7
 
50
#define MV_VLC_BITS 9
 
51
#define V2_MV_VLC_BITS 9
 
52
#define TEX_VLC_BITS 9
 
53
#define MB_NON_INTRA_VLC_BITS 9
 
54
#define MB_INTRA_VLC_BITS 9
 
55
 
 
56
#define II_BITRATE 128*1024
 
57
#define MBAC_BITRATE 50*1024
 
58
 
 
59
#define DEFAULT_INTER_INDEX 3
 
60
 
 
61
static uint32_t v2_dc_lum_table[512][2];
 
62
static uint32_t v2_dc_chroma_table[512][2];
 
63
 
 
64
void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
 
65
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
 
66
                                       int n, int coded, const uint8_t *scantable);
 
67
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
 
68
static int msmpeg4_decode_motion(MpegEncContext * s,
 
69
                                 int *mx_ptr, int *my_ptr);
 
70
static void init_h263_dc_for_msmpeg4(void);
 
71
static inline void msmpeg4_memsetw(short *tab, int val, int n);
 
72
#ifdef CONFIG_ENCODERS
 
73
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
 
74
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
 
75
#endif //CONFIG_ENCODERS
 
76
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
 
77
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
 
78
static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
 
79
 
 
80
/* vc1 externs */
 
81
extern uint8_t wmv3_dc_scale_table[32];
 
82
 
 
83
#ifdef DEBUG
 
84
int intra_count = 0;
 
85
int frame_count = 0;
 
86
#endif
 
87
 
 
88
#include "msmpeg4data.h"
 
89
 
 
90
#ifdef CONFIG_ENCODERS //strangely gcc includes this even if it is not references
 
91
static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
 
92
#endif //CONFIG_ENCODERS
 
93
 
 
94
static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
 
95
 
 
96
static void common_init(MpegEncContext * s)
 
97
{
 
98
    static int inited=0;
 
99
 
 
100
    switch(s->msmpeg4_version){
 
101
    case 1:
 
102
    case 2:
 
103
        s->y_dc_scale_table=
 
104
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 
105
        break;
 
106
    case 3:
 
107
        if(s->workaround_bugs){
 
108
            s->y_dc_scale_table= old_ff_y_dc_scale_table;
 
109
            s->c_dc_scale_table= old_ff_c_dc_scale_table;
 
110
        } else{
 
111
            s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
 
112
            s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
 
113
        }
 
114
        break;
 
115
    case 4:
 
116
    case 5:
 
117
        s->y_dc_scale_table= wmv1_y_dc_scale_table;
 
118
        s->c_dc_scale_table= wmv1_c_dc_scale_table;
 
119
        break;
 
120
#if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC1_DECODER)
 
121
    case 6:
 
122
        s->y_dc_scale_table= wmv3_dc_scale_table;
 
123
        s->c_dc_scale_table= wmv3_dc_scale_table;
 
124
        break;
 
125
#endif
 
126
 
 
127
    }
 
128
 
 
129
 
 
130
    if(s->msmpeg4_version>=4){
 
131
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , wmv1_scantable[1]);
 
132
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
 
133
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
 
134
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , wmv1_scantable[0]);
 
135
    }
 
136
    //Note the default tables are set in common_init in mpegvideo.c
 
137
 
 
138
    if(!inited){
 
139
        inited=1;
 
140
 
 
141
        init_h263_dc_for_msmpeg4();
 
142
    }
 
143
}
 
144
 
 
145
#ifdef CONFIG_ENCODERS
 
146
 
 
147
/* build the table which associate a (x,y) motion vector to a vlc */
 
148
static void init_mv_table(MVTable *tab)
 
149
{
 
150
    int i, x, y;
 
151
 
 
152
    tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
 
153
    /* mark all entries as not used */
 
154
    for(i=0;i<4096;i++)
 
155
        tab->table_mv_index[i] = tab->n;
 
156
 
 
157
    for(i=0;i<tab->n;i++) {
 
158
        x = tab->table_mvx[i];
 
159
        y = tab->table_mvy[i];
 
160
        tab->table_mv_index[(x << 6) | y] = i;
 
161
    }
 
162
}
 
163
 
 
164
void ff_code012(PutBitContext *pb, int n)
 
165
{
 
166
    if (n == 0) {
 
167
        put_bits(pb, 1, 0);
 
168
    } else {
 
169
        put_bits(pb, 1, 1);
 
170
        put_bits(pb, 1, (n >= 2));
 
171
    }
 
172
}
 
173
 
 
174
void ff_msmpeg4_encode_init(MpegEncContext *s)
 
175
{
 
176
    static int init_done=0;
 
177
    int i;
 
178
 
 
179
    common_init(s);
 
180
    if(s->msmpeg4_version>=4){
 
181
        s->min_qcoeff= -255;
 
182
        s->max_qcoeff=  255;
 
183
    }
 
184
 
 
185
    if (!init_done) {
 
186
        /* init various encoding tables */
 
187
        init_done = 1;
 
188
        init_mv_table(&mv_tables[0]);
 
189
        init_mv_table(&mv_tables[1]);
 
190
        for(i=0;i<NB_RL_TABLES;i++)
 
191
            init_rl(&rl_table[i], static_rl_table_store[i]);
 
192
 
 
193
        for(i=0; i<NB_RL_TABLES; i++){
 
194
            int level;
 
195
            for(level=0; level<=MAX_LEVEL; level++){
 
196
                int run;
 
197
                for(run=0; run<=MAX_RUN; run++){
 
198
                    int last;
 
199
                    for(last=0; last<2; last++){
 
200
                        rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[  i], last, run, level, 0);
 
201
                    }
 
202
                }
 
203
            }
 
204
        }
 
205
    }
 
206
}
 
207
 
 
208
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
 
209
    int size=0;
 
210
    int code;
 
211
    int run_diff= intra ? 0 : 1;
 
212
 
 
213
    code = get_rl_index(rl, last, run, level);
 
214
    size+= rl->table_vlc[code][1];
 
215
    if (code == rl->n) {
 
216
        int level1, run1;
 
217
 
 
218
        level1 = level - rl->max_level[last][run];
 
219
        if (level1 < 1)
 
220
            goto esc2;
 
221
        code = get_rl_index(rl, last, run, level1);
 
222
        if (code == rl->n) {
 
223
            esc2:
 
224
            size++;
 
225
            if (level > MAX_LEVEL)
 
226
                goto esc3;
 
227
            run1 = run - rl->max_run[last][level] - run_diff;
 
228
            if (run1 < 0)
 
229
                goto esc3;
 
230
            code = get_rl_index(rl, last, run1, level);
 
231
            if (code == rl->n) {
 
232
            esc3:
 
233
                /* third escape */
 
234
                size+=1+1+6+8;
 
235
            } else {
 
236
                /* second escape */
 
237
                size+= 1+1+ rl->table_vlc[code][1];
 
238
            }
 
239
        } else {
 
240
            /* first escape */
 
241
            size+= 1+1+ rl->table_vlc[code][1];
 
242
        }
 
243
    } else {
 
244
        size++;
 
245
    }
 
246
    return size;
 
247
}
 
248
 
 
249
void ff_find_best_tables(MpegEncContext * s)
 
250
{
 
251
    int i;
 
252
    int best       =-1, best_size       =9999999;
 
253
    int chroma_best=-1, best_chroma_size=9999999;
 
254
 
 
255
    for(i=0; i<3; i++){
 
256
        int level;
 
257
        int chroma_size=0;
 
258
        int size=0;
 
259
 
 
260
        if(i>0){// ;)
 
261
            size++;
 
262
            chroma_size++;
 
263
        }
 
264
        for(level=0; level<=MAX_LEVEL; level++){
 
265
            int run;
 
266
            for(run=0; run<=MAX_RUN; run++){
 
267
                int last;
 
268
                const int last_size= size + chroma_size;
 
269
                for(last=0; last<2; last++){
 
270
                    int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
 
271
                    int intra_luma_count  = s->ac_stats[1][0][level][run][last];
 
272
                    int intra_chroma_count= s->ac_stats[1][1][level][run][last];
 
273
 
 
274
                    if(s->pict_type==I_TYPE){
 
275
                        size       += intra_luma_count  *rl_length[i  ][level][run][last];
 
276
                        chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
 
277
                    }else{
 
278
                        size+=        intra_luma_count  *rl_length[i  ][level][run][last]
 
279
                                     +intra_chroma_count*rl_length[i+3][level][run][last]
 
280
                                     +inter_count       *rl_length[i+3][level][run][last];
 
281
                    }
 
282
                }
 
283
                if(last_size == size+chroma_size) break;
 
284
            }
 
285
        }
 
286
        if(size<best_size){
 
287
            best_size= size;
 
288
            best= i;
 
289
        }
 
290
        if(chroma_size<best_chroma_size){
 
291
            best_chroma_size= chroma_size;
 
292
            chroma_best= i;
 
293
        }
 
294
    }
 
295
 
 
296
//    printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
 
297
//           s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
 
298
 
 
299
    if(s->pict_type==P_TYPE) chroma_best= best;
 
300
 
 
301
    memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
 
302
 
 
303
    s->rl_table_index       =        best;
 
304
    s->rl_chroma_table_index= chroma_best;
 
305
 
 
306
    if(s->pict_type != s->last_non_b_pict_type){
 
307
        s->rl_table_index= 2;
 
308
        if(s->pict_type==I_TYPE)
 
309
            s->rl_chroma_table_index= 1;
 
310
        else
 
311
            s->rl_chroma_table_index= 2;
 
312
    }
 
313
 
 
314
}
 
315
 
 
316
/* write MSMPEG4 compatible frame header */
 
317
void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
 
318
{
 
319
    ff_find_best_tables(s);
 
320
 
 
321
    align_put_bits(&s->pb);
 
322
    put_bits(&s->pb, 2, s->pict_type - 1);
 
323
 
 
324
    put_bits(&s->pb, 5, s->qscale);
 
325
    if(s->msmpeg4_version<=2){
 
326
        s->rl_table_index = 2;
 
327
        s->rl_chroma_table_index = 2;
 
328
    }
 
329
 
 
330
    s->dc_table_index = 1;
 
331
    s->mv_table_index = 1; /* only if P frame */
 
332
    s->use_skip_mb_code = 1; /* only if P frame */
 
333
    s->per_mb_rl_table = 0;
 
334
    if(s->msmpeg4_version==4)
 
335
        s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
 
336
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
 
337
 
 
338
    if (s->pict_type == I_TYPE) {
 
339
        s->slice_height= s->mb_height/1;
 
340
        put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
 
341
 
 
342
        if(s->msmpeg4_version==4){
 
343
            msmpeg4_encode_ext_header(s);
 
344
            if(s->bit_rate>MBAC_BITRATE)
 
345
                put_bits(&s->pb, 1, s->per_mb_rl_table);
 
346
        }
 
347
 
 
348
        if(s->msmpeg4_version>2){
 
349
            if(!s->per_mb_rl_table){
 
350
                ff_code012(&s->pb, s->rl_chroma_table_index);
 
351
                ff_code012(&s->pb, s->rl_table_index);
 
352
            }
 
353
 
 
354
            put_bits(&s->pb, 1, s->dc_table_index);
 
355
        }
 
356
    } else {
 
357
        put_bits(&s->pb, 1, s->use_skip_mb_code);
 
358
 
 
359
        if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
 
360
            put_bits(&s->pb, 1, s->per_mb_rl_table);
 
361
 
 
362
        if(s->msmpeg4_version>2){
 
363
            if(!s->per_mb_rl_table)
 
364
                ff_code012(&s->pb, s->rl_table_index);
 
365
 
 
366
            put_bits(&s->pb, 1, s->dc_table_index);
 
367
 
 
368
            put_bits(&s->pb, 1, s->mv_table_index);
 
369
        }
 
370
    }
 
371
 
 
372
    s->esc3_level_length= 0;
 
373
    s->esc3_run_length= 0;
 
374
 
 
375
#ifdef DEBUG
 
376
    intra_count = 0;
 
377
    av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
 
378
#endif
 
379
}
 
380
 
 
381
void msmpeg4_encode_ext_header(MpegEncContext * s)
 
382
{
 
383
        put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
 
384
 
 
385
        put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
 
386
 
 
387
        if(s->msmpeg4_version>=3)
 
388
            put_bits(&s->pb, 1, s->flipflop_rounding);
 
389
        else
 
390
            assert(s->flipflop_rounding==0);
 
391
}
 
392
 
 
393
#endif //CONFIG_ENCODERS
 
394
 
 
395
/* predict coded block */
 
396
static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
 
397
{
 
398
    int xy, wrap, pred, a, b, c;
 
399
 
 
400
    xy = s->block_index[n];
 
401
    wrap = s->b8_stride;
 
402
 
 
403
    /* B C
 
404
     * A X
 
405
     */
 
406
    a = s->coded_block[xy - 1       ];
 
407
    b = s->coded_block[xy - 1 - wrap];
 
408
    c = s->coded_block[xy     - wrap];
 
409
 
 
410
    if (b == c) {
 
411
        pred = a;
 
412
    } else {
 
413
        pred = c;
 
414
    }
 
415
 
 
416
    /* store value */
 
417
    *coded_block_ptr = &s->coded_block[xy];
 
418
 
 
419
    return pred;
 
420
}
 
421
 
 
422
#ifdef CONFIG_ENCODERS
 
423
 
 
424
static void msmpeg4_encode_motion(MpegEncContext * s,
 
425
                                  int mx, int my)
 
426
{
 
427
    int code;
 
428
    MVTable *mv;
 
429
 
 
430
    /* modulo encoding */
 
431
    /* WARNING : you cannot reach all the MVs even with the modulo
 
432
       encoding. This is a somewhat strange compromise they took !!!  */
 
433
    if (mx <= -64)
 
434
        mx += 64;
 
435
    else if (mx >= 64)
 
436
        mx -= 64;
 
437
    if (my <= -64)
 
438
        my += 64;
 
439
    else if (my >= 64)
 
440
        my -= 64;
 
441
 
 
442
    mx += 32;
 
443
    my += 32;
 
444
#if 0
 
445
    if ((unsigned)mx >= 64 ||
 
446
        (unsigned)my >= 64)
 
447
        av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
 
448
#endif
 
449
    mv = &mv_tables[s->mv_table_index];
 
450
 
 
451
    code = mv->table_mv_index[(mx << 6) | my];
 
452
    put_bits(&s->pb,
 
453
             mv->table_mv_bits[code],
 
454
             mv->table_mv_code[code]);
 
455
    if (code == mv->n) {
 
456
        /* escape : code literally */
 
457
        put_bits(&s->pb, 6, mx);
 
458
        put_bits(&s->pb, 6, my);
 
459
    }
 
460
}
 
461
 
 
462
static inline void handle_slices(MpegEncContext *s){
 
463
    if (s->mb_x == 0) {
 
464
        if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
 
465
            if(s->msmpeg4_version < 4){
 
466
                ff_mpeg4_clean_buffers(s);
 
467
            }
 
468
            s->first_slice_line = 1;
 
469
        } else {
 
470
            s->first_slice_line = 0;
 
471
        }
 
472
    }
 
473
}
 
474
 
 
475
void msmpeg4_encode_mb(MpegEncContext * s,
 
476
                       DCTELEM block[6][64],
 
477
                       int motion_x, int motion_y)
 
478
{
 
479
    int cbp, coded_cbp, i;
 
480
    int pred_x, pred_y;
 
481
    uint8_t *coded_block;
 
482
 
 
483
    handle_slices(s);
 
484
 
 
485
    if (!s->mb_intra) {
 
486
        /* compute cbp */
 
487
        cbp = 0;
 
488
        for (i = 0; i < 6; i++) {
 
489
            if (s->block_last_index[i] >= 0)
 
490
                cbp |= 1 << (5 - i);
 
491
        }
 
492
        if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
 
493
            /* skip macroblock */
 
494
            put_bits(&s->pb, 1, 1);
 
495
            s->last_bits++;
 
496
            s->misc_bits++;
 
497
            s->skip_count++;
 
498
 
 
499
            return;
 
500
        }
 
501
        if (s->use_skip_mb_code)
 
502
            put_bits(&s->pb, 1, 0);     /* mb coded */
 
503
 
 
504
        if(s->msmpeg4_version<=2){
 
505
            put_bits(&s->pb,
 
506
                     v2_mb_type[cbp&3][1],
 
507
                     v2_mb_type[cbp&3][0]);
 
508
            if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
 
509
            else             coded_cbp= cbp;
 
510
 
 
511
            put_bits(&s->pb,
 
512
                     cbpy_tab[coded_cbp>>2][1],
 
513
                     cbpy_tab[coded_cbp>>2][0]);
 
514
 
 
515
            s->misc_bits += get_bits_diff(s);
 
516
 
 
517
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 
518
            msmpeg4v2_encode_motion(s, motion_x - pred_x);
 
519
            msmpeg4v2_encode_motion(s, motion_y - pred_y);
 
520
        }else{
 
521
            put_bits(&s->pb,
 
522
                     table_mb_non_intra[cbp + 64][1],
 
523
                     table_mb_non_intra[cbp + 64][0]);
 
524
 
 
525
            s->misc_bits += get_bits_diff(s);
 
526
 
 
527
            /* motion vector */
 
528
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 
529
            msmpeg4_encode_motion(s, motion_x - pred_x,
 
530
                                  motion_y - pred_y);
 
531
        }
 
532
 
 
533
        s->mv_bits += get_bits_diff(s);
 
534
 
 
535
        for (i = 0; i < 6; i++) {
 
536
            ff_msmpeg4_encode_block(s, block[i], i);
 
537
        }
 
538
        s->p_tex_bits += get_bits_diff(s);
 
539
    } else {
 
540
        /* compute cbp */
 
541
        cbp = 0;
 
542
        coded_cbp = 0;
 
543
        for (i = 0; i < 6; i++) {
 
544
            int val, pred;
 
545
            val = (s->block_last_index[i] >= 1);
 
546
            cbp |= val << (5 - i);
 
547
            if (i < 4) {
 
548
                /* predict value for close blocks only for luma */
 
549
                pred = coded_block_pred(s, i, &coded_block);
 
550
                *coded_block = val;
 
551
                val = val ^ pred;
 
552
            }
 
553
            coded_cbp |= val << (5 - i);
 
554
        }
 
555
#if 0
 
556
        if (coded_cbp)
 
557
            printf("cbp=%x %x\n", cbp, coded_cbp);
 
558
#endif
 
559
 
 
560
        if(s->msmpeg4_version<=2){
 
561
            if (s->pict_type == I_TYPE) {
 
562
                put_bits(&s->pb,
 
563
                         v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
 
564
            } else {
 
565
                if (s->use_skip_mb_code)
 
566
                    put_bits(&s->pb, 1, 0);     /* mb coded */
 
567
                put_bits(&s->pb,
 
568
                         v2_mb_type[(cbp&3) + 4][1],
 
569
                         v2_mb_type[(cbp&3) + 4][0]);
 
570
            }
 
571
            put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
 
572
            put_bits(&s->pb,
 
573
                     cbpy_tab[cbp>>2][1],
 
574
                     cbpy_tab[cbp>>2][0]);
 
575
        }else{
 
576
            if (s->pict_type == I_TYPE) {
 
577
                put_bits(&s->pb,
 
578
                         ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
 
579
            } else {
 
580
                if (s->use_skip_mb_code)
 
581
                    put_bits(&s->pb, 1, 0);     /* mb coded */
 
582
                put_bits(&s->pb,
 
583
                         table_mb_non_intra[cbp][1],
 
584
                         table_mb_non_intra[cbp][0]);
 
585
            }
 
586
            put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
 
587
            if(s->inter_intra_pred){
 
588
                s->h263_aic_dir=0;
 
589
                put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
 
590
            }
 
591
        }
 
592
        s->misc_bits += get_bits_diff(s);
 
593
 
 
594
        for (i = 0; i < 6; i++) {
 
595
            ff_msmpeg4_encode_block(s, block[i], i);
 
596
        }
 
597
        s->i_tex_bits += get_bits_diff(s);
 
598
        s->i_count++;
 
599
    }
 
600
}
 
601
 
 
602
#endif //CONFIG_ENCODERS
 
603
 
 
604
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
 
605
                                    int32_t **dc_val_ptr)
 
606
{
 
607
    int i;
 
608
 
 
609
    if (n < 4) {
 
610
        i= 0;
 
611
    } else {
 
612
        i= n-3;
 
613
    }
 
614
 
 
615
    *dc_val_ptr= &s->last_dc[i];
 
616
    return s->last_dc[i];
 
617
}
 
618
 
 
619
static int get_dc(uint8_t *src, int stride, int scale)
 
620
{
 
621
    int y;
 
622
    int sum=0;
 
623
    for(y=0; y<8; y++){
 
624
        int x;
 
625
        for(x=0; x<8; x++){
 
626
            sum+=src[x + y*stride];
 
627
        }
 
628
    }
 
629
    return FASTDIV((sum + (scale>>1)), scale);
 
630
}
 
631
 
 
632
/* dir = 0: left, dir = 1: top prediction */
 
633
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
 
634
                             int16_t **dc_val_ptr, int *dir_ptr)
 
635
{
 
636
    int a, b, c, wrap, pred, scale;
 
637
    int16_t *dc_val;
 
638
 
 
639
    /* find prediction */
 
640
    if (n < 4) {
 
641
        scale = s->y_dc_scale;
 
642
    } else {
 
643
        scale = s->c_dc_scale;
 
644
    }
 
645
 
 
646
    wrap = s->block_wrap[n];
 
647
    dc_val= s->dc_val[0] + s->block_index[n];
 
648
 
 
649
    /* B C
 
650
     * A X
 
651
     */
 
652
    a = dc_val[ - 1];
 
653
    b = dc_val[ - 1 - wrap];
 
654
    c = dc_val[ - wrap];
 
655
 
 
656
    if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
 
657
        b=c=1024;
 
658
    }
 
659
 
 
660
    /* XXX: the following solution consumes divisions, but it does not
 
661
       necessitate to modify mpegvideo.c. The problem comes from the
 
662
       fact they decided to store the quantized DC (which would lead
 
663
       to problems if Q could vary !) */
 
664
#if (defined(ARCH_X86)) && !defined PIC
 
665
    asm volatile(
 
666
        "movl %3, %%eax         \n\t"
 
667
        "shrl $1, %%eax         \n\t"
 
668
        "addl %%eax, %2         \n\t"
 
669
        "addl %%eax, %1         \n\t"
 
670
        "addl %0, %%eax         \n\t"
 
671
        "mull %4                \n\t"
 
672
        "movl %%edx, %0         \n\t"
 
673
        "movl %1, %%eax         \n\t"
 
674
        "mull %4                \n\t"
 
675
        "movl %%edx, %1         \n\t"
 
676
        "movl %2, %%eax         \n\t"
 
677
        "mull %4                \n\t"
 
678
        "movl %%edx, %2         \n\t"
 
679
        : "+b" (a), "+c" (b), "+D" (c)
 
680
        : "g" (scale), "S" (ff_inverse[scale])
 
681
        : "%eax", "%edx"
 
682
    );
 
683
#else
 
684
    /* #elif defined (ARCH_ALPHA) */
 
685
    /* Divisions are extremely costly on Alpha; optimize the most
 
686
       common case. But they are costly everywhere...
 
687
     */
 
688
    if (scale == 8) {
 
689
        a = (a + (8 >> 1)) / 8;
 
690
        b = (b + (8 >> 1)) / 8;
 
691
        c = (c + (8 >> 1)) / 8;
 
692
    } else {
 
693
        a = FASTDIV((a + (scale >> 1)), scale);
 
694
        b = FASTDIV((b + (scale >> 1)), scale);
 
695
        c = FASTDIV((c + (scale >> 1)), scale);
 
696
    }
 
697
#endif
 
698
    /* XXX: WARNING: they did not choose the same test as MPEG4. This
 
699
       is very important ! */
 
700
    if(s->msmpeg4_version>3){
 
701
        if(s->inter_intra_pred){
 
702
            uint8_t *dest;
 
703
            int wrap;
 
704
 
 
705
            if(n==1){
 
706
                pred=a;
 
707
                *dir_ptr = 0;
 
708
            }else if(n==2){
 
709
                pred=c;
 
710
                *dir_ptr = 1;
 
711
            }else if(n==3){
 
712
                if (abs(a - b) < abs(b - c)) {
 
713
                    pred = c;
 
714
                    *dir_ptr = 1;
 
715
                } else {
 
716
                    pred = a;
 
717
                    *dir_ptr = 0;
 
718
                }
 
719
            }else{
 
720
                if(n<4){
 
721
                    wrap= s->linesize;
 
722
                    dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8*  wrap ) + ((n&1) + 2*s->mb_x) * 8;
 
723
                }else{
 
724
                    wrap= s->uvlinesize;
 
725
                    dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
 
726
                }
 
727
                if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
 
728
                else           a= get_dc(dest-8, wrap, scale*8);
 
729
                if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
 
730
                else           c= get_dc(dest-8*wrap, wrap, scale*8);
 
731
 
 
732
                if (s->h263_aic_dir==0) {
 
733
                    pred= a;
 
734
                    *dir_ptr = 0;
 
735
                }else if (s->h263_aic_dir==1) {
 
736
                    if(n==0){
 
737
                        pred= c;
 
738
                        *dir_ptr = 1;
 
739
                    }else{
 
740
                        pred= a;
 
741
                        *dir_ptr = 0;
 
742
                    }
 
743
                }else if (s->h263_aic_dir==2) {
 
744
                    if(n==0){
 
745
                        pred= a;
 
746
                        *dir_ptr = 0;
 
747
                    }else{
 
748
                        pred= c;
 
749
                        *dir_ptr = 1;
 
750
                    }
 
751
                } else {
 
752
                    pred= c;
 
753
                    *dir_ptr = 1;
 
754
                }
 
755
            }
 
756
        }else{
 
757
            if (abs(a - b) < abs(b - c)) {
 
758
                pred = c;
 
759
                *dir_ptr = 1;
 
760
            } else {
 
761
                pred = a;
 
762
                *dir_ptr = 0;
 
763
            }
 
764
        }
 
765
    }else{
 
766
        if (abs(a - b) <= abs(b - c)) {
 
767
            pred = c;
 
768
            *dir_ptr = 1;
 
769
        } else {
 
770
            pred = a;
 
771
            *dir_ptr = 0;
 
772
        }
 
773
    }
 
774
 
 
775
    /* update predictor */
 
776
    *dc_val_ptr = &dc_val[0];
 
777
    return pred;
 
778
}
 
779
 
 
780
#define DC_MAX 119
 
781
 
 
782
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
 
783
{
 
784
    int sign, code;
 
785
    int pred, extquant;
 
786
    int extrabits = 0;
 
787
 
 
788
    if(s->msmpeg4_version==1){
 
789
        int32_t *dc_val;
 
790
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
 
791
 
 
792
        /* update predictor */
 
793
        *dc_val= level;
 
794
    }else{
 
795
        int16_t *dc_val;
 
796
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
 
797
 
 
798
        /* update predictor */
 
799
        if (n < 4) {
 
800
            *dc_val = level * s->y_dc_scale;
 
801
        } else {
 
802
            *dc_val = level * s->c_dc_scale;
 
803
        }
 
804
    }
 
805
 
 
806
    /* do the prediction */
 
807
    level -= pred;
 
808
 
 
809
    if(s->msmpeg4_version<=2){
 
810
        if (n < 4) {
 
811
            put_bits(&s->pb,
 
812
                     v2_dc_lum_table[level+256][1],
 
813
                     v2_dc_lum_table[level+256][0]);
 
814
        }else{
 
815
            put_bits(&s->pb,
 
816
                     v2_dc_chroma_table[level+256][1],
 
817
                     v2_dc_chroma_table[level+256][0]);
 
818
        }
 
819
    }else{
 
820
        sign = 0;
 
821
        if (level < 0) {
 
822
            level = -level;
 
823
            sign = 1;
 
824
        }
 
825
        code = level;
 
826
        if (code > DC_MAX)
 
827
            code = DC_MAX;
 
828
        else if( s->msmpeg4_version>=6 ) {
 
829
            if( s->qscale == 1 ) {
 
830
                extquant = (level + 3) & 0x3;
 
831
                code  = ((level+3)>>2);
 
832
            } else if( s->qscale == 2 ) {
 
833
                extquant = (level + 1) & 0x1;
 
834
                code  = ((level+1)>>1);
 
835
            }
 
836
        }
 
837
 
 
838
        if (s->dc_table_index == 0) {
 
839
            if (n < 4) {
 
840
                put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
 
841
            } else {
 
842
                put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
 
843
            }
 
844
        } else {
 
845
            if (n < 4) {
 
846
                put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
 
847
            } else {
 
848
                put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
 
849
            }
 
850
        }
 
851
 
 
852
        if(s->msmpeg4_version>=6 && s->qscale<=2)
 
853
            extrabits = 3 - s->qscale;
 
854
 
 
855
        if (code == DC_MAX)
 
856
            put_bits(&s->pb, 8 + extrabits, level);
 
857
        else if(extrabits > 0)//== VC1 && s->qscale<=2
 
858
            put_bits(&s->pb, extrabits, extquant);
 
859
 
 
860
        if (level != 0) {
 
861
            put_bits(&s->pb, 1, sign);
 
862
        }
 
863
    }
 
864
}
 
865
 
 
866
/* Encoding of a block. Very similar to MPEG4 except for a different
 
867
   escape coding (same as H263) and more vlc tables.
 
868
 */
 
869
void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
 
870
{
 
871
    int level, run, last, i, j, last_index;
 
872
    int last_non_zero, sign, slevel;
 
873
    int code, run_diff, dc_pred_dir;
 
874
    const RLTable *rl;
 
875
    const uint8_t *scantable;
 
876
 
 
877
    if (s->mb_intra) {
 
878
        msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
 
879
        i = 1;
 
880
        if (n < 4) {
 
881
            rl = &rl_table[s->rl_table_index];
 
882
        } else {
 
883
            rl = &rl_table[3 + s->rl_chroma_table_index];
 
884
        }
 
885
        run_diff = s->msmpeg4_version>=4;
 
886
        scantable= s->intra_scantable.permutated;
 
887
    } else {
 
888
        i = 0;
 
889
        rl = &rl_table[3 + s->rl_table_index];
 
890
        if(s->msmpeg4_version<=2)
 
891
            run_diff = 0;
 
892
        else
 
893
            run_diff = 1;
 
894
        scantable= s->inter_scantable.permutated;
 
895
    }
 
896
 
 
897
    /* recalculate block_last_index for M$ wmv1 */
 
898
    if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
 
899
        for(last_index=63; last_index>=0; last_index--){
 
900
            if(block[scantable[last_index]]) break;
 
901
        }
 
902
        s->block_last_index[n]= last_index;
 
903
    }else
 
904
        last_index = s->block_last_index[n];
 
905
    /* AC coefs */
 
906
    last_non_zero = i - 1;
 
907
    for (; i <= last_index; i++) {
 
908
        j = scantable[i];
 
909
        level = block[j];
 
910
        if (level) {
 
911
            run = i - last_non_zero - 1;
 
912
            last = (i == last_index);
 
913
            sign = 0;
 
914
            slevel = level;
 
915
            if (level < 0) {
 
916
                sign = 1;
 
917
                level = -level;
 
918
            }
 
919
 
 
920
            if(level<=MAX_LEVEL && run<=MAX_RUN){
 
921
                s->ac_stats[s->mb_intra][n>3][level][run][last]++;
 
922
            }
 
923
#if 0
 
924
else
 
925
    s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
 
926
#endif
 
927
            code = get_rl_index(rl, last, run, level);
 
928
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 
929
            if (code == rl->n) {
 
930
                int level1, run1;
 
931
 
 
932
                level1 = level - rl->max_level[last][run];
 
933
                if (level1 < 1)
 
934
                    goto esc2;
 
935
                code = get_rl_index(rl, last, run, level1);
 
936
                if (code == rl->n) {
 
937
                esc2:
 
938
                    put_bits(&s->pb, 1, 0);
 
939
                    if (level > MAX_LEVEL)
 
940
                        goto esc3;
 
941
                    run1 = run - rl->max_run[last][level] - run_diff;
 
942
                    if (run1 < 0)
 
943
                        goto esc3;
 
944
                    code = get_rl_index(rl, last, run1+1, level);
 
945
                    if (s->msmpeg4_version == 4 && code == rl->n)
 
946
                        goto esc3;
 
947
                    code = get_rl_index(rl, last, run1, level);
 
948
                    if (code == rl->n) {
 
949
                    esc3:
 
950
                        /* third escape */
 
951
                        put_bits(&s->pb, 1, 0);
 
952
                        put_bits(&s->pb, 1, last);
 
953
                        if(s->msmpeg4_version>=4){
 
954
                            if(s->esc3_level_length==0){
 
955
                                s->esc3_level_length=8;
 
956
                                s->esc3_run_length= 6;
 
957
                                //ESCLVLSZ + ESCRUNSZ
 
958
                                if(s->qscale<8)
 
959
                                    put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
 
960
                                else
 
961
                                    put_bits(&s->pb, 8, 3);
 
962
                            }
 
963
                            put_bits(&s->pb, s->esc3_run_length, run);
 
964
                            put_bits(&s->pb, 1, sign);
 
965
                            put_bits(&s->pb, s->esc3_level_length, level);
 
966
                        }else{
 
967
                            put_bits(&s->pb, 6, run);
 
968
                            put_bits(&s->pb, 8, slevel & 0xff);
 
969
                        }
 
970
                    } else {
 
971
                        /* second escape */
 
972
                        put_bits(&s->pb, 1, 1);
 
973
                        put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 
974
                        put_bits(&s->pb, 1, sign);
 
975
                    }
 
976
                } else {
 
977
                    /* first escape */
 
978
                    put_bits(&s->pb, 1, 1);
 
979
                    put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 
980
                    put_bits(&s->pb, 1, sign);
 
981
                }
 
982
            } else {
 
983
                put_bits(&s->pb, 1, sign);
 
984
            }
 
985
            last_non_zero = i;
 
986
        }
 
987
    }
 
988
}
 
989
 
 
990
/****************************************/
 
991
/* decoding stuff */
 
992
 
 
993
static VLC mb_non_intra_vlc[4];
 
994
static VLC v2_dc_lum_vlc;
 
995
static VLC v2_dc_chroma_vlc;
 
996
static VLC cbpy_vlc;
 
997
static VLC v2_intra_cbpc_vlc;
 
998
static VLC v2_mb_type_vlc;
 
999
static VLC v2_mv_vlc;
 
1000
static VLC v1_intra_cbpc_vlc;
 
1001
static VLC v1_inter_cbpc_vlc;
 
1002
static VLC inter_intra_vlc;
 
1003
 
 
1004
/* This table is practically identical to the one from h263
 
1005
 * except that it is inverted. */
 
1006
static void init_h263_dc_for_msmpeg4(void)
 
1007
{
 
1008
        int level, uni_code, uni_len;
 
1009
 
 
1010
        for(level=-256; level<256; level++){
 
1011
            int size, v, l;
 
1012
            /* find number of bits */
 
1013
            size = 0;
 
1014
            v = abs(level);
 
1015
            while (v) {
 
1016
                v >>= 1;
 
1017
                    size++;
 
1018
            }
 
1019
 
 
1020
            if (level < 0)
 
1021
                l= (-level) ^ ((1 << size) - 1);
 
1022
            else
 
1023
                l= level;
 
1024
 
 
1025
            /* luminance h263 */
 
1026
            uni_code= DCtab_lum[size][0];
 
1027
            uni_len = DCtab_lum[size][1];
 
1028
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
 
1029
 
 
1030
            if (size > 0) {
 
1031
                uni_code<<=size; uni_code|=l;
 
1032
                uni_len+=size;
 
1033
                if (size > 8){
 
1034
                    uni_code<<=1; uni_code|=1;
 
1035
                    uni_len++;
 
1036
                }
 
1037
            }
 
1038
            v2_dc_lum_table[level+256][0]= uni_code;
 
1039
            v2_dc_lum_table[level+256][1]= uni_len;
 
1040
 
 
1041
            /* chrominance h263 */
 
1042
            uni_code= DCtab_chrom[size][0];
 
1043
            uni_len = DCtab_chrom[size][1];
 
1044
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
 
1045
 
 
1046
            if (size > 0) {
 
1047
                uni_code<<=size; uni_code|=l;
 
1048
                uni_len+=size;
 
1049
                if (size > 8){
 
1050
                    uni_code<<=1; uni_code|=1;
 
1051
                    uni_len++;
 
1052
                }
 
1053
            }
 
1054
            v2_dc_chroma_table[level+256][0]= uni_code;
 
1055
            v2_dc_chroma_table[level+256][1]= uni_len;
 
1056
 
 
1057
        }
 
1058
}
 
1059
 
 
1060
/* init all vlc decoding tables */
 
1061
int ff_msmpeg4_decode_init(MpegEncContext *s)
 
1062
{
 
1063
    static int done = 0;
 
1064
    int i;
 
1065
    MVTable *mv;
 
1066
 
 
1067
    common_init(s);
 
1068
 
 
1069
    if (!done) {
 
1070
        done = 1;
 
1071
 
 
1072
        for(i=0;i<NB_RL_TABLES;i++) {
 
1073
            init_rl(&rl_table[i], static_rl_table_store[i]);
 
1074
            init_vlc_rl(&rl_table[i], 1);
 
1075
        }
 
1076
        for(i=0;i<2;i++) {
 
1077
            mv = &mv_tables[i];
 
1078
            init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
 
1079
                     mv->table_mv_bits, 1, 1,
 
1080
                     mv->table_mv_code, 2, 2, 1);
 
1081
        }
 
1082
 
 
1083
        init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
 
1084
                 &ff_table0_dc_lum[0][1], 8, 4,
 
1085
                 &ff_table0_dc_lum[0][0], 8, 4, 1);
 
1086
        init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
 
1087
                 &ff_table0_dc_chroma[0][1], 8, 4,
 
1088
                 &ff_table0_dc_chroma[0][0], 8, 4, 1);
 
1089
        init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
 
1090
                 &ff_table1_dc_lum[0][1], 8, 4,
 
1091
                 &ff_table1_dc_lum[0][0], 8, 4, 1);
 
1092
        init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
 
1093
                 &ff_table1_dc_chroma[0][1], 8, 4,
 
1094
                 &ff_table1_dc_chroma[0][0], 8, 4, 1);
 
1095
 
 
1096
        init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
 
1097
                 &v2_dc_lum_table[0][1], 8, 4,
 
1098
                 &v2_dc_lum_table[0][0], 8, 4, 1);
 
1099
        init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
 
1100
                 &v2_dc_chroma_table[0][1], 8, 4,
 
1101
                 &v2_dc_chroma_table[0][0], 8, 4, 1);
 
1102
 
 
1103
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
 
1104
                 &cbpy_tab[0][1], 2, 1,
 
1105
                 &cbpy_tab[0][0], 2, 1, 1);
 
1106
        init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
 
1107
                 &v2_intra_cbpc[0][1], 2, 1,
 
1108
                 &v2_intra_cbpc[0][0], 2, 1, 1);
 
1109
        init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
 
1110
                 &v2_mb_type[0][1], 2, 1,
 
1111
                 &v2_mb_type[0][0], 2, 1, 1);
 
1112
        init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
 
1113
                 &mvtab[0][1], 2, 1,
 
1114
                 &mvtab[0][0], 2, 1, 1);
 
1115
 
 
1116
        for(i=0; i<4; i++){
 
1117
            init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
 
1118
                     &wmv2_inter_table[i][0][1], 8, 4,
 
1119
                     &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
 
1120
        }
 
1121
 
 
1122
        init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
 
1123
                 &ff_msmp4_mb_i_table[0][1], 4, 2,
 
1124
                 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
 
1125
 
 
1126
        init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
 
1127
                 intra_MCBPC_bits, 1, 1,
 
1128
                 intra_MCBPC_code, 1, 1, 1);
 
1129
        init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
 
1130
                 inter_MCBPC_bits, 1, 1,
 
1131
                 inter_MCBPC_code, 1, 1, 1);
 
1132
 
 
1133
        init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
 
1134
                 &table_inter_intra[0][1], 2, 1,
 
1135
                 &table_inter_intra[0][0], 2, 1, 1);
 
1136
    }
 
1137
 
 
1138
    switch(s->msmpeg4_version){
 
1139
    case 1:
 
1140
    case 2:
 
1141
        s->decode_mb= msmpeg4v12_decode_mb;
 
1142
        break;
 
1143
    case 3:
 
1144
    case 4:
 
1145
        s->decode_mb= msmpeg4v34_decode_mb;
 
1146
        break;
 
1147
    case 5:
 
1148
        s->decode_mb= wmv2_decode_mb;
 
1149
    case 6:
 
1150
        //FIXME + TODO VC1 decode mb
 
1151
        break;
 
1152
    }
 
1153
 
 
1154
    s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
 
1155
 
 
1156
    return 0;
 
1157
}
 
1158
 
 
1159
int msmpeg4_decode_picture_header(MpegEncContext * s)
 
1160
{
 
1161
    int code;
 
1162
 
 
1163
#if 0
 
1164
{
 
1165
int i;
 
1166
for(i=0; i<s->gb.size_in_bits; i++)
 
1167
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
 
1168
//    get_bits1(&s->gb);
 
1169
av_log(s->avctx, AV_LOG_DEBUG, "END\n");
 
1170
return -1;
 
1171
}
 
1172
#endif
 
1173
 
 
1174
    if(s->msmpeg4_version==1){
 
1175
        int start_code, num;
 
1176
        start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
 
1177
        if(start_code!=0x00000100){
 
1178
            av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
 
1179
            return -1;
 
1180
        }
 
1181
 
 
1182
        num= get_bits(&s->gb, 5); // frame number */
 
1183
    }
 
1184
 
 
1185
    s->pict_type = get_bits(&s->gb, 2) + 1;
 
1186
    if (s->pict_type != I_TYPE &&
 
1187
        s->pict_type != P_TYPE){
 
1188
        av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
 
1189
        return -1;
 
1190
    }
 
1191
#if 0
 
1192
{
 
1193
    static int had_i=0;
 
1194
    if(s->pict_type == I_TYPE) had_i=1;
 
1195
    if(!had_i) return -1;
 
1196
}
 
1197
#endif
 
1198
    s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
 
1199
    if(s->qscale==0){
 
1200
        av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
 
1201
        return -1;
 
1202
    }
 
1203
 
 
1204
    if (s->pict_type == I_TYPE) {
 
1205
        code = get_bits(&s->gb, 5);
 
1206
        if(s->msmpeg4_version==1){
 
1207
            if(code==0 || code>s->mb_height){
 
1208
                av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
 
1209
                return -1;
 
1210
            }
 
1211
 
 
1212
            s->slice_height = code;
 
1213
        }else{
 
1214
            /* 0x17: one slice, 0x18: two slices, ... */
 
1215
            if (code < 0x17){
 
1216
                av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
 
1217
                return -1;
 
1218
            }
 
1219
 
 
1220
            s->slice_height = s->mb_height / (code - 0x16);
 
1221
        }
 
1222
 
 
1223
        switch(s->msmpeg4_version){
 
1224
        case 1:
 
1225
        case 2:
 
1226
            s->rl_chroma_table_index = 2;
 
1227
            s->rl_table_index = 2;
 
1228
 
 
1229
            s->dc_table_index = 0; //not used
 
1230
            break;
 
1231
        case 3:
 
1232
            s->rl_chroma_table_index = decode012(&s->gb);
 
1233
            s->rl_table_index = decode012(&s->gb);
 
1234
 
 
1235
            s->dc_table_index = get_bits1(&s->gb);
 
1236
            break;
 
1237
        case 4:
 
1238
            msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
 
1239
 
 
1240
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
 
1241
            else                           s->per_mb_rl_table= 0;
 
1242
 
 
1243
            if(!s->per_mb_rl_table){
 
1244
                s->rl_chroma_table_index = decode012(&s->gb);
 
1245
                s->rl_table_index = decode012(&s->gb);
 
1246
            }
 
1247
 
 
1248
            s->dc_table_index = get_bits1(&s->gb);
 
1249
            s->inter_intra_pred= 0;
 
1250
            break;
 
1251
        }
 
1252
        s->no_rounding = 1;
 
1253
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
 
1254
            av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
 
1255
                s->qscale,
 
1256
                s->rl_chroma_table_index,
 
1257
                s->rl_table_index,
 
1258
                s->dc_table_index,
 
1259
                s->per_mb_rl_table,
 
1260
                s->slice_height);
 
1261
    } else {
 
1262
        switch(s->msmpeg4_version){
 
1263
        case 1:
 
1264
        case 2:
 
1265
            if(s->msmpeg4_version==1)
 
1266
                s->use_skip_mb_code = 1;
 
1267
            else
 
1268
                s->use_skip_mb_code = get_bits1(&s->gb);
 
1269
            s->rl_table_index = 2;
 
1270
            s->rl_chroma_table_index = s->rl_table_index;
 
1271
            s->dc_table_index = 0; //not used
 
1272
            s->mv_table_index = 0;
 
1273
            break;
 
1274
        case 3:
 
1275
            s->use_skip_mb_code = get_bits1(&s->gb);
 
1276
            s->rl_table_index = decode012(&s->gb);
 
1277
            s->rl_chroma_table_index = s->rl_table_index;
 
1278
 
 
1279
            s->dc_table_index = get_bits1(&s->gb);
 
1280
 
 
1281
            s->mv_table_index = get_bits1(&s->gb);
 
1282
            break;
 
1283
        case 4:
 
1284
            s->use_skip_mb_code = get_bits1(&s->gb);
 
1285
 
 
1286
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
 
1287
            else                           s->per_mb_rl_table= 0;
 
1288
 
 
1289
            if(!s->per_mb_rl_table){
 
1290
                s->rl_table_index = decode012(&s->gb);
 
1291
                s->rl_chroma_table_index = s->rl_table_index;
 
1292
            }
 
1293
 
 
1294
            s->dc_table_index = get_bits1(&s->gb);
 
1295
 
 
1296
            s->mv_table_index = get_bits1(&s->gb);
 
1297
            s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
 
1298
            break;
 
1299
        }
 
1300
 
 
1301
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
 
1302
            av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
 
1303
                s->use_skip_mb_code,
 
1304
                s->rl_table_index,
 
1305
                s->rl_chroma_table_index,
 
1306
                s->dc_table_index,
 
1307
                s->mv_table_index,
 
1308
                s->per_mb_rl_table,
 
1309
                s->qscale);
 
1310
 
 
1311
        if(s->flipflop_rounding){
 
1312
            s->no_rounding ^= 1;
 
1313
        }else{
 
1314
            s->no_rounding = 0;
 
1315
        }
 
1316
    }
 
1317
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
 
1318
 
 
1319
    s->esc3_level_length= 0;
 
1320
    s->esc3_run_length= 0;
 
1321
 
 
1322
#ifdef DEBUG
 
1323
    av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
 
1324
#endif
 
1325
    return 0;
 
1326
}
 
1327
 
 
1328
int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
 
1329
{
 
1330
    int left= buf_size*8 - get_bits_count(&s->gb);
 
1331
    int length= s->msmpeg4_version>=3 ? 17 : 16;
 
1332
    /* the alt_bitstream reader could read over the end so we need to check it */
 
1333
    if(left>=length && left<length+8)
 
1334
    {
 
1335
        int fps;
 
1336
 
 
1337
        fps= get_bits(&s->gb, 5);
 
1338
        s->bit_rate= get_bits(&s->gb, 11)*1024;
 
1339
        if(s->msmpeg4_version>=3)
 
1340
            s->flipflop_rounding= get_bits1(&s->gb);
 
1341
        else
 
1342
            s->flipflop_rounding= 0;
 
1343
 
 
1344
//        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
 
1345
    }
 
1346
    else if(left<length+8)
 
1347
    {
 
1348
        s->flipflop_rounding= 0;
 
1349
        if(s->msmpeg4_version != 2)
 
1350
            av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
 
1351
    }
 
1352
    else
 
1353
    {
 
1354
        av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
 
1355
    }
 
1356
 
 
1357
    return 0;
 
1358
}
 
1359
 
 
1360
static inline void msmpeg4_memsetw(short *tab, int val, int n)
 
1361
{
 
1362
    int i;
 
1363
    for(i=0;i<n;i++)
 
1364
        tab[i] = val;
 
1365
}
 
1366
 
 
1367
#ifdef CONFIG_ENCODERS
 
1368
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
 
1369
{
 
1370
    int range, bit_size, sign, code, bits;
 
1371
 
 
1372
    if (val == 0) {
 
1373
        /* zero vector */
 
1374
        code = 0;
 
1375
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
 
1376
    } else {
 
1377
        bit_size = s->f_code - 1;
 
1378
        range = 1 << bit_size;
 
1379
        if (val <= -64)
 
1380
            val += 64;
 
1381
        else if (val >= 64)
 
1382
            val -= 64;
 
1383
 
 
1384
        if (val >= 0) {
 
1385
            sign = 0;
 
1386
        } else {
 
1387
            val = -val;
 
1388
            sign = 1;
 
1389
        }
 
1390
        val--;
 
1391
        code = (val >> bit_size) + 1;
 
1392
        bits = val & (range - 1);
 
1393
 
 
1394
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
 
1395
        if (bit_size > 0) {
 
1396
            put_bits(&s->pb, bit_size, bits);
 
1397
        }
 
1398
    }
 
1399
}
 
1400
#endif
 
1401
 
 
1402
/* This is identical to h263 except that its range is multiplied by 2. */
 
1403
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
 
1404
{
 
1405
    int code, val, sign, shift;
 
1406
 
 
1407
    code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
 
1408
//     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
 
1409
    if (code < 0)
 
1410
        return 0xffff;
 
1411
 
 
1412
    if (code == 0)
 
1413
        return pred;
 
1414
    sign = get_bits1(&s->gb);
 
1415
    shift = f_code - 1;
 
1416
    val = code;
 
1417
    if (shift) {
 
1418
        val = (val - 1) << shift;
 
1419
        val |= get_bits(&s->gb, shift);
 
1420
        val++;
 
1421
    }
 
1422
    if (sign)
 
1423
        val = -val;
 
1424
 
 
1425
    val += pred;
 
1426
    if (val <= -64)
 
1427
        val += 64;
 
1428
    else if (val >= 64)
 
1429
        val -= 64;
 
1430
 
 
1431
    return val;
 
1432
}
 
1433
 
 
1434
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
 
1435
{
 
1436
    int cbp, code, i;
 
1437
 
 
1438
    if (s->pict_type == P_TYPE) {
 
1439
        if (s->use_skip_mb_code) {
 
1440
            if (get_bits1(&s->gb)) {
 
1441
                /* skip mb */
 
1442
                s->mb_intra = 0;
 
1443
                for(i=0;i<6;i++)
 
1444
                    s->block_last_index[i] = -1;
 
1445
                s->mv_dir = MV_DIR_FORWARD;
 
1446
                s->mv_type = MV_TYPE_16X16;
 
1447
                s->mv[0][0][0] = 0;
 
1448
                s->mv[0][0][1] = 0;
 
1449
                s->mb_skipped = 1;
 
1450
                return 0;
 
1451
            }
 
1452
        }
 
1453
 
 
1454
        if(s->msmpeg4_version==2)
 
1455
            code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
 
1456
        else
 
1457
            code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
 
1458
        if(code<0 || code>7){
 
1459
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
 
1460
            return -1;
 
1461
        }
 
1462
 
 
1463
        s->mb_intra = code >>2;
 
1464
 
 
1465
        cbp = code & 0x3;
 
1466
    } else {
 
1467
        s->mb_intra = 1;
 
1468
        if(s->msmpeg4_version==2)
 
1469
            cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
 
1470
        else
 
1471
            cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
 
1472
        if(cbp<0 || cbp>3){
 
1473
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
 
1474
            return -1;
 
1475
        }
 
1476
    }
 
1477
 
 
1478
    if (!s->mb_intra) {
 
1479
        int mx, my, cbpy;
 
1480
 
 
1481
        cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
 
1482
        if(cbpy<0){
 
1483
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
 
1484
            return -1;
 
1485
        }
 
1486
 
 
1487
        cbp|= cbpy<<2;
 
1488
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
 
1489
 
 
1490
        h263_pred_motion(s, 0, 0, &mx, &my);
 
1491
        mx= msmpeg4v2_decode_motion(s, mx, 1);
 
1492
        my= msmpeg4v2_decode_motion(s, my, 1);
 
1493
 
 
1494
        s->mv_dir = MV_DIR_FORWARD;
 
1495
        s->mv_type = MV_TYPE_16X16;
 
1496
        s->mv[0][0][0] = mx;
 
1497
        s->mv[0][0][1] = my;
 
1498
    } else {
 
1499
        if(s->msmpeg4_version==2){
 
1500
            s->ac_pred = get_bits1(&s->gb);
 
1501
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
 
1502
        } else{
 
1503
            s->ac_pred = 0;
 
1504
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
 
1505
            if(s->pict_type==P_TYPE) cbp^=0x3C;
 
1506
        }
 
1507
    }
 
1508
 
 
1509
    s->dsp.clear_blocks(s->block[0]);
 
1510
    for (i = 0; i < 6; i++) {
 
1511
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
 
1512
        {
 
1513
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
 
1514
             return -1;
 
1515
        }
 
1516
    }
 
1517
    return 0;
 
1518
}
 
1519
 
 
1520
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
 
1521
{
 
1522
    int cbp, code, i;
 
1523
    uint8_t *coded_val;
 
1524
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
 
1525
 
 
1526
    if (s->pict_type == P_TYPE) {
 
1527
        if (s->use_skip_mb_code) {
 
1528
            if (get_bits1(&s->gb)) {
 
1529
                /* skip mb */
 
1530
                s->mb_intra = 0;
 
1531
                for(i=0;i<6;i++)
 
1532
                    s->block_last_index[i] = -1;
 
1533
                s->mv_dir = MV_DIR_FORWARD;
 
1534
                s->mv_type = MV_TYPE_16X16;
 
1535
                s->mv[0][0][0] = 0;
 
1536
                s->mv[0][0][1] = 0;
 
1537
                s->mb_skipped = 1;
 
1538
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
 
1539
 
 
1540
                return 0;
 
1541
            }
 
1542
        }
 
1543
 
 
1544
        code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
 
1545
        if (code < 0)
 
1546
            return -1;
 
1547
        //s->mb_intra = (code & 0x40) ? 0 : 1;
 
1548
        s->mb_intra = (~code & 0x40) >> 6;
 
1549
 
 
1550
        cbp = code & 0x3f;
 
1551
    } else {
 
1552
        s->mb_intra = 1;
 
1553
        code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
 
1554
        if (code < 0)
 
1555
            return -1;
 
1556
        /* predict coded block pattern */
 
1557
        cbp = 0;
 
1558
        for(i=0;i<6;i++) {
 
1559
            int val = ((code >> (5 - i)) & 1);
 
1560
            if (i < 4) {
 
1561
                int pred = coded_block_pred(s, i, &coded_val);
 
1562
                val = val ^ pred;
 
1563
                *coded_val = val;
 
1564
            }
 
1565
            cbp |= val << (5 - i);
 
1566
        }
 
1567
    }
 
1568
 
 
1569
    if (!s->mb_intra) {
 
1570
        int mx, my;
 
1571
//printf("P at %d %d\n", s->mb_x, s->mb_y);
 
1572
        if(s->per_mb_rl_table && cbp){
 
1573
            s->rl_table_index = decode012(&s->gb);
 
1574
            s->rl_chroma_table_index = s->rl_table_index;
 
1575
        }
 
1576
        h263_pred_motion(s, 0, 0, &mx, &my);
 
1577
        if (msmpeg4_decode_motion(s, &mx, &my) < 0)
 
1578
            return -1;
 
1579
        s->mv_dir = MV_DIR_FORWARD;
 
1580
        s->mv_type = MV_TYPE_16X16;
 
1581
        s->mv[0][0][0] = mx;
 
1582
        s->mv[0][0][1] = my;
 
1583
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
 
1584
    } else {
 
1585
//printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24));
 
1586
        s->ac_pred = get_bits1(&s->gb);
 
1587
        *mb_type_ptr = MB_TYPE_INTRA;
 
1588
        if(s->inter_intra_pred){
 
1589
            s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
 
1590
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
 
1591
        }
 
1592
        if(s->per_mb_rl_table && cbp){
 
1593
            s->rl_table_index = decode012(&s->gb);
 
1594
            s->rl_chroma_table_index = s->rl_table_index;
 
1595
        }
 
1596
    }
 
1597
 
 
1598
    s->dsp.clear_blocks(s->block[0]);
 
1599
    for (i = 0; i < 6; i++) {
 
1600
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
 
1601
        {
 
1602
            av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
 
1603
            return -1;
 
1604
        }
 
1605
    }
 
1606
 
 
1607
    return 0;
 
1608
}
 
1609
//#define ERROR_DETAILS
 
1610
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
 
1611
                              int n, int coded, const uint8_t *scan_table)
 
1612
{
 
1613
    int level, i, last, run, run_diff;
 
1614
    int dc_pred_dir;
 
1615
    RLTable *rl;
 
1616
    RL_VLC_ELEM *rl_vlc;
 
1617
    int qmul, qadd;
 
1618
 
 
1619
    if (s->mb_intra) {
 
1620
        qmul=1;
 
1621
        qadd=0;
 
1622
 
 
1623
        /* DC coef */
 
1624
        level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
 
1625
 
 
1626
        if (level < 0){
 
1627
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
 
1628
            if(s->inter_intra_pred) level=0;
 
1629
            else                    return -1;
 
1630
        }
 
1631
        if (n < 4) {
 
1632
            rl = &rl_table[s->rl_table_index];
 
1633
            if(level > 256*s->y_dc_scale){
 
1634
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
 
1635
                if(!s->inter_intra_pred) return -1;
 
1636
            }
 
1637
        } else {
 
1638
            rl = &rl_table[3 + s->rl_chroma_table_index];
 
1639
            if(level > 256*s->c_dc_scale){
 
1640
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
 
1641
                if(!s->inter_intra_pred) return -1;
 
1642
            }
 
1643
        }
 
1644
        block[0] = level;
 
1645
 
 
1646
        run_diff = s->msmpeg4_version >= 4;
 
1647
        i = 0;
 
1648
        if (!coded) {
 
1649
            goto not_coded;
 
1650
        }
 
1651
        if (s->ac_pred) {
 
1652
            if (dc_pred_dir == 0)
 
1653
                scan_table = s->intra_v_scantable.permutated; /* left */
 
1654
            else
 
1655
                scan_table = s->intra_h_scantable.permutated; /* top */
 
1656
        } else {
 
1657
            scan_table = s->intra_scantable.permutated;
 
1658
        }
 
1659
        rl_vlc= rl->rl_vlc[0];
 
1660
    } else {
 
1661
        qmul = s->qscale << 1;
 
1662
        qadd = (s->qscale - 1) | 1;
 
1663
        i = -1;
 
1664
        rl = &rl_table[3 + s->rl_table_index];
 
1665
 
 
1666
        if(s->msmpeg4_version==2)
 
1667
            run_diff = 0;
 
1668
        else
 
1669
            run_diff = 1;
 
1670
 
 
1671
        if (!coded) {
 
1672
            s->block_last_index[n] = i;
 
1673
            return 0;
 
1674
        }
 
1675
        if(!scan_table)
 
1676
            scan_table = s->inter_scantable.permutated;
 
1677
        rl_vlc= rl->rl_vlc[s->qscale];
 
1678
    }
 
1679
  {
 
1680
    OPEN_READER(re, &s->gb);
 
1681
    for(;;) {
 
1682
        UPDATE_CACHE(re, &s->gb);
 
1683
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
 
1684
        if (level==0) {
 
1685
            int cache;
 
1686
            cache= GET_CACHE(re, &s->gb);
 
1687
            /* escape */
 
1688
            if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
 
1689
                if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
 
1690
                    /* third escape */
 
1691
                    if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
 
1692
                    UPDATE_CACHE(re, &s->gb);
 
1693
                    if(s->msmpeg4_version<=3){
 
1694
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
 
1695
                        run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
 
1696
                        level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
 
1697
                        SKIP_COUNTER(re, &s->gb, 1+6+8);
 
1698
                    }else{
 
1699
                        int sign;
 
1700
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
 
1701
                        if(!s->esc3_level_length){
 
1702
                            int ll;
 
1703
                            //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
 
1704
                            if(s->qscale<8){
 
1705
                                ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
 
1706
                                if(ll==0){
 
1707
                                    if(SHOW_UBITS(re, &s->gb, 1)) av_log(s->avctx, AV_LOG_ERROR, "cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
 
1708
                                    SKIP_BITS(re, &s->gb, 1);
 
1709
                                    ll=8;
 
1710
                                }
 
1711
                            }else{
 
1712
                                ll=2;
 
1713
                                while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
 
1714
                                    ll++;
 
1715
                                    SKIP_BITS(re, &s->gb, 1);
 
1716
                                }
 
1717
                                if(ll<8) SKIP_BITS(re, &s->gb, 1);
 
1718
                            }
 
1719
 
 
1720
                            s->esc3_level_length= ll;
 
1721
                            s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
 
1722
//printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
 
1723
                            UPDATE_CACHE(re, &s->gb);
 
1724
                        }
 
1725
                        run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
 
1726
                        SKIP_BITS(re, &s->gb, s->esc3_run_length);
 
1727
 
 
1728
                        sign=  SHOW_UBITS(re, &s->gb, 1);
 
1729
                        SKIP_BITS(re, &s->gb, 1);
 
1730
 
 
1731
                        level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
 
1732
                        SKIP_BITS(re, &s->gb, s->esc3_level_length);
 
1733
                        if(sign) level= -level;
 
1734
                    }
 
1735
//printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
 
1736
#if 0 // waste of time / this will detect very few errors
 
1737
                    {
 
1738
                        const int abs_level= FFABS(level);
 
1739
                        const int run1= run - rl->max_run[last][abs_level] - run_diff;
 
1740
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
 
1741
                            if(abs_level <= rl->max_level[last][run]){
 
1742
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
 
1743
                                return DECODING_AC_LOST;
 
1744
                            }
 
1745
                            if(abs_level <= rl->max_level[last][run]*2){
 
1746
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
 
1747
                                return DECODING_AC_LOST;
 
1748
                            }
 
1749
                            if(run1>=0 && abs_level <= rl->max_level[last][run1]){
 
1750
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
 
1751
                                return DECODING_AC_LOST;
 
1752
                            }
 
1753
                        }
 
1754
                    }
 
1755
#endif
 
1756
                    //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
 
1757
                    if (level>0) level= level * qmul + qadd;
 
1758
                    else         level= level * qmul - qadd;
 
1759
#if 0 // waste of time too :(
 
1760
                    if(level>2048 || level<-2048){
 
1761
                        av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
 
1762
                        return DECODING_AC_LOST;
 
1763
                    }
 
1764
#endif
 
1765
                    i+= run + 1;
 
1766
                    if(last) i+=192;
 
1767
#ifdef ERROR_DETAILS
 
1768
                if(run==66)
 
1769
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
 
1770
                else if((i>62 && i<192) || i>192+63)
 
1771
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
 
1772
#endif
 
1773
                } else {
 
1774
                    /* second escape */
 
1775
#if MIN_CACHE_BITS < 23
 
1776
                    LAST_SKIP_BITS(re, &s->gb, 2);
 
1777
                    UPDATE_CACHE(re, &s->gb);
 
1778
#else
 
1779
                    SKIP_BITS(re, &s->gb, 2);
 
1780
#endif
 
1781
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
 
1782
                    i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
 
1783
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
 
1784
                    LAST_SKIP_BITS(re, &s->gb, 1);
 
1785
#ifdef ERROR_DETAILS
 
1786
                if(run==66)
 
1787
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
 
1788
                else if((i>62 && i<192) || i>192+63)
 
1789
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
 
1790
#endif
 
1791
                }
 
1792
            } else {
 
1793
                /* first escape */
 
1794
#if MIN_CACHE_BITS < 22
 
1795
                LAST_SKIP_BITS(re, &s->gb, 1);
 
1796
                UPDATE_CACHE(re, &s->gb);
 
1797
#else
 
1798
                SKIP_BITS(re, &s->gb, 1);
 
1799
#endif
 
1800
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
 
1801
                i+= run;
 
1802
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
 
1803
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
 
1804
                LAST_SKIP_BITS(re, &s->gb, 1);
 
1805
#ifdef ERROR_DETAILS
 
1806
                if(run==66)
 
1807
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
 
1808
                else if((i>62 && i<192) || i>192+63)
 
1809
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
 
1810
#endif
 
1811
            }
 
1812
        } else {
 
1813
            i+= run;
 
1814
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
 
1815
            LAST_SKIP_BITS(re, &s->gb, 1);
 
1816
#ifdef ERROR_DETAILS
 
1817
                if(run==66)
 
1818
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
 
1819
                else if((i>62 && i<192) || i>192+63)
 
1820
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
 
1821
#endif
 
1822
        }
 
1823
        if (i > 62){
 
1824
            i-= 192;
 
1825
            if(i&(~63)){
 
1826
                const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
 
1827
                if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
 
1828
                    av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
 
1829
                    break;
 
1830
                }else{
 
1831
                    av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
 
1832
                    return -1;
 
1833
                }
 
1834
            }
 
1835
 
 
1836
            block[scan_table[i]] = level;
 
1837
            break;
 
1838
        }
 
1839
 
 
1840
        block[scan_table[i]] = level;
 
1841
    }
 
1842
    CLOSE_READER(re, &s->gb);
 
1843
  }
 
1844
 not_coded:
 
1845
    if (s->mb_intra) {
 
1846
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
 
1847
        if (s->ac_pred) {
 
1848
            i = 63; /* XXX: not optimal */
 
1849
        }
 
1850
    }
 
1851
    if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
 
1852
    s->block_last_index[n] = i;
 
1853
 
 
1854
    return 0;
 
1855
}
 
1856
 
 
1857
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
 
1858
{
 
1859
    int level, pred;
 
1860
 
 
1861
    if(s->msmpeg4_version<=2){
 
1862
        if (n < 4) {
 
1863
            level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
 
1864
        } else {
 
1865
            level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
 
1866
        }
 
1867
        if (level < 0)
 
1868
            return -1;
 
1869
        level-=256;
 
1870
    }else{  //FIXME optimize use unified tables & index
 
1871
        if (n < 4) {
 
1872
            level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
 
1873
        } else {
 
1874
            level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
 
1875
        }
 
1876
        if (level < 0){
 
1877
            av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
 
1878
            return -1;
 
1879
        }
 
1880
 
 
1881
        if (level == DC_MAX) {
 
1882
            level = get_bits(&s->gb, 8);
 
1883
            if (get_bits1(&s->gb))
 
1884
                level = -level;
 
1885
        } else if (level != 0) {
 
1886
            if (get_bits1(&s->gb))
 
1887
                level = -level;
 
1888
        }
 
1889
    }
 
1890
 
 
1891
    if(s->msmpeg4_version==1){
 
1892
        int32_t *dc_val;
 
1893
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
 
1894
        level += pred;
 
1895
 
 
1896
        /* update predictor */
 
1897
        *dc_val= level;
 
1898
    }else{
 
1899
        int16_t *dc_val;
 
1900
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
 
1901
        level += pred;
 
1902
 
 
1903
        /* update predictor */
 
1904
        if (n < 4) {
 
1905
            *dc_val = level * s->y_dc_scale;
 
1906
        } else {
 
1907
            *dc_val = level * s->c_dc_scale;
 
1908
        }
 
1909
    }
 
1910
 
 
1911
    return level;
 
1912
}
 
1913
 
 
1914
static int msmpeg4_decode_motion(MpegEncContext * s,
 
1915
                                 int *mx_ptr, int *my_ptr)
 
1916
{
 
1917
    MVTable *mv;
 
1918
    int code, mx, my;
 
1919
 
 
1920
    mv = &mv_tables[s->mv_table_index];
 
1921
 
 
1922
    code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
 
1923
    if (code < 0){
 
1924
        av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
 
1925
        return -1;
 
1926
    }
 
1927
    if (code == mv->n) {
 
1928
//printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
 
1929
        mx = get_bits(&s->gb, 6);
 
1930
        my = get_bits(&s->gb, 6);
 
1931
    } else {
 
1932
        mx = mv->table_mvx[code];
 
1933
        my = mv->table_mvy[code];
 
1934
    }
 
1935
 
 
1936
    mx += *mx_ptr - 32;
 
1937
    my += *my_ptr - 32;
 
1938
    /* WARNING : they do not do exactly modulo encoding */
 
1939
    if (mx <= -64)
 
1940
        mx += 64;
 
1941
    else if (mx >= 64)
 
1942
        mx -= 64;
 
1943
 
 
1944
    if (my <= -64)
 
1945
        my += 64;
 
1946
    else if (my >= 64)
 
1947
        my -= 64;
 
1948
    *mx_ptr = mx;
 
1949
    *my_ptr = my;
 
1950
    return 0;
 
1951
}
 
1952
 
 
1953
/* cleanest way to support it
 
1954
 * there is too much shared between versions so that we cant have 1 file per version & 1 common
 
1955
 * as allmost everything would be in the common file
 
1956
 */
 
1957
#include "wmv2.c"