Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ d2940155

History | View | Annotate | Download (61.1 KB)

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