Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ 650cec0c

History | View | Annotate | Download (60.6 KB)

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