Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ d2975f8d

History | View | Annotate | Download (63.8 KB)

1
/*
2
 * MPEG1 encoder / MPEG2 decoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19
//#define DEBUG
20
#include "avcodec.h"
21
#include "dsputil.h"
22
#include "mpegvideo.h"
23

    
24
#include "mpeg12data.h"
25

    
26
#if 1
27
#define PRINT_QP(a, b) {}
28
#else
29
#define PRINT_QP(a, b) printf(a, b)
30
#endif
31

    
32
/* Start codes. */
33
#define SEQ_END_CODE                0x000001b7
34
#define SEQ_START_CODE                0x000001b3
35
#define GOP_START_CODE                0x000001b8
36
#define PICTURE_START_CODE        0x00000100
37
#define SLICE_MIN_START_CODE        0x00000101
38
#define SLICE_MAX_START_CODE        0x000001af
39
#define EXT_START_CODE                0x000001b5
40
#define USER_START_CODE                0x000001b2
41

    
42
#define DC_VLC_BITS 9
43
#define MV_VLC_BITS 9
44
#define MBINCR_VLC_BITS 9
45
#define MB_PAT_VLC_BITS 9
46
#define MB_PTYPE_VLC_BITS 6
47
#define MB_BTYPE_VLC_BITS 6
48
#define TEX_VLC_BITS 9
49

    
50
static void mpeg1_encode_block(MpegEncContext *s, 
51
                         DCTELEM *block, 
52
                         int component);
53
static void mpeg1_encode_motion(MpegEncContext *s, int val);
54
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
55
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
56
                              DCTELEM *block, 
57
                              int n);
58
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
59
                              DCTELEM *block, 
60
                              int n);
61
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
62
                                        DCTELEM *block, 
63
                                        int n);
64
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
65
                                    DCTELEM *block, 
66
                                    int n);
67
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
68

    
69
static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
70
static UINT8 fcode_tab[MAX_MV*2+1];
71

    
72
static inline int get_bits_diff(MpegEncContext *s){
73
    int bits,ret;
74
    
75
    bits= get_bit_count(&s->pb);
76
    ret= bits - s->last_bits;
77
    s->last_bits=bits;
78
    
79
    return ret;
80
}
81

    
82
static void init_2d_vlc_rl(RLTable *rl)
83
{
84
    int i;
85
    
86
    init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2, 
87
             &rl->table_vlc[0][1], 4, 2,
88
             &rl->table_vlc[0][0], 4, 2);
89

    
90
    
91
    rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
92
    for(i=0; i<rl->vlc.table_size; i++){
93
        int code= rl->vlc.table[i][0];
94
        int len = rl->vlc.table[i][1];
95
        int level, run;
96
    
97
        if(len==0){ // illegal code
98
            run= 65;
99
            level= MAX_LEVEL;
100
        }else if(len<0){ //more bits needed
101
            run= 0;
102
            level= code;
103
        }else{
104
            if(code==rl->n){ //esc
105
                run= 65;
106
                level= 0;
107
            }else if(code==rl->n+1){ //eob
108
                run= 0;
109
                level= 127;
110
            }else{
111
                run=   rl->table_run  [code] + 1;
112
                level= rl->table_level[code];
113
            }
114
        }
115
        rl->rl_vlc[0][i].len= len;
116
        rl->rl_vlc[0][i].level= level;
117
        rl->rl_vlc[0][i].run= run;
118
    }
119
}
120

    
121

    
122
static void put_header(MpegEncContext *s, int header)
123
{
124
    align_put_bits(&s->pb);
125
    put_bits(&s->pb, 16, header>>16);
126
    put_bits(&s->pb, 16, header&0xFFFF);
127
}
128

    
129
/* put sequence header if needed */
130
static void mpeg1_encode_sequence_header(MpegEncContext *s)
131
{
132
        unsigned int vbv_buffer_size;
133
        unsigned int fps, v;
134
        int n;
135
        UINT64 time_code;
136
        
137
        if (s->picture_in_gop_number == 0) {
138
            /* mpeg1 header repeated every gop */
139
            put_header(s, SEQ_START_CODE);
140
            
141
            /* search closest frame rate */
142
            {
143
                int i, dmin, d;
144
                s->frame_rate_index = 0;
145
                dmin = 0x7fffffff;
146
                for(i=1;i<9;i++) {
147
                    d = abs(s->frame_rate - frame_rate_tab[i]);
148
                    if (d < dmin) {
149
                        dmin = d;
150
                        s->frame_rate_index = i;
151
                    }
152
                }
153
            }
154
 
155
            put_bits(&s->pb, 12, s->width);
156
            put_bits(&s->pb, 12, s->height);
157
            put_bits(&s->pb, 4, 1); /* 1/1 aspect ratio */
158
            put_bits(&s->pb, 4, s->frame_rate_index);
159
            v = s->bit_rate / 400;
160
            if (v > 0x3ffff)
161
                v = 0x3ffff;
162
            put_bits(&s->pb, 18, v);
163
            put_bits(&s->pb, 1, 1); /* marker */
164

    
165
            if(s->avctx->rc_buffer_size)
166
                vbv_buffer_size = s->avctx->rc_buffer_size;
167
            else
168
                /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */
169
                vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;         
170
            put_bits(&s->pb, 10, (vbv_buffer_size + 16383) / 16384); 
171
            put_bits(&s->pb, 1, 1); /* constrained parameter flag */
172
            put_bits(&s->pb, 1, 0); /* no custom intra matrix */
173
            put_bits(&s->pb, 1, 0); /* no custom non intra matrix */
174

    
175
            put_header(s, GOP_START_CODE);
176
            put_bits(&s->pb, 1, 0); /* do drop frame */
177
            /* time code : we must convert from the real frame rate to a
178
               fake mpeg frame rate in case of low frame rate */
179
            fps = frame_rate_tab[s->frame_rate_index];
180
            time_code = (INT64)s->fake_picture_number * FRAME_RATE_BASE;
181
            s->gop_picture_number = s->fake_picture_number;
182
            put_bits(&s->pb, 5, (UINT32)((time_code / (fps * 3600)) % 24));
183
            put_bits(&s->pb, 6, (UINT32)((time_code / (fps * 60)) % 60));
184
            put_bits(&s->pb, 1, 1);
185
            put_bits(&s->pb, 6, (UINT32)((time_code / fps) % 60));
186
            put_bits(&s->pb, 6, (UINT32)((time_code % fps) / FRAME_RATE_BASE));
187
            put_bits(&s->pb, 1, 1); /* closed gop */
188
            put_bits(&s->pb, 1, 0); /* broken link */
189
        }
190

    
191
        if (s->frame_rate < (24 * FRAME_RATE_BASE) && s->picture_number > 0) {
192
            /* insert empty P pictures to slow down to the desired
193
               frame rate. Each fake pictures takes about 20 bytes */
194
            fps = frame_rate_tab[s->frame_rate_index];
195
            n = (((INT64)s->picture_number * fps) / s->frame_rate) - 1;
196
            while (s->fake_picture_number < n) {
197
                mpeg1_skip_picture(s, s->fake_picture_number - 
198
                                   s->gop_picture_number); 
199
                s->fake_picture_number++;
200
            }
201

    
202
        }
203
}
204

    
205

    
206
/* insert a fake P picture */
207
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)
208
{
209
    unsigned int mb_incr;
210

    
211
    /* mpeg1 picture header */
212
    put_header(s, PICTURE_START_CODE);
213
    /* temporal reference */
214
    put_bits(&s->pb, 10, pict_num & 0x3ff); 
215
    
216
    put_bits(&s->pb, 3, P_TYPE);
217
    put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
218
    
219
    put_bits(&s->pb, 1, 1); /* integer coordinates */
220
    put_bits(&s->pb, 3, 1); /* forward_f_code */
221
    
222
    put_bits(&s->pb, 1, 0); /* extra bit picture */
223
    
224
    /* only one slice */
225
    put_header(s, SLICE_MIN_START_CODE);
226
    put_bits(&s->pb, 5, 1); /* quantizer scale */
227
    put_bits(&s->pb, 1, 0); /* slice extra information */
228
    
229
    mb_incr = 1;
230
    put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 
231
             mbAddrIncrTable[mb_incr - 1][0]);
232
    
233
    /* empty macroblock */
234
    put_bits(&s->pb, 3, 1); /* motion only */
235
    
236
    /* zero motion x & y */
237
    put_bits(&s->pb, 1, 1); 
238
    put_bits(&s->pb, 1, 1); 
239

    
240
    /* output a number of empty slice */
241
    mb_incr = s->mb_width * s->mb_height - 1;
242
    while (mb_incr > 33) {
243
        put_bits(&s->pb, 11, 0x008);
244
        mb_incr -= 33;
245
    }
246
    put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 
247
             mbAddrIncrTable[mb_incr - 1][0]);
248
    
249
    /* empty macroblock */
250
    put_bits(&s->pb, 3, 1); /* motion only */
251
    
252
    /* zero motion x & y */
253
    put_bits(&s->pb, 1, 1); 
254
    put_bits(&s->pb, 1, 1); 
255
}
256

    
257
static void common_init(MpegEncContext *s)
258
{
259
    s->y_dc_scale_table=
260
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
261
}
262

    
263
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
264
{
265
    mpeg1_encode_sequence_header(s);
266

    
267
    /* mpeg1 picture header */
268
    put_header(s, PICTURE_START_CODE);
269
    /* temporal reference */
270
    put_bits(&s->pb, 10, (s->fake_picture_number - 
271
                          s->gop_picture_number) & 0x3ff); 
272
    s->fake_picture_number++;
273
    
274
    put_bits(&s->pb, 3, s->pict_type);
275
    put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
276
    
277
    if (s->pict_type == P_TYPE) {
278
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
279
        put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
280
    }
281
    
282
    put_bits(&s->pb, 1, 0); /* extra bit picture */
283
    
284
    /* only one slice */
285
    put_header(s, SLICE_MIN_START_CODE);
286
    put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
287
    put_bits(&s->pb, 1, 0); /* slice extra information */
288
}
289

    
290
void mpeg1_encode_mb(MpegEncContext *s,
291
                     DCTELEM block[6][64],
292
                     int motion_x, int motion_y)
293
{
294
    int mb_incr, i, cbp, mb_x, mb_y;
295

    
296
    mb_x = s->mb_x;
297
    mb_y = s->mb_y;
298

    
299
    /* compute cbp */
300
    cbp = 0;
301
    for(i=0;i<6;i++) {
302
        if (s->block_last_index[i] >= 0)
303
            cbp |= 1 << (5 - i);
304
    }
305

    
306
    /* skip macroblock, except if first or last macroblock of a slice */
307
    if ((cbp | motion_x | motion_y) == 0 &&
308
        (!((mb_x | mb_y) == 0 ||
309
           (mb_x == s->mb_width - 1 && mb_y == s->mb_height - 1)))) {
310
        s->mb_incr++;
311
        s->qscale -= s->dquant;
312
        s->skip_count++;
313
        s->misc_bits++;
314
        s->last_bits++;
315
    } else {
316
        /* output mb incr */
317
        mb_incr = s->mb_incr;
318

    
319
        while (mb_incr > 33) {
320
            put_bits(&s->pb, 11, 0x008);
321
            mb_incr -= 33;
322
        }
323
        put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 
324
                 mbAddrIncrTable[mb_incr - 1][0]);
325
        
326
        if (s->pict_type == I_TYPE) {
327
            if(s->dquant && cbp){
328
                put_bits(&s->pb, 2, 1); /* macroblock_type : macroblock_quant = 1 */
329
                put_bits(&s->pb, 5, s->qscale);
330
            }else{
331
                put_bits(&s->pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */
332
                s->qscale -= s->dquant;
333
            }
334
            s->misc_bits+= get_bits_diff(s);
335
            s->i_count++;
336
        } else {
337
            if (s->mb_intra) {
338
                if(s->dquant && cbp){
339
                    put_bits(&s->pb, 6, 0x01);
340
                    put_bits(&s->pb, 5, s->qscale);
341
                }else{
342
                    put_bits(&s->pb, 5, 0x03);
343
                    s->qscale -= s->dquant;
344
                }
345
                s->misc_bits+= get_bits_diff(s);
346
                s->i_count++;
347
            } else {
348
                if (cbp != 0) {
349
                    if (motion_x == 0 && motion_y == 0) {
350
                        if(s->dquant){
351
                            put_bits(&s->pb, 5, 1); /* macroblock_pattern & quant */
352
                            put_bits(&s->pb, 5, s->qscale);
353
                        }else{
354
                            put_bits(&s->pb, 2, 1); /* macroblock_pattern only */
355
                        }
356
                        s->misc_bits+= get_bits_diff(s);
357
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
358
                    } else {
359
                        if(s->dquant){
360
                            put_bits(&s->pb, 5, 2); /* motion + cbp */
361
                            put_bits(&s->pb, 5, s->qscale);
362
                        }else{
363
                            put_bits(&s->pb, 1, 1); /* motion + cbp */
364
                        }
365
                        s->misc_bits+= get_bits_diff(s);
366
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0]); 
367
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1]); 
368
                        s->mv_bits+= get_bits_diff(s);
369
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
370
                    }
371
                } else {
372
                    put_bits(&s->pb, 3, 1); /* motion only */
373
                    mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0]); 
374
                    mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1]); 
375
                    s->qscale -= s->dquant;
376
                    s->mv_bits+= get_bits_diff(s);
377
                }
378
                s->f_count++;
379
            }
380
        }
381
        for(i=0;i<6;i++) {
382
            if (cbp & (1 << (5 - i))) {
383
                mpeg1_encode_block(s, block[i], i);
384
            }
385
        }
386
        s->mb_incr = 1;
387
        if(s->mb_intra)
388
            s->i_tex_bits+= get_bits_diff(s);
389
        else
390
            s->p_tex_bits+= get_bits_diff(s);
391
    }
392
    s->last_mv[0][0][0] = motion_x;
393
    s->last_mv[0][0][1] = motion_y;
394
}
395

    
396
static void mpeg1_encode_motion(MpegEncContext *s, int val)
397
{
398
    int code, bit_size, l, m, bits, range, sign;
399

    
400
    if (val == 0) {
401
        /* zero vector */
402
        code = 0;
403
        put_bits(&s->pb,
404
                 mbMotionVectorTable[0][1], 
405
                 mbMotionVectorTable[0][0]); 
406
    } else {
407
        bit_size = s->f_code - 1;
408
        range = 1 << bit_size;
409
        /* modulo encoding */
410
        l = 16 * range;
411
        m = 2 * l;
412
        if (val < -l) {
413
            val += m;
414
        } else if (val >= l) {
415
            val -= m;
416
        }
417

    
418
        if (val >= 0) {
419
            val--;
420
            code = (val >> bit_size) + 1;
421
            bits = val & (range - 1);
422
            sign = 0;
423
        } else {
424
            val = -val;
425
            val--;
426
            code = (val >> bit_size) + 1;
427
            bits = val & (range - 1);
428
            sign = 1;
429
        }
430
        put_bits(&s->pb,
431
                 mbMotionVectorTable[code][1], 
432
                 mbMotionVectorTable[code][0]); 
433
        put_bits(&s->pb, 1, sign);
434
        if (bit_size > 0) {
435
            put_bits(&s->pb, bit_size, bits);
436
        }
437
    }
438
}
439

    
440
void ff_mpeg1_encode_init(MpegEncContext *s)
441
{
442
    static int done=0;
443

    
444
    common_init(s);
445

    
446
    if(!done){
447
        int f_code;
448
        int mv;
449
        int i;
450

    
451
        done=1;
452
        init_rl(&rl_mpeg1);
453
        
454
        for(i=0; i<64; i++)
455
        {
456
                mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
457
                mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
458
        }
459

    
460
        /* build unified dc encoding tables */
461
        for(i=-255; i<256; i++)
462
        {
463
                int adiff, index;
464
                int bits, code;
465
                int diff=i;
466

    
467
                adiff = ABS(diff);
468
                if(diff<0) diff--;
469
                index = vlc_dc_table[adiff];
470

    
471
                bits= vlc_dc_lum_bits[index] + index;
472
                code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
473
                mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
474
                
475
                bits= vlc_dc_chroma_bits[index] + index;
476
                code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
477
                mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
478
        }
479

    
480
        for(f_code=1; f_code<=MAX_FCODE; f_code++){
481
            for(mv=-MAX_MV; mv<=MAX_MV; mv++){
482
                int len;
483

    
484
                if(mv==0) len= mbMotionVectorTable[0][1];
485
                else{
486
                    int val, bit_size, range, code;
487

    
488
                    bit_size = s->f_code - 1;
489
                    range = 1 << bit_size;
490

    
491
                    val=mv;
492
                    if (val < 0) 
493
                        val = -val;
494
                    val--;
495
                    code = (val >> bit_size) + 1;
496
                    if(code<17){
497
                        len= mbMotionVectorTable[code][1] + 1 + bit_size;
498
                    }else{
499
                        len= mbMotionVectorTable[16][1] + 2 + bit_size;
500
                    }
501
                }
502

    
503
                mv_penalty[f_code][mv+MAX_MV]= len;
504
            }
505
        }
506
        
507

    
508
        for(f_code=MAX_FCODE; f_code>0; f_code--){
509
            for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
510
                fcode_tab[mv+MAX_MV]= f_code;
511
            }
512
        }
513
    }
514
    s->mv_penalty= mv_penalty;
515
    s->fcode_tab= fcode_tab;
516
    s->min_qcoeff=-255;
517
    s->max_qcoeff= 255;
518
    s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
519
    s->inter_quant_bias= 0;
520
}
521

    
522
static inline void encode_dc(MpegEncContext *s, int diff, int component)
523
{
524
    if (component == 0) {
525
        put_bits(
526
            &s->pb, 
527
            mpeg1_lum_dc_uni[diff+255]&0xFF,
528
            mpeg1_lum_dc_uni[diff+255]>>8);
529
    } else {
530
        put_bits(
531
            &s->pb, 
532
            mpeg1_chr_dc_uni[diff+255]&0xFF,
533
            mpeg1_chr_dc_uni[diff+255]>>8);
534
    }
535
}
536

    
537
static void mpeg1_encode_block(MpegEncContext *s, 
538
                               DCTELEM *block, 
539
                               int n)
540
{
541
    int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
542
    int code, component;
543
//    RLTable *rl = &rl_mpeg1;
544

    
545
    last_index = s->block_last_index[n];
546

    
547
    /* DC coef */
548
    if (s->mb_intra) {
549
        component = (n <= 3 ? 0 : n - 4 + 1);
550
        dc = block[0]; /* overflow is impossible */
551
        diff = dc - s->last_dc[component];
552
        encode_dc(s, diff, component);
553
        s->last_dc[component] = dc;
554
        i = 1;
555
    } else {
556
        /* encode the first coefficient : needs to be done here because
557
           it is handled slightly differently */
558
        level = block[0];
559
        if (abs(level) == 1) {
560
                code = ((UINT32)level >> 31); /* the sign bit */
561
                put_bits(&s->pb, 2, code | 0x02);
562
                i = 1;
563
        } else {
564
            i = 0;
565
            last_non_zero = -1;
566
            goto next_coef;
567
        }
568
    }
569

    
570
    /* now quantify & encode AC coefs */
571
    last_non_zero = i - 1;
572

    
573
    for(;i<=last_index;i++) {
574
        j = s->intra_scantable.permutated[i];
575
        level = block[j];
576
    next_coef:
577
#if 0
578
        if (level != 0)
579
            dprintf("level[%d]=%d\n", i, level);
580
#endif            
581
        /* encode using VLC */
582
        if (level != 0) {
583
            run = i - last_non_zero - 1;
584
            
585
            alevel= level;
586
            MASK_ABS(sign, alevel)
587
            sign&=1;
588

    
589
//            code = get_rl_index(rl, 0, run, alevel);
590
            if (alevel > mpeg1_max_level[0][run])
591
                code= 111; /*rl->n*/
592
            else
593
                code= mpeg1_index_run[0][run] + alevel - 1;
594

    
595
            if (code < 111 /* rl->n */) {
596
                    /* store the vlc & sign at once */
597
                put_bits(&s->pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign);
598
            } else {
599
                /* escape seems to be pretty rare <5% so i dont optimize it */
600
                put_bits(&s->pb, mpeg1_vlc[111/*rl->n*/][1], mpeg1_vlc[111/*rl->n*/][0]);
601
                /* escape: only clip in this case */
602
                put_bits(&s->pb, 6, run);
603
                if (alevel < 128) {
604
                    put_bits(&s->pb, 8, level & 0xff);
605
                } else {
606
                    if (level < 0) {
607
                        put_bits(&s->pb, 16, 0x8001 + level + 255);
608
                    } else {
609
                        put_bits(&s->pb, 16, level & 0xffff);
610
                    }
611
                }
612
            }
613
            last_non_zero = i;
614
        }
615
    }
616
    /* end of block */
617
    put_bits(&s->pb, 2, 0x2);
618
}
619

    
620
/******************************************/
621
/* decoding */
622

    
623
static VLC dc_lum_vlc;
624
static VLC dc_chroma_vlc;
625
static VLC mv_vlc;
626
static VLC mbincr_vlc;
627
static VLC mb_ptype_vlc;
628
static VLC mb_btype_vlc;
629
static VLC mb_pat_vlc;
630

    
631
static void init_vlcs(MpegEncContext *s)
632
{
633
    static int done = 0;
634

    
635
    if (!done) {
636
        done = 1;
637

    
638
        init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12, 
639
                 vlc_dc_lum_bits, 1, 1,
640
                 vlc_dc_lum_code, 2, 2);
641
        init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12, 
642
                 vlc_dc_chroma_bits, 1, 1,
643
                 vlc_dc_chroma_code, 2, 2);
644
        init_vlc(&mv_vlc, MV_VLC_BITS, 17, 
645
                 &mbMotionVectorTable[0][1], 2, 1,
646
                 &mbMotionVectorTable[0][0], 2, 1);
647
        init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 35, 
648
                 &mbAddrIncrTable[0][1], 2, 1,
649
                 &mbAddrIncrTable[0][0], 2, 1);
650
        init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63, 
651
                 &mbPatTable[0][1], 2, 1,
652
                 &mbPatTable[0][0], 2, 1);
653
        
654
        init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 32, 
655
                 &table_mb_ptype[0][1], 2, 1,
656
                 &table_mb_ptype[0][0], 2, 1);
657
        init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 32, 
658
                 &table_mb_btype[0][1], 2, 1,
659
                 &table_mb_btype[0][0], 2, 1);
660
        init_rl(&rl_mpeg1);
661
        init_rl(&rl_mpeg2);
662

    
663
        init_2d_vlc_rl(&rl_mpeg1);
664
        init_2d_vlc_rl(&rl_mpeg2);
665
    }
666
}
667

    
668
static inline int get_dmv(MpegEncContext *s)
669
{
670
    if(get_bits1(&s->gb)) 
671
        return 1 - (get_bits1(&s->gb) << 1);
672
    else
673
        return 0;
674
}
675

    
676
static inline int get_qscale(MpegEncContext *s)
677
{
678
    int qscale;
679
    if (s->mpeg2) {
680
        if (s->q_scale_type) {
681
            qscale = non_linear_qscale[get_bits(&s->gb, 5)];
682
        } else {
683
            qscale = get_bits(&s->gb, 5) << 1;
684
        }
685
    } else {
686
        /* for mpeg1, we use the generic unquant code */
687
        qscale = get_bits(&s->gb, 5);
688
    }
689
    return qscale;
690
}
691

    
692
/* motion type (for mpeg2) */
693
#define MT_FIELD 1
694
#define MT_FRAME 2
695
#define MT_16X8  2
696
#define MT_DMV   3
697

    
698
static int mpeg_decode_mb(MpegEncContext *s,
699
                          DCTELEM block[6][64])
700
{
701
    int i, j, k, cbp, val, mb_type, motion_type;
702
    
703
    dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
704

    
705
    if (--s->mb_incr != 0) {
706
        /* skip mb */
707
        s->mb_intra = 0;
708
        for(i=0;i<6;i++)
709
            s->block_last_index[i] = -1;
710
        s->mv_type = MV_TYPE_16X16;
711
        if (s->pict_type == P_TYPE) {
712
            /* if P type, zero motion vector is implied */
713
            s->mv_dir = MV_DIR_FORWARD;
714
            s->mv[0][0][0] = s->mv[0][0][1] = 0;
715
            s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
716
            s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
717
        } else {
718
            /* if B type, reuse previous vectors and directions */
719
            s->mv[0][0][0] = s->last_mv[0][0][0];
720
            s->mv[0][0][1] = s->last_mv[0][0][1];
721
            s->mv[1][0][0] = s->last_mv[1][0][0];
722
            s->mv[1][0][1] = s->last_mv[1][0][1];
723
        }
724
        s->mb_skiped = 1;
725
        return 0;
726
    }
727

    
728
    switch(s->pict_type) {
729
    default:
730
    case I_TYPE:
731
        if (get_bits1(&s->gb) == 0) {
732
            if (get_bits1(&s->gb) == 0)
733
                return -1;
734
            mb_type = MB_QUANT | MB_INTRA;
735
        } else {
736
            mb_type = MB_INTRA;
737
        }
738
        break;
739
    case P_TYPE:
740
        mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
741
        if (mb_type < 0){
742
            fprintf(stderr, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
743
            return -1;
744
        }
745
        break;
746
    case B_TYPE:
747
        mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
748
        if (mb_type < 0){
749
            fprintf(stderr, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
750
            return -1;
751
        }
752
        break;
753
    }
754
    dprintf("mb_type=%x\n", mb_type);
755
    motion_type = 0; /* avoid warning */
756
    if (mb_type & (MB_FOR|MB_BACK)) {
757
        /* get additionnal motion vector type */
758
        if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) 
759
            motion_type = MT_FRAME;
760
        else
761
            motion_type = get_bits(&s->gb, 2);
762
    }
763
    /* compute dct type */
764
    if (s->picture_structure == PICT_FRAME && 
765
        !s->frame_pred_frame_dct &&
766
        (mb_type & (MB_PAT | MB_INTRA))) {
767
        s->interlaced_dct = get_bits1(&s->gb);
768
#ifdef DEBUG
769
        if (s->interlaced_dct)
770
            printf("interlaced_dct\n");
771
#endif
772
    } else {
773
        s->interlaced_dct = 0; /* frame based */
774
    }
775

    
776
    if (mb_type & MB_QUANT) {
777
        s->qscale = get_qscale(s);
778
    }
779
    if (mb_type & MB_INTRA) {
780
        if (s->concealment_motion_vectors) {
781
            /* just parse them */
782
            if (s->picture_structure != PICT_FRAME) 
783
                skip_bits1(&s->gb); /* field select */
784
            mpeg_decode_motion(s, s->mpeg_f_code[0][0], 0);
785
            mpeg_decode_motion(s, s->mpeg_f_code[0][1], 0);
786
        }
787
        s->mb_intra = 1;
788
        cbp = 0x3f;
789
        memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
790
    } else {
791
        s->mb_intra = 0;
792
        cbp = 0;
793
    }
794
    /* special case of implicit zero motion vector */
795
    if (s->pict_type == P_TYPE && !(mb_type & MB_FOR)) {
796
        s->mv_dir = MV_DIR_FORWARD;
797
        s->mv_type = MV_TYPE_16X16;
798
        s->last_mv[0][0][0] = 0;
799
        s->last_mv[0][0][1] = 0;
800
        s->last_mv[0][1][0] = 0;
801
        s->last_mv[0][1][1] = 0;
802
        s->mv[0][0][0] = 0;
803
        s->mv[0][0][1] = 0;
804
    } else if (mb_type & (MB_FOR | MB_BACK)) {
805
        /* motion vectors */
806
        s->mv_dir = 0;
807
        for(i=0;i<2;i++) {
808
            if (mb_type & (MB_FOR >> i)) {
809
                s->mv_dir |= (MV_DIR_FORWARD >> i);
810
                dprintf("motion_type=%d\n", motion_type);
811
                switch(motion_type) {
812
                case MT_FRAME: /* or MT_16X8 */
813
                    if (s->picture_structure == PICT_FRAME) {
814
                        /* MT_FRAME */
815
                        s->mv_type = MV_TYPE_16X16;
816
                        for(k=0;k<2;k++) {
817
                            val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], 
818
                                                     s->last_mv[i][0][k]);
819
                            s->last_mv[i][0][k] = val;
820
                            s->last_mv[i][1][k] = val;
821
                            /* full_pel: only for mpeg1 */
822
                            if (s->full_pel[i])
823
                                val = val << 1;
824
                            s->mv[i][0][k] = val;
825
                            dprintf("mv%d: %d\n", k, val);
826
                        }
827
                    } else {
828
                        /* MT_16X8 */
829
                        s->mv_type = MV_TYPE_16X8;
830
                        for(j=0;j<2;j++) {
831
                            s->field_select[i][j] = get_bits1(&s->gb);
832
                            for(k=0;k<2;k++) {
833
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
834
                                                         s->last_mv[i][j][k]);
835
                                s->last_mv[i][j][k] = val;
836
                                s->mv[i][j][k] = val;
837
                            }
838
                        }
839
                    }
840
                    break;
841
                case MT_FIELD:
842
                    if (s->picture_structure == PICT_FRAME) {
843
                        s->mv_type = MV_TYPE_FIELD;
844
                        for(j=0;j<2;j++) {
845
                            s->field_select[i][j] = get_bits1(&s->gb);
846
                            val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
847
                                                     s->last_mv[i][j][0]);
848
                            s->last_mv[i][j][0] = val;
849
                            s->mv[i][j][0] = val;
850
                            dprintf("fmx=%d\n", val);
851
                            val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
852
                                                     s->last_mv[i][j][1] >> 1);
853
                            s->last_mv[i][j][1] = val << 1;
854
                            s->mv[i][j][1] = val;
855
                            dprintf("fmy=%d\n", val);
856
                        }
857
                    } else {
858
                        s->mv_type = MV_TYPE_16X16;
859
                        s->field_select[i][0] = get_bits1(&s->gb);
860
                        for(k=0;k<2;k++) {
861
                            val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
862
                                                     s->last_mv[i][0][k]);
863
                            s->last_mv[i][0][k] = val;
864
                            s->last_mv[i][1][k] = val;
865
                            s->mv[i][0][k] = val;
866
                        }
867
                    }
868
                    break;
869
                case MT_DMV:
870
                    {
871
                        int dmx, dmy, mx, my, m;
872

    
873
                        mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 
874
                                                s->last_mv[i][0][0]);
875
                        s->last_mv[i][0][0] = mx;
876
                        s->last_mv[i][1][0] = mx;
877
                        dmx = get_dmv(s);
878
                        my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 
879
                                                s->last_mv[i][0][1] >> 1);
880
                        dmy = get_dmv(s);
881
                        s->mv_type = MV_TYPE_DMV;
882
                        /* XXX: totally broken */
883
                        if (s->picture_structure == PICT_FRAME) {
884
                            s->last_mv[i][0][1] = my << 1;
885
                            s->last_mv[i][1][1] = my << 1;
886

    
887
                            m = s->top_field_first ? 1 : 3;
888
                            /* top -> top pred */
889
                            s->mv[i][0][0] = mx; 
890
                            s->mv[i][0][1] = my << 1;
891
                            s->mv[i][1][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
892
                            s->mv[i][1][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
893
                            m = 4 - m;
894
                            s->mv[i][2][0] = mx;
895
                            s->mv[i][2][1] = my << 1;
896
                            s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
897
                            s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
898
                        } else {
899
                            s->last_mv[i][0][1] = my;
900
                            s->last_mv[i][1][1] = my;
901
                            s->mv[i][0][0] = mx;
902
                            s->mv[i][0][1] = my;
903
                            s->mv[i][1][0] = ((mx + (mx > 0)) >> 1) + dmx;
904
                            s->mv[i][1][1] = ((my + (my > 0)) >> 1) + dmy - 1 
905
                                /* + 2 * cur_field */;
906
                        }
907
                    }
908
                    break;
909
                }
910
            }
911
        }
912
    }
913

    
914
    if ((mb_type & MB_INTRA) && s->concealment_motion_vectors) {
915
        skip_bits1(&s->gb); /* marker */
916
    }
917
    
918
    if (mb_type & MB_PAT) {
919
        cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
920
        if (cbp < 0){
921
            fprintf(stderr, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
922
            return -1;
923
        }
924
        cbp++;
925
    }
926
    dprintf("cbp=%x\n", cbp);
927

    
928
    if (s->mpeg2) {
929
        if (s->mb_intra) {
930
            for(i=0;i<6;i++) {
931
                if (mpeg2_decode_block_intra(s, block[i], i) < 0)
932
                    return -1;
933
            }
934
        } else {
935
            for(i=0;i<6;i++) {
936
                if (cbp & 32) {
937
                    if (mpeg2_decode_block_non_intra(s, block[i], i) < 0)
938
                        return -1;
939
                } else {
940
                    s->block_last_index[i] = -1;
941
                }
942
                cbp+=cbp;
943
            }
944
        }
945
    } else {
946
        if (s->mb_intra) {
947
            for(i=0;i<6;i++) {
948
                if (mpeg1_decode_block_intra(s, block[i], i) < 0)
949
                    return -1;
950
            }
951
        }else{
952
            for(i=0;i<6;i++) {
953
                if (cbp & 32) {
954
                    if (mpeg1_decode_block_inter(s, block[i], i) < 0)
955
                        return -1;
956
                } else {
957
                    s->block_last_index[i] = -1;
958
                }
959
                cbp+=cbp;
960
            }
961
        }
962
    }
963
    return 0;
964
}
965

    
966
/* as h263, but only 17 codes */
967
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
968
{
969
    int code, sign, val, m, l, shift;
970

    
971
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
972
    if (code < 0) {
973
        return 0xffff;
974
    }
975
    if (code == 0) {
976
        return pred;
977
    }
978
    sign = get_bits1(&s->gb);
979
    shift = fcode - 1;
980
    val = (code - 1) << shift;
981
    if (shift > 0)
982
        val |= get_bits(&s->gb, shift);
983
    val++;
984
    if (sign)
985
        val = -val;
986
    val += pred;
987
    
988
    /* modulo decoding */
989
    l = (1 << shift) * 16;
990
    m = 2 * l;
991
    if (val < -l) {
992
        val += m;
993
    } else if (val >= l) {
994
        val -= m;
995
    }
996
    return val;
997
}
998

    
999
static inline int decode_dc(MpegEncContext *s, int component)
1000
{
1001
    int code, diff;
1002

    
1003
    if (component == 0) {
1004
        code = get_vlc2(&s->gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1005
    } else {
1006
        code = get_vlc2(&s->gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1007
    }
1008
    if (code < 0){
1009
        fprintf(stderr, "invalid dc code at %d %d\n", s->mb_x, s->mb_y);
1010
        return 0xffff;
1011
    }
1012
    if (code == 0) {
1013
        diff = 0;
1014
    } else {
1015
        diff = get_bits(&s->gb, code);
1016
        if ((diff & (1 << (code - 1))) == 0) 
1017
            diff = (-1 << code) | (diff + 1);
1018
    }
1019
    return diff;
1020
}
1021

    
1022
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
1023
                               DCTELEM *block, 
1024
                               int n)
1025
{
1026
    int level, dc, diff, i, j, run;
1027
    int component;
1028
    RLTable *rl = &rl_mpeg1;
1029
    UINT8 * const scantable= s->intra_scantable.permutated;
1030
    const UINT16 *quant_matrix= s->intra_matrix;
1031
    const int qscale= s->qscale;
1032

    
1033
    /* DC coef */
1034
    component = (n <= 3 ? 0 : n - 4 + 1);
1035
    diff = decode_dc(s, component);
1036
    if (diff >= 0xffff)
1037
        return -1;
1038
    dc = s->last_dc[component];
1039
    dc += diff;
1040
    s->last_dc[component] = dc;
1041
    block[0] = dc<<3;
1042
    dprintf("dc=%d diff=%d\n", dc, diff);
1043
    i = 0;
1044
    {
1045
        OPEN_READER(re, &s->gb);    
1046
        /* now quantify & encode AC coefs */
1047
        for(;;) {
1048
            UPDATE_CACHE(re, &s->gb);
1049
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1050
            
1051
            if(level == 127){
1052
                break;
1053
            } else if(level != 0) {
1054
                i += run;
1055
                j = scantable[i];
1056
                level= (level*qscale*quant_matrix[j])>>3;
1057
                level= (level-1)|1;
1058
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1059
                LAST_SKIP_BITS(re, &s->gb, 1);
1060
            } else {
1061
                /* escape */
1062
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1063
                UPDATE_CACHE(re, &s->gb);
1064
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1065
                if (level == -128) {
1066
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1067
                } else if (level == 0) {
1068
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1069
                }
1070
                i += run;
1071
                j = scantable[i];
1072
                if(level<0){
1073
                    level= -level;
1074
                    level= (level*qscale*quant_matrix[j])>>3;
1075
                    level= (level-1)|1;
1076
                    level= -level;
1077
                }else{
1078
                    level= (level*qscale*quant_matrix[j])>>3;
1079
                    level= (level-1)|1;
1080
                }
1081
            }
1082
            if (i > 63){
1083
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1084
                return -1;
1085
            }
1086

    
1087
            block[j] = level;
1088
        }
1089
        CLOSE_READER(re, &s->gb);
1090
    }
1091
    s->block_last_index[n] = i;
1092
   return 0;
1093
}
1094

    
1095
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
1096
                               DCTELEM *block, 
1097
                               int n)
1098
{
1099
    int level, i, j, run;
1100
    RLTable *rl = &rl_mpeg1;
1101
    UINT8 * const scantable= s->intra_scantable.permutated;
1102
    const UINT16 *quant_matrix= s->inter_matrix;
1103
    const int qscale= s->qscale;
1104

    
1105
    {
1106
        int v;
1107
        OPEN_READER(re, &s->gb);
1108
        i = -1;
1109
        /* special case for the first coef. no need to add a second vlc table */
1110
        UPDATE_CACHE(re, &s->gb);
1111
        v= SHOW_UBITS(re, &s->gb, 2);
1112
        if (v & 2) {
1113
            LAST_SKIP_BITS(re, &s->gb, 2);
1114
            level= (3*qscale*quant_matrix[0])>>4;
1115
            level= (level-1)|1;
1116
            if(v&1)
1117
                level= -level;
1118
            block[0] = level;
1119
            i++;
1120
        }
1121

    
1122
        /* now quantify & encode AC coefs */
1123
        for(;;) {
1124
            UPDATE_CACHE(re, &s->gb);
1125
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1126
            
1127
            if(level == 127){
1128
                break;
1129
            } else if(level != 0) {
1130
                i += run;
1131
                j = scantable[i];
1132
                level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1133
                level= (level-1)|1;
1134
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1135
                LAST_SKIP_BITS(re, &s->gb, 1);
1136
            } else {
1137
                /* escape */
1138
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1139
                UPDATE_CACHE(re, &s->gb);
1140
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1141
                if (level == -128) {
1142
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1143
                } else if (level == 0) {
1144
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1145
                }
1146
                i += run;
1147
                j = scantable[i];
1148
                if(level<0){
1149
                    level= -level;
1150
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1151
                    level= (level-1)|1;
1152
                    level= -level;
1153
                }else{
1154
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1155
                    level= (level-1)|1;
1156
                }
1157
            }
1158
            if (i > 63){
1159
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1160
                return -1;
1161
            }
1162

    
1163
            block[j] = level;
1164
        }
1165
        CLOSE_READER(re, &s->gb);
1166
    }
1167
    s->block_last_index[n] = i;
1168
    return 0;
1169
}
1170

    
1171
/* Also does unquantization here, since I will never support mpeg2
1172
   encoding */
1173
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1174
                               DCTELEM *block, 
1175
                               int n)
1176
{
1177
    int level, i, j, run;
1178
    RLTable *rl = &rl_mpeg1;
1179
    UINT8 * const scantable= s->intra_scantable.permutated;
1180
    const UINT16 *quant_matrix;
1181
    const int qscale= s->qscale;
1182
    int mismatch;
1183

    
1184
    mismatch = 1;
1185

    
1186
    {
1187
        int v;
1188
        OPEN_READER(re, &s->gb);
1189
        i = -1;
1190
        if (n < 4)
1191
            quant_matrix = s->inter_matrix;
1192
        else
1193
            quant_matrix = s->chroma_inter_matrix;
1194

    
1195
        /* special case for the first coef. no need to add a second vlc table */
1196
        UPDATE_CACHE(re, &s->gb);
1197
        v= SHOW_UBITS(re, &s->gb, 2);
1198
        if (v & 2) {
1199
            LAST_SKIP_BITS(re, &s->gb, 2);
1200
            level= (3*qscale*quant_matrix[0])>>5;
1201
            if(v&1)
1202
                level= -level;
1203
            block[0] = level;
1204
            mismatch ^= level;
1205
            i++;
1206
        }
1207

    
1208
        /* now quantify & encode AC coefs */
1209
        for(;;) {
1210
            UPDATE_CACHE(re, &s->gb);
1211
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1212
            
1213
            if(level == 127){
1214
                break;
1215
            } else if(level != 0) {
1216
                i += run;
1217
                j = scantable[i];
1218
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1219
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1220
                LAST_SKIP_BITS(re, &s->gb, 1);
1221
            } else {
1222
                /* escape */
1223
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1224
                UPDATE_CACHE(re, &s->gb);
1225
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1226

    
1227
                i += run;
1228
                j = scantable[i];
1229
                if(level<0){
1230
                    level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1231
                    level= -level;
1232
                }else{
1233
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1234
                }
1235
            }
1236
            if (i > 63){
1237
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1238
                return -1;
1239
            }
1240
            
1241
            mismatch ^= level;
1242
            block[j] = level;
1243
        }
1244
        CLOSE_READER(re, &s->gb);
1245
    }
1246
    block[63] ^= (mismatch & 1);
1247
    
1248
    s->block_last_index[n] = i;
1249
    return 0;
1250
}
1251

    
1252
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
1253
                               DCTELEM *block, 
1254
                               int n)
1255
{
1256
    int level, dc, diff, i, j, run;
1257
    int component;
1258
    RLTable *rl;
1259
    UINT8 * const scantable= s->intra_scantable.permutated;
1260
    const UINT16 *quant_matrix;
1261
    const int qscale= s->qscale;
1262
    int mismatch;
1263

    
1264
    /* DC coef */
1265
    if (n < 4){
1266
        quant_matrix = s->intra_matrix;
1267
        component = 0; 
1268
    }else{
1269
        quant_matrix = s->chroma_intra_matrix;
1270
        component = n - 3;
1271
    }
1272
    diff = decode_dc(s, component);
1273
    if (diff >= 0xffff)
1274
        return -1;
1275
    dc = s->last_dc[component];
1276
    dc += diff;
1277
    s->last_dc[component] = dc;
1278
    block[0] = dc << (3 - s->intra_dc_precision);
1279
    dprintf("dc=%d\n", block[0]);
1280
    mismatch = block[0] ^ 1;
1281
    i = 0;
1282
    if (s->intra_vlc_format)
1283
        rl = &rl_mpeg2;
1284
    else
1285
        rl = &rl_mpeg1;
1286

    
1287
    {
1288
        OPEN_READER(re, &s->gb);    
1289
        /* now quantify & encode AC coefs */
1290
        for(;;) {
1291
            UPDATE_CACHE(re, &s->gb);
1292
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1293
            
1294
            if(level == 127){
1295
                break;
1296
            } else if(level != 0) {
1297
                i += run;
1298
                j = scantable[i];
1299
                level= (level*qscale*quant_matrix[j])>>4;
1300
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1301
                LAST_SKIP_BITS(re, &s->gb, 1);
1302
            } else {
1303
                /* escape */
1304
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1305
                UPDATE_CACHE(re, &s->gb);
1306
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1307
                i += run;
1308
                j = scantable[i];
1309
                if(level<0){
1310
                    level= (-level*qscale*quant_matrix[j])>>4;
1311
                    level= -level;
1312
                }else{
1313
                    level= (level*qscale*quant_matrix[j])>>4;
1314
                }
1315
            }
1316
            if (i > 63){
1317
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1318
                return -1;
1319
            }
1320
            
1321
            mismatch^= level;
1322
            block[j] = level;
1323
        }
1324
        CLOSE_READER(re, &s->gb);
1325
    }
1326
    block[63]^= mismatch&1;
1327
    
1328
    s->block_last_index[n] = i;
1329
    return 0;
1330
}
1331

    
1332
/* compressed picture size */
1333
#define PICTURE_BUFFER_SIZE 100000
1334

    
1335
typedef struct Mpeg1Context {
1336
    MpegEncContext mpeg_enc_ctx;
1337
    UINT32 header_state;
1338
    int start_code; /* current start code */
1339
    UINT8 buffer[PICTURE_BUFFER_SIZE]; 
1340
    UINT8 *buf_ptr;
1341
    int buffer_size;
1342
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1343
    int repeat_field; /* true if we must repeat the field */
1344
} Mpeg1Context;
1345

    
1346
static int mpeg_decode_init(AVCodecContext *avctx)
1347
{
1348
    Mpeg1Context *s = avctx->priv_data;
1349
    
1350
    s->mpeg_enc_ctx.flags= avctx->flags;
1351
    common_init(&s->mpeg_enc_ctx);
1352
    init_vlcs(&s->mpeg_enc_ctx);
1353

    
1354
    s->header_state = 0xff;
1355
    s->mpeg_enc_ctx_allocated = 0;
1356
    s->buffer_size = PICTURE_BUFFER_SIZE;
1357
    s->start_code = -1;
1358
    s->buf_ptr = s->buffer;
1359
    s->mpeg_enc_ctx.picture_number = 0;
1360
    s->repeat_field = 0;
1361
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1362
    avctx->mbskip_table= s->mpeg_enc_ctx.mbskip_table;
1363
    return 0;
1364
}
1365

    
1366
/* return the 8 bit start code value and update the search
1367
   state. Return -1 if no start code found */
1368
static int find_start_code(UINT8 **pbuf_ptr, UINT8 *buf_end, 
1369
                           UINT32 *header_state)
1370
{
1371
    UINT8 *buf_ptr;
1372
    unsigned int state, v;
1373
    int val;
1374

    
1375
    state = *header_state;
1376
    buf_ptr = *pbuf_ptr;
1377
    while (buf_ptr < buf_end) {
1378
        v = *buf_ptr++;
1379
        if (state == 0x000001) {
1380
            state = ((state << 8) | v) & 0xffffff;
1381
            val = state;
1382
            goto found;
1383
        }
1384
        state = ((state << 8) | v) & 0xffffff;
1385
    }
1386
    val = -1;
1387
 found:
1388
    *pbuf_ptr = buf_ptr;
1389
    *header_state = state;
1390
    return val;
1391
}
1392

    
1393
static int mpeg1_decode_picture(AVCodecContext *avctx, 
1394
                                UINT8 *buf, int buf_size)
1395
{
1396
    Mpeg1Context *s1 = avctx->priv_data;
1397
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1398
    int ref, f_code;
1399

    
1400
    init_get_bits(&s->gb, buf, buf_size);
1401

    
1402
    ref = get_bits(&s->gb, 10); /* temporal ref */
1403
    s->pict_type = get_bits(&s->gb, 3);
1404
    dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number);
1405
    skip_bits(&s->gb, 16);
1406
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
1407
        s->full_pel[0] = get_bits1(&s->gb);
1408
        f_code = get_bits(&s->gb, 3);
1409
        if (f_code == 0)
1410
            return -1;
1411
        s->mpeg_f_code[0][0] = f_code;
1412
        s->mpeg_f_code[0][1] = f_code;
1413
    }
1414
    if (s->pict_type == B_TYPE) {
1415
        s->full_pel[1] = get_bits1(&s->gb);
1416
        f_code = get_bits(&s->gb, 3);
1417
        if (f_code == 0)
1418
            return -1;
1419
        s->mpeg_f_code[1][0] = f_code;
1420
        s->mpeg_f_code[1][1] = f_code;
1421
    }
1422
    s->y_dc_scale = 8;
1423
    s->c_dc_scale = 8;
1424
    s->first_slice = 1;
1425
    return 0;
1426
}
1427

    
1428
static void mpeg_decode_sequence_extension(MpegEncContext *s)
1429
{
1430
    int horiz_size_ext, vert_size_ext;
1431
    int bit_rate_ext, vbv_buf_ext, low_delay;
1432
    int frame_rate_ext_n, frame_rate_ext_d;
1433

    
1434
    skip_bits(&s->gb, 8); /* profil and level */
1435
    s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1436
    skip_bits(&s->gb, 2); /* chroma_format */
1437
    horiz_size_ext = get_bits(&s->gb, 2);
1438
    vert_size_ext = get_bits(&s->gb, 2);
1439
    s->width |= (horiz_size_ext << 12);
1440
    s->height |= (vert_size_ext << 12);
1441
    bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1442
    s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
1443
    skip_bits1(&s->gb); /* marker */
1444
    vbv_buf_ext = get_bits(&s->gb, 8);
1445
    low_delay = get_bits1(&s->gb);
1446
    frame_rate_ext_n = get_bits(&s->gb, 2);
1447
    frame_rate_ext_d = get_bits(&s->gb, 5);
1448
    if (frame_rate_ext_d >= 1)
1449
        s->frame_rate = (s->frame_rate * frame_rate_ext_n) / frame_rate_ext_d;
1450
    dprintf("sequence extension\n");
1451
    s->mpeg2 = 1;
1452
    s->avctx->sub_id = 2; /* indicates mpeg2 found */
1453
}
1454

    
1455
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1456
{
1457
    int i, v, j;
1458

    
1459
    dprintf("matrix extension\n");
1460

    
1461
    if (get_bits1(&s->gb)) {
1462
        for(i=0;i<64;i++) {
1463
            v = get_bits(&s->gb, 8);
1464
            j= s->idct_permutation[ ff_zigzag_direct[i] ];
1465
            s->intra_matrix[j] = v;
1466
            s->chroma_intra_matrix[j] = v;
1467
        }
1468
    }
1469
    if (get_bits1(&s->gb)) {
1470
        for(i=0;i<64;i++) {
1471
            v = get_bits(&s->gb, 8);
1472
            j= s->idct_permutation[ ff_zigzag_direct[i] ];
1473
            s->inter_matrix[j] = v;
1474
            s->chroma_inter_matrix[j] = v;
1475
        }
1476
    }
1477
    if (get_bits1(&s->gb)) {
1478
        for(i=0;i<64;i++) {
1479
            v = get_bits(&s->gb, 8);
1480
            j= s->idct_permutation[ ff_zigzag_direct[i] ];
1481
            s->chroma_intra_matrix[j] = v;
1482
        }
1483
    }
1484
    if (get_bits1(&s->gb)) {
1485
        for(i=0;i<64;i++) {
1486
            v = get_bits(&s->gb, 8);
1487
            j= s->idct_permutation[ ff_zigzag_direct[i] ];
1488
            s->chroma_inter_matrix[j] = v;
1489
        }
1490
    }
1491
}
1492

    
1493
static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
1494
{
1495
    s->full_pel[0] = s->full_pel[1] = 0;
1496
    s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1497
    s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1498
    s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1499
    s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1500
    s->intra_dc_precision = get_bits(&s->gb, 2);
1501
    s->picture_structure = get_bits(&s->gb, 2);
1502
    s->top_field_first = get_bits1(&s->gb);
1503
    s->frame_pred_frame_dct = get_bits1(&s->gb);
1504
    s->concealment_motion_vectors = get_bits1(&s->gb);
1505
    s->q_scale_type = get_bits1(&s->gb);
1506
    s->intra_vlc_format = get_bits1(&s->gb);
1507
    s->alternate_scan = get_bits1(&s->gb);
1508
    s->repeat_first_field = get_bits1(&s->gb);
1509
    s->chroma_420_type = get_bits1(&s->gb);
1510
    s->progressive_frame = get_bits1(&s->gb);
1511
    
1512
    if(s->alternate_scan){
1513
        ff_init_scantable(s, &s->inter_scantable  , ff_alternate_vertical_scan);
1514
        ff_init_scantable(s, &s->intra_scantable  , ff_alternate_vertical_scan);
1515
        ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
1516
        ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
1517
    }else{
1518
        ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
1519
        ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
1520
        ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
1521
        ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
1522
    }
1523
    
1524
    /* composite display not parsed */
1525
    dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
1526
    dprintf("picture_structure=%d\n", s->picture_structure);
1527
    dprintf("top field first=%d\n", s->top_field_first);
1528
    dprintf("repeat first field=%d\n", s->repeat_first_field);
1529
    dprintf("conceal=%d\n", s->concealment_motion_vectors);
1530
    dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
1531
    dprintf("alternate_scan=%d\n", s->alternate_scan);
1532
    dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1533
    dprintf("progressive_frame=%d\n", s->progressive_frame);
1534
}
1535

    
1536
static void mpeg_decode_extension(AVCodecContext *avctx, 
1537
                                  UINT8 *buf, int buf_size)
1538
{
1539
    Mpeg1Context *s1 = avctx->priv_data;
1540
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1541
    int ext_type;
1542

    
1543
    init_get_bits(&s->gb, buf, buf_size);
1544
    
1545
    ext_type = get_bits(&s->gb, 4);
1546
    switch(ext_type) {
1547
    case 0x1:
1548
        /* sequence ext */
1549
        mpeg_decode_sequence_extension(s);
1550
        break;
1551
    case 0x3:
1552
        /* quant matrix extension */
1553
        mpeg_decode_quant_matrix_extension(s);
1554
        break;
1555
    case 0x8:
1556
        /* picture extension */
1557
        mpeg_decode_picture_coding_extension(s);
1558
        break;
1559
    }
1560
}
1561

    
1562
/* return 1 if end of frame */
1563
static int mpeg_decode_slice(AVCodecContext *avctx, 
1564
                              AVPicture *pict,
1565
                              int start_code,
1566
                              UINT8 *buf, int buf_size)
1567
{
1568
    Mpeg1Context *s1 = avctx->priv_data;
1569
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1570
    int ret;
1571

    
1572
    start_code = (start_code - 1) & 0xff;
1573
    if (start_code >= s->mb_height){
1574
        fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);
1575
        return -1;
1576
    }
1577
    s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
1578
    s->last_dc[1] = s->last_dc[0];
1579
    s->last_dc[2] = s->last_dc[0];
1580
    memset(s->last_mv, 0, sizeof(s->last_mv));
1581
    /* start frame decoding */
1582
    if (s->first_slice) {
1583
        s->first_slice = 0;
1584
        MPV_frame_start(s, avctx);
1585
    }
1586

    
1587
    init_get_bits(&s->gb, buf, buf_size);
1588

    
1589
    s->qscale = get_qscale(s);
1590
    /* extra slice info */
1591
    while (get_bits1(&s->gb) != 0) {
1592
        skip_bits(&s->gb, 8);
1593
    }
1594

    
1595
    s->mb_x=0;
1596
    for(;;) {
1597
        int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1598
        if (code < 0)
1599
            return -1; /* error = end of slice, but empty slice is bad or?*/
1600
        if (code >= 33) {
1601
            if (code == 33) {
1602
                s->mb_x += 33;
1603
            }
1604
            /* otherwise, stuffing, nothing to do */
1605
        } else {
1606
            s->mb_x += code;
1607
            break;
1608
        }
1609
    }
1610
    s->mb_y = start_code;
1611
    s->mb_incr= 1;
1612

    
1613
    for(;;) {
1614
        clear_blocks(s->block[0]);
1615
        emms_c();
1616
        
1617
        ret = mpeg_decode_mb(s, s->block);
1618
        dprintf("ret=%d\n", ret);
1619
        if (ret < 0)
1620
            return -1;
1621
    
1622
        MPV_decode_mb(s, s->block);
1623

    
1624
        if (++s->mb_x >= s->mb_width) {
1625
            if (    avctx->draw_horiz_band 
1626
                && (s->num_available_buffers>=1 || (!s->has_b_frames)) ) {
1627
                UINT8 *src_ptr[3];
1628
                int y, h, offset;
1629
                y = s->mb_y * 16;
1630
                h = s->height - y;
1631
                if (h > 16)
1632
                    h = 16;
1633
                if(s->pict_type==B_TYPE)
1634
                    offset = 0;
1635
                else
1636
                    offset = y * s->linesize;
1637
                if(s->pict_type==B_TYPE || (!s->has_b_frames)){
1638
                    src_ptr[0] = s->current_picture[0] + offset;
1639
                    src_ptr[1] = s->current_picture[1] + (offset >> 2);
1640
                    src_ptr[2] = s->current_picture[2] + (offset >> 2);
1641
                } else {
1642
                    src_ptr[0] = s->last_picture[0] + offset;
1643
                    src_ptr[1] = s->last_picture[1] + (offset >> 2);
1644
                    src_ptr[2] = s->last_picture[2] + (offset >> 2);
1645
                }
1646
                avctx->draw_horiz_band(avctx, src_ptr, s->linesize,
1647
                                   y, s->width, h);
1648
            }
1649

    
1650
            s->mb_x = 0;
1651
            s->mb_y++;
1652
            PRINT_QP("%s", "\n");
1653
        }
1654
        PRINT_QP("%2d", s->qscale);
1655

    
1656
        /* skip mb handling */
1657
        if (s->mb_incr == 0) {
1658
            /* read again increment */
1659
            s->mb_incr = 1;
1660
            for(;;) {
1661
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1662
                if (code < 0)
1663
                    goto eos; /* error = end of slice */
1664
                if (code >= 33) {
1665
                    if (code == 33) {
1666
                        s->mb_incr += 33;
1667
                    }
1668
                    /* otherwise, stuffing, nothing to do */
1669
                } else {
1670
                    s->mb_incr += code;
1671
                    break;
1672
                }
1673
            }
1674
        }
1675
        if(s->mb_y >= s->mb_height){
1676
            fprintf(stderr, "slice too long\n");
1677
            return -1;
1678
        }
1679
    }
1680
eos: //end of slice
1681
    
1682
    emms_c();
1683

    
1684
    /* end of slice reached */
1685
    if (/*s->mb_x == 0 &&*/
1686
        s->mb_y == s->mb_height) {
1687
        /* end of image */
1688
        UINT8 **picture;
1689

    
1690
        MPV_frame_end(s);
1691

    
1692
        /* XXX: incorrect reported qscale for mpeg2 */
1693
        if (s->pict_type == B_TYPE) {
1694
            picture = s->current_picture;
1695
            avctx->quality = s->qscale;
1696
        } else {
1697
            /* latency of 1 frame for I and P frames */
1698
            /* XXX: use another variable than picture_number */
1699
            if (s->picture_number == 0) {
1700
                picture = NULL;
1701
            } else {
1702
                picture = s->last_picture;
1703
                avctx->quality = s->last_qscale;
1704
            }
1705
            s->last_qscale = s->qscale;
1706
            s->picture_number++;
1707
        }
1708
        if (picture) {
1709
            pict->data[0] = picture[0];
1710
            pict->data[1] = picture[1];
1711
            pict->data[2] = picture[2];
1712
            pict->linesize[0] = s->linesize;
1713
            pict->linesize[1] = s->uvlinesize;
1714
            pict->linesize[2] = s->uvlinesize;
1715
            return 1;
1716
        } else {
1717
            return 0;
1718
        }
1719
    } else {
1720
        return 0;
1721
    }
1722
}
1723

    
1724
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
1725
                                 UINT8 *buf, int buf_size)
1726
{
1727
    Mpeg1Context *s1 = avctx->priv_data;
1728
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1729
    int width, height, i, v, j;
1730

    
1731
    init_get_bits(&s->gb, buf, buf_size);
1732

    
1733
    width = get_bits(&s->gb, 12);
1734
    height = get_bits(&s->gb, 12);
1735
    skip_bits(&s->gb, 4);
1736
    s->frame_rate_index = get_bits(&s->gb, 4);
1737
    if (s->frame_rate_index == 0)
1738
        return -1;
1739
    s->bit_rate = get_bits(&s->gb, 18) * 400;
1740
    if (get_bits1(&s->gb) == 0) /* marker */
1741
        return -1;
1742
    if (width <= 0 || height <= 0 ||
1743
        (width % 2) != 0 || (height % 2) != 0)
1744
        return -1;
1745
    if (width != s->width ||
1746
        height != s->height) {
1747
        /* start new mpeg1 context decoding */
1748
        s->out_format = FMT_MPEG1;
1749
        if (s1->mpeg_enc_ctx_allocated) {
1750
            MPV_common_end(s);
1751
        }
1752
        s->width = width;
1753
        s->height = height;
1754
        avctx->has_b_frames= s->has_b_frames = 1;
1755
        s->avctx = avctx;
1756
        avctx->width = width;
1757
        avctx->height = height;
1758
        if (s->frame_rate_index >= 9) {
1759
            /* at least give a valid frame rate (some old mpeg1 have this) */
1760
            avctx->frame_rate = 25 * FRAME_RATE_BASE;
1761
        } else {
1762
            avctx->frame_rate = frame_rate_tab[s->frame_rate_index];
1763
        }
1764
        s->frame_rate = avctx->frame_rate;
1765
        avctx->bit_rate = s->bit_rate;
1766
        
1767
        if (MPV_common_init(s) < 0)
1768
            return -1;
1769
        s1->mpeg_enc_ctx_allocated = 1;
1770
    }
1771

    
1772
    skip_bits(&s->gb, 10); /* vbv_buffer_size */
1773
    skip_bits(&s->gb, 1);
1774

    
1775
    /* get matrix */
1776
    if (get_bits1(&s->gb)) {
1777
        for(i=0;i<64;i++) {
1778
            v = get_bits(&s->gb, 8);
1779
            j = s->intra_scantable.permutated[i];
1780
            s->intra_matrix[j] = v;
1781
            s->chroma_intra_matrix[j] = v;
1782
        }
1783
#ifdef DEBUG
1784
        dprintf("intra matrix present\n");
1785
        for(i=0;i<64;i++)
1786
            dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
1787
        printf("\n");
1788
#endif
1789
    } else {
1790
        for(i=0;i<64;i++) {
1791
            int j= s->idct_permutation[i];
1792
            v = ff_mpeg1_default_intra_matrix[i];
1793
            s->intra_matrix[j] = v;
1794
            s->chroma_intra_matrix[j] = v;
1795
        }
1796
    }
1797
    if (get_bits1(&s->gb)) {
1798
        for(i=0;i<64;i++) {
1799
            v = get_bits(&s->gb, 8);
1800
            j = s->intra_scantable.permutated[i];
1801
            s->inter_matrix[j] = v;
1802
            s->chroma_inter_matrix[j] = v;
1803
        }
1804
#ifdef DEBUG
1805
        dprintf("non intra matrix present\n");
1806
        for(i=0;i<64;i++)
1807
            dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
1808
        printf("\n");
1809
#endif
1810
    } else {
1811
        for(i=0;i<64;i++) {
1812
            int j= s->idct_permutation[i];
1813
            v = ff_mpeg1_default_non_intra_matrix[i];
1814
            s->inter_matrix[j] = v;
1815
            s->chroma_inter_matrix[j] = v;
1816
        }
1817
    }
1818

    
1819
    /* we set mpeg2 parameters so that it emulates mpeg1 */
1820
    s->progressive_sequence = 1;
1821
    s->progressive_frame = 1;
1822
    s->picture_structure = PICT_FRAME;
1823
    s->frame_pred_frame_dct = 1;
1824
    s->mpeg2 = 0;
1825
    avctx->sub_id = 1; /* indicates mpeg1 */
1826
    return 0;
1827
}
1828

    
1829
/* handle buffering and image synchronisation */
1830
static int mpeg_decode_frame(AVCodecContext *avctx, 
1831
                             void *data, int *data_size,
1832
                             UINT8 *buf, int buf_size)
1833
{
1834
    Mpeg1Context *s = avctx->priv_data;
1835
    UINT8 *buf_end, *buf_ptr, *buf_start;
1836
    int len, start_code_found, ret, code, start_code, input_size;
1837
    AVPicture *picture = data;
1838
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
1839
            
1840
    dprintf("fill_buffer\n");
1841

    
1842
    *data_size = 0;
1843

    
1844
    /* special case for last picture */
1845
    if (buf_size == 0) {
1846
        if (s2->picture_number > 0) {
1847
            picture->data[0] = s2->next_picture[0];
1848
            picture->data[1] = s2->next_picture[1];
1849
            picture->data[2] = s2->next_picture[2];
1850
            picture->linesize[0] = s2->linesize;
1851
            picture->linesize[1] = s2->uvlinesize;
1852
            picture->linesize[2] = s2->uvlinesize;
1853
            *data_size = sizeof(AVPicture);
1854
        }
1855
        return 0;
1856
    }
1857

    
1858
    buf_ptr = buf;
1859
    buf_end = buf + buf_size;
1860

    
1861
#if 0    
1862
    if (s->repeat_field % 2 == 1) { 
1863
        s->repeat_field++;
1864
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
1865
        //        s2->picture_number, s->repeat_field);
1866
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
1867
            *data_size = sizeof(AVPicture);
1868
            goto the_end;
1869
        }
1870
    }
1871
#endif
1872
    while (buf_ptr < buf_end) {
1873
        buf_start = buf_ptr;
1874
        /* find start next code */
1875
        code = find_start_code(&buf_ptr, buf_end, &s->header_state);
1876
        if (code >= 0) {
1877
            start_code_found = 1;
1878
        } else {
1879
            start_code_found = 0;
1880
        }
1881
        /* copy to buffer */
1882
        len = buf_ptr - buf_start;
1883
        if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
1884
            /* data too big : flush */
1885
            s->buf_ptr = s->buffer;
1886
            if (start_code_found)
1887
                s->start_code = code;
1888
        } else {
1889
            memcpy(s->buf_ptr, buf_start, len);
1890
            s->buf_ptr += len;
1891
            if(   (s2->flags&CODEC_FLAG_NOT_TRUNCATED) && (!start_code_found) 
1892
               && s->buf_ptr+4<s->buffer+s->buffer_size){
1893
                start_code_found= 1;
1894
                code= 0x1FF;
1895
                s->header_state=0xFF;
1896
                s->buf_ptr[0]=0;
1897
                s->buf_ptr[1]=0;
1898
                s->buf_ptr[2]=1;
1899
                s->buf_ptr[3]=0xFF;
1900
                s->buf_ptr+=4;
1901
            }
1902
            if (start_code_found) {
1903
                /* prepare data for next start code */
1904
                input_size = s->buf_ptr - s->buffer;
1905
                start_code = s->start_code;
1906
                s->buf_ptr = s->buffer;
1907
                s->start_code = code;
1908
                switch(start_code) {
1909
                case SEQ_START_CODE:
1910
                    mpeg1_decode_sequence(avctx, s->buffer, 
1911
                                          input_size);
1912
                    break;
1913
                            
1914
                case PICTURE_START_CODE:
1915
                    /* we have a complete image : we try to decompress it */
1916
                    mpeg1_decode_picture(avctx, 
1917
                                         s->buffer, input_size);
1918
                    break;
1919
                case EXT_START_CODE:
1920
                    mpeg_decode_extension(avctx,
1921
                                          s->buffer, input_size);
1922
                    break;
1923
                default:
1924
                    if (start_code >= SLICE_MIN_START_CODE &&
1925
                        start_code <= SLICE_MAX_START_CODE) {
1926
                        ret = mpeg_decode_slice(avctx, picture,
1927
                                                start_code, s->buffer, input_size);
1928
                        if (ret == 1) {
1929
                            /* got a picture: exit */
1930
                            /* first check if we must repeat the frame */
1931
                            avctx->repeat_pict = 0;
1932
#if 0
1933
                            if (s2->progressive_frame && s2->repeat_first_field) {
1934
                                //fprintf(stderr,"\nRepeat this frame: %d! pict: %d",avctx->frame_number,s2->picture_number);
1935
                                //s2->repeat_first_field = 0;
1936
                                //s2->progressive_frame = 0;
1937
                                if (++s->repeat_field > 2)
1938
                                    s->repeat_field = 0;
1939
                                avctx->repeat_pict = 1;
1940
                            }
1941
#endif                      
1942
                            if (s2->repeat_first_field) {
1943
                                if (s2->progressive_sequence) {
1944
                                    if (s2->top_field_first)
1945
                                        avctx->repeat_pict = 4;
1946
                                    else
1947
                                        avctx->repeat_pict = 2;
1948
                                } else if (s2->progressive_frame) {
1949
                                    avctx->repeat_pict = 1;
1950
                                }
1951
                            }         
1952
                            *data_size = sizeof(AVPicture);
1953
                            goto the_end;
1954
                        }else if(ret==-1){
1955
                            printf("Error while decoding slice\n");
1956
                        }
1957
                    }
1958
                    break;
1959
                }
1960
            }
1961
        }
1962
    }
1963
 the_end:
1964
    return buf_ptr - buf;
1965
}
1966

    
1967
static int mpeg_decode_end(AVCodecContext *avctx)
1968
{
1969
    Mpeg1Context *s = avctx->priv_data;
1970

    
1971
    if (s->mpeg_enc_ctx_allocated)
1972
        MPV_common_end(&s->mpeg_enc_ctx);
1973
    return 0;
1974
}
1975

    
1976
AVCodec mpeg_decoder = {
1977
    "mpegvideo",
1978
    CODEC_TYPE_VIDEO,
1979
    CODEC_ID_MPEG1VIDEO,
1980
    sizeof(Mpeg1Context),
1981
    mpeg_decode_init,
1982
    NULL,
1983
    mpeg_decode_end,
1984
    mpeg_decode_frame,
1985
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1986
};