Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ 983e3246

History | View | Annotate | Download (74.2 KB)

1
/*
2
 * MPEG1 codec / 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
 
20
/**
21
 * @file mpeg12.c
22
 * MPEG1 codec / MPEG2 decoder.
23
 */
24
 
25
//#define DEBUG
26
#include "avcodec.h"
27
#include "dsputil.h"
28
#include "mpegvideo.h"
29

    
30
#include "mpeg12data.h"
31

    
32
#if 1
33
#define PRINT_QP(a, b) {}
34
#else
35
#define PRINT_QP(a, b) printf(a, b)
36
#endif
37

    
38
/* Start codes. */
39
#define SEQ_END_CODE                0x000001b7
40
#define SEQ_START_CODE                0x000001b3
41
#define GOP_START_CODE                0x000001b8
42
#define PICTURE_START_CODE        0x00000100
43
#define SLICE_MIN_START_CODE        0x00000101
44
#define SLICE_MAX_START_CODE        0x000001af
45
#define EXT_START_CODE                0x000001b5
46
#define USER_START_CODE                0x000001b2
47

    
48
#define DC_VLC_BITS 9
49
#define MV_VLC_BITS 9
50
#define MBINCR_VLC_BITS 9
51
#define MB_PAT_VLC_BITS 9
52
#define MB_PTYPE_VLC_BITS 6
53
#define MB_BTYPE_VLC_BITS 6
54
#define TEX_VLC_BITS 9
55

    
56
static void mpeg1_encode_block(MpegEncContext *s, 
57
                         DCTELEM *block, 
58
                         int component);
59
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code);    // RAL: f_code parameter added
60
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
61
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
62
                              DCTELEM *block, 
63
                              int n);
64
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
65
                              DCTELEM *block, 
66
                              int n);
67
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
68
                                        DCTELEM *block, 
69
                                        int n);
70
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
71
                                    DCTELEM *block, 
72
                                    int n);
73
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
74

    
75
#ifdef CONFIG_ENCODERS
76
static uint16_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
77
static uint8_t fcode_tab[MAX_MV*2+1];
78

    
79
static uint32_t uni_mpeg1_ac_vlc_bits[64*64*2];
80
static uint8_t  uni_mpeg1_ac_vlc_len [64*64*2];
81
#endif
82

    
83
static inline int get_bits_diff(MpegEncContext *s){
84
    int bits,ret;
85
    
86
    bits= get_bit_count(&s->pb);
87
    ret= bits - s->last_bits;
88
    s->last_bits=bits;
89
    
90
    return ret;
91
}
92

    
93
static void init_2d_vlc_rl(RLTable *rl)
94
{
95
    int i;
96
    
97
    init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2, 
98
             &rl->table_vlc[0][1], 4, 2,
99
             &rl->table_vlc[0][0], 4, 2);
100

    
101
    
102
    rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
103
    for(i=0; i<rl->vlc.table_size; i++){
104
        int code= rl->vlc.table[i][0];
105
        int len = rl->vlc.table[i][1];
106
        int level, run;
107
    
108
        if(len==0){ // illegal code
109
            run= 65;
110
            level= MAX_LEVEL;
111
        }else if(len<0){ //more bits needed
112
            run= 0;
113
            level= code;
114
        }else{
115
            if(code==rl->n){ //esc
116
                run= 65;
117
                level= 0;
118
            }else if(code==rl->n+1){ //eob
119
                run= 0;
120
                level= 127;
121
            }else{
122
                run=   rl->table_run  [code] + 1;
123
                level= rl->table_level[code];
124
            }
125
        }
126
        rl->rl_vlc[0][i].len= len;
127
        rl->rl_vlc[0][i].level= level;
128
        rl->rl_vlc[0][i].run= run;
129
    }
130
}
131

    
132
static void init_uni_ac_vlc(RLTable *rl, uint32_t *uni_ac_vlc_bits, uint8_t *uni_ac_vlc_len){
133
    int i;
134

    
135
    for(i=0; i<128; i++){
136
        int level= i-64;
137
        int run;
138
        for(run=0; run<64; run++){
139
            int len, bits, code;
140
            
141
            int alevel= ABS(level);
142
            int sign= (level>>31)&1;
143

    
144
            if (alevel > rl->max_level[0][run])
145
                code= 111; /*rl->n*/
146
            else
147
                code= rl->index_run[0][run] + alevel - 1;
148

    
149
            if (code < 111 /* rl->n */) {
150
                    /* store the vlc & sign at once */
151
                len=   mpeg1_vlc[code][1]+1;
152
                bits= (mpeg1_vlc[code][0]<<1) + sign;
153
            } else {
154
                len=  mpeg1_vlc[111/*rl->n*/][1]+6;
155
                bits= mpeg1_vlc[111/*rl->n*/][0]<<6;
156

    
157
                bits|= run;
158
                if (alevel < 128) {
159
                    bits<<=8; len+=8;
160
                    bits|= level & 0xff;
161
                } else {
162
                    bits<<=16; len+=16;
163
                    bits|= level & 0xff;
164
                    if (level < 0) {
165
                        bits|= 0x8001 + level + 255;
166
                    } else {
167
                        bits|= level & 0xffff;
168
                    }
169
                }
170
            }
171

    
172
            uni_ac_vlc_bits[UNI_AC_ENC_INDEX(run, i)]= bits;
173
            uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len;
174
        }
175
    }
176
}
177

    
178
static void put_header(MpegEncContext *s, int header)
179
{
180
    align_put_bits(&s->pb);
181
    put_bits(&s->pb, 16, header>>16);
182
    put_bits(&s->pb, 16, header&0xFFFF);
183
}
184

    
185
/* put sequence header if needed */
186
static void mpeg1_encode_sequence_header(MpegEncContext *s)
187
{
188
        unsigned int vbv_buffer_size;
189
        unsigned int fps, v;
190
        int n, i;
191
        uint64_t time_code;
192
        float best_aspect_error= 1E10;
193
        float aspect_ratio= s->avctx->aspect_ratio;
194
        
195
        if(aspect_ratio==0.0) aspect_ratio= s->width / (float)s->height; //pixel aspect 1:1 (VGA)
196
        
197
        if (s->current_picture.key_frame) {
198
            /* mpeg1 header repeated every gop */
199
            put_header(s, SEQ_START_CODE);
200
            
201
            /* search closest frame rate */
202
            {
203
                int i, dmin, d;
204
                s->frame_rate_index = 0;
205
                dmin = 0x7fffffff;
206
                for(i=1;i<9;i++) {
207
                    d = abs(s->frame_rate - frame_rate_tab[i]);
208
                    if (d < dmin) {
209
                        dmin = d;
210
                        s->frame_rate_index = i;
211
                    }
212
                }
213
            }
214
 
215
            put_bits(&s->pb, 12, s->width);
216
            put_bits(&s->pb, 12, s->height);
217
            
218
            for(i=1; i<15; i++){
219
                float error= mpeg1_aspect[i] - s->width/(s->height*aspect_ratio);
220
                error= ABS(error);
221
                
222
                if(error < best_aspect_error){
223
                    best_aspect_error= error;
224
                    s->aspect_ratio_info= i;
225
                }
226
            }
227
            
228
            put_bits(&s->pb, 4, s->aspect_ratio_info);
229
            put_bits(&s->pb, 4, s->frame_rate_index);
230
            v = s->bit_rate / 400;
231
            if (v > 0x3ffff)
232
                v = 0x3ffff;
233
            put_bits(&s->pb, 18, v);
234
            put_bits(&s->pb, 1, 1); /* marker */
235

    
236
            if(s->avctx->rc_buffer_size)
237
                vbv_buffer_size = s->avctx->rc_buffer_size;
238
            else
239
                /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */
240
                vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;         
241
            put_bits(&s->pb, 10, (vbv_buffer_size + 16383) / 16384); 
242
            put_bits(&s->pb, 1, 1); /* constrained parameter flag */
243
            put_bits(&s->pb, 1, 0); /* no custom intra matrix */
244
            put_bits(&s->pb, 1, 0); /* no custom non intra matrix */
245

    
246
            put_header(s, GOP_START_CODE);
247
            put_bits(&s->pb, 1, 0); /* do drop frame */
248
            /* time code : we must convert from the real frame rate to a
249
               fake mpeg frame rate in case of low frame rate */
250
            fps = frame_rate_tab[s->frame_rate_index];
251
            time_code = (int64_t)s->fake_picture_number * FRAME_RATE_BASE;
252
            s->gop_picture_number = s->fake_picture_number;
253
            put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
254
            put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
255
            put_bits(&s->pb, 1, 1);
256
            put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
257
            put_bits(&s->pb, 6, (uint32_t)((time_code % fps) / FRAME_RATE_BASE));
258
            put_bits(&s->pb, 1, 1); /* closed gop */
259
            put_bits(&s->pb, 1, 0); /* broken link */
260
        }
261

    
262
        if (s->frame_rate < (24 * FRAME_RATE_BASE) && s->picture_number > 0) {
263
            /* insert empty P pictures to slow down to the desired
264
               frame rate. Each fake pictures takes about 20 bytes */
265
            fps = frame_rate_tab[s->frame_rate_index];
266
            n = (((int64_t)s->picture_number * fps) / s->frame_rate) - 1;
267
            while (s->fake_picture_number < n) {
268
                mpeg1_skip_picture(s, s->fake_picture_number - 
269
                                   s->gop_picture_number); 
270
                s->fake_picture_number++;
271
            }
272

    
273
        }
274
}
275

    
276

    
277
/* insert a fake P picture */
278
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)
279
{
280
    unsigned int mb_incr;
281

    
282
    /* mpeg1 picture header */
283
    put_header(s, PICTURE_START_CODE);
284
    /* temporal reference */
285
    put_bits(&s->pb, 10, pict_num & 0x3ff); 
286
    
287
    put_bits(&s->pb, 3, P_TYPE);
288
    put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
289
    
290
    put_bits(&s->pb, 1, 1); /* integer coordinates */
291
    put_bits(&s->pb, 3, 1); /* forward_f_code */
292
    
293
    put_bits(&s->pb, 1, 0); /* extra bit picture */
294
    
295
    /* only one slice */
296
    put_header(s, SLICE_MIN_START_CODE);
297
    put_bits(&s->pb, 5, 1); /* quantizer scale */
298
    put_bits(&s->pb, 1, 0); /* slice extra information */
299
    
300
    mb_incr = 1;
301
    put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 
302
             mbAddrIncrTable[mb_incr - 1][0]);
303
    
304
    /* empty macroblock */
305
    put_bits(&s->pb, 3, 1); /* motion only */
306
    
307
    /* zero motion x & y */
308
    put_bits(&s->pb, 1, 1); 
309
    put_bits(&s->pb, 1, 1); 
310

    
311
    /* output a number of empty slice */
312
    mb_incr = s->mb_width * s->mb_height - 1;
313
    while (mb_incr > 33) {
314
        put_bits(&s->pb, 11, 0x008);
315
        mb_incr -= 33;
316
    }
317
    put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 
318
             mbAddrIncrTable[mb_incr - 1][0]);
319
    
320
    /* empty macroblock */
321
    put_bits(&s->pb, 3, 1); /* motion only */
322
    
323
    /* zero motion x & y */
324
    put_bits(&s->pb, 1, 1); 
325
    put_bits(&s->pb, 1, 1); 
326
}
327

    
328
static void common_init(MpegEncContext *s)
329
{
330
    s->y_dc_scale_table=
331
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
332
}
333

    
334
#ifdef CONFIG_ENCODERS
335
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
336
{
337
    mpeg1_encode_sequence_header(s);
338

    
339
    /* mpeg1 picture header */
340
    put_header(s, PICTURE_START_CODE);
341
    /* temporal reference */
342

    
343
    // RAL: s->picture_number instead of s->fake_picture_number
344
    put_bits(&s->pb, 10, (s->picture_number - 
345
                          s->gop_picture_number) & 0x3ff); 
346
    s->fake_picture_number++;
347
    
348
    put_bits(&s->pb, 3, s->pict_type);
349
    put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
350
    
351
    // RAL: Forward f_code also needed for B frames
352
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
353
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
354
        put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
355
    }
356
    
357
    // RAL: Backward f_code necessary for B frames
358
    if (s->pict_type == B_TYPE) {
359
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
360
        put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
361
        }
362

    
363
    put_bits(&s->pb, 1, 0); /* extra bit picture */
364
    
365
    /* only one slice */
366
    put_header(s, SLICE_MIN_START_CODE);
367
    put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
368
    put_bits(&s->pb, 1, 0); /* slice extra information */
369
}
370

    
371
void mpeg1_encode_mb(MpegEncContext *s,
372
                     DCTELEM block[6][64],
373
                     int motion_x, int motion_y)
374
{
375
    int mb_incr, i, cbp, mb_x, mb_y;
376

    
377
    mb_x = s->mb_x;
378
    mb_y = s->mb_y;
379

    
380
    /* compute cbp */
381
    cbp = 0;
382
    for(i=0;i<6;i++) {
383
        if (s->block_last_index[i] >= 0)
384
            cbp |= 1 << (5 - i);
385
    }
386

    
387
    // RAL: Skipped macroblocks for B frames...
388
    if (cbp == 0 && (!((mb_x | mb_y) == 0 || (mb_x == s->mb_width - 1 && mb_y == s->mb_height - 1))) && 
389
        ((s->pict_type == P_TYPE && (motion_x | motion_y) == 0) ||
390
        (s->pict_type == B_TYPE && s->mv_dir == s->last_mv_dir && (((s->mv_dir & MV_DIR_FORWARD) ? ((s->mv[0][0][0] - s->last_mv[0][0][0])|(s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
391
        ((s->mv_dir & MV_DIR_BACKWARD) ? ((s->mv[1][0][0] - s->last_mv[1][0][0])|(s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
392
        s->mb_incr++;
393
        s->qscale -= s->dquant;
394
        s->skip_count++;
395
        s->misc_bits++;
396
        s->last_bits++;
397
    } else {
398
        /* output mb incr */
399
        mb_incr = s->mb_incr;
400

    
401
        while (mb_incr > 33) {
402
            put_bits(&s->pb, 11, 0x008);
403
            mb_incr -= 33;
404
        }
405
        put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 
406
                 mbAddrIncrTable[mb_incr - 1][0]);
407
        
408
        if (s->pict_type == I_TYPE) {
409
            if(s->dquant && cbp){
410
                put_bits(&s->pb, 2, 1); /* macroblock_type : macroblock_quant = 1 */
411
                put_bits(&s->pb, 5, s->qscale);
412
            }else{
413
                put_bits(&s->pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */
414
                s->qscale -= s->dquant;
415
            }
416
            s->misc_bits+= get_bits_diff(s);
417
            s->i_count++;
418
        } else if (s->mb_intra) {
419
            if(s->dquant && cbp){
420
                put_bits(&s->pb, 6, 0x01);
421
                put_bits(&s->pb, 5, s->qscale);
422
            }else{
423
                put_bits(&s->pb, 5, 0x03);
424
                s->qscale -= s->dquant;
425
            }
426
            s->misc_bits+= get_bits_diff(s);
427
            s->i_count++;
428
            s->last_mv[0][0][0] = 
429
            s->last_mv[0][0][1] = 0;
430
        } else if (s->pict_type == P_TYPE) { 
431
                if (cbp != 0) {
432
                    if (motion_x == 0 && motion_y == 0) {
433
                        if(s->dquant){
434
                            put_bits(&s->pb, 5, 1); /* macroblock_pattern & quant */
435
                            put_bits(&s->pb, 5, s->qscale);
436
                        }else{
437
                            put_bits(&s->pb, 2, 1); /* macroblock_pattern only */
438
                        }
439
                        s->misc_bits+= get_bits_diff(s);
440
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
441
                    } else {
442
                        if(s->dquant){
443
                            put_bits(&s->pb, 5, 2); /* motion + cbp */
444
                            put_bits(&s->pb, 5, s->qscale);
445
                        }else{
446
                            put_bits(&s->pb, 1, 1); /* motion + cbp */
447
                        }
448
                        s->misc_bits+= get_bits_diff(s);
449
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
450
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
451
                        s->mv_bits+= get_bits_diff(s);
452
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
453
                    }
454
                } else {
455
                    put_bits(&s->pb, 3, 1); /* motion only */
456
                    mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
457
                    mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
458
                    s->qscale -= s->dquant;
459
                    s->mv_bits+= get_bits_diff(s);
460
                }
461
                s->f_count++;
462
        } else
463
            {    // RAL: All the following bloc added for B frames:
464
                if (cbp != 0)
465
                    {    // With coded bloc pattern
466
                    if (s->mv_dir == (MV_DIR_FORWARD | MV_DIR_BACKWARD))
467
                        {    // Bi-directional motion
468
                        if (s->dquant)
469
                            {    // With QScale
470
                            put_bits(&s->pb, 5, 2);
471
                            put_bits(&s->pb, 5, s->qscale);
472
                            }
473
                        else    // Without QScale
474
                            put_bits(&s->pb, 2, 3);
475
                        s->misc_bits += get_bits_diff(s);
476
                        mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
477
                        mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
478
                        mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
479
                        mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
480
                        s->b_count++;
481
                        s->f_count++;
482
                        s->mv_bits += get_bits_diff(s);
483
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
484
                        }
485
                    else if (s->mv_dir == MV_DIR_BACKWARD)
486
                        {    // Backward motion
487
                        if (s->dquant)
488
                            {    // With QScale
489
                            put_bits(&s->pb, 6, 2);
490
                            put_bits(&s->pb, 5, s->qscale);
491
                            }
492
                        else    // Without QScale
493
                            put_bits(&s->pb, 3, 3);
494
                        s->misc_bits += get_bits_diff(s);
495
                        mpeg1_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code); 
496
                        mpeg1_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code); 
497
                        s->b_count++;
498
                        s->mv_bits += get_bits_diff(s);
499
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
500
                        }
501
                    else if (s->mv_dir == MV_DIR_FORWARD)
502
                        {    // Forward motion
503
                        if (s->dquant)
504
                            {    // With QScale
505
                            put_bits(&s->pb, 6, 3);
506
                            put_bits(&s->pb, 5, s->qscale);
507
                            }
508
                        else    // Without QScale
509
                            put_bits(&s->pb, 4, 3);
510
                        s->misc_bits += get_bits_diff(s);
511
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); 
512
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); 
513
                        s->f_count++;
514
                        s->mv_bits += get_bits_diff(s);
515
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
516
                        }
517
                    }
518
                else
519
                    {    // No coded bloc pattern
520
                    if (s->mv_dir == (MV_DIR_FORWARD | MV_DIR_BACKWARD))
521
                        {    // Bi-directional motion 
522
                        put_bits(&s->pb, 2, 2); /* backward & forward motion */
523
                        mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
524
                        mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
525
                        mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
526
                        mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
527
                        s->b_count++;
528
                        s->f_count++;
529
                        }
530
                    else if (s->mv_dir == MV_DIR_BACKWARD)
531
                        {    // Backward motion
532
                        put_bits(&s->pb, 3, 2); /* backward motion only */
533
                        mpeg1_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code); 
534
                        mpeg1_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code); 
535
                        s->b_count++;
536
                        }
537
                    else if (s->mv_dir == MV_DIR_FORWARD)
538
                        {    // Forward motion
539
                        put_bits(&s->pb, 4, 2); /* forward motion only */
540
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); 
541
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); 
542
                        s->f_count++;
543
                        }
544
                    s->qscale -= s->dquant;
545
                    s->mv_bits += get_bits_diff(s);
546
                    }
547
            // End of bloc from RAL
548
            }
549
        for(i=0;i<6;i++) {
550
            if (cbp & (1 << (5 - i))) {
551
                mpeg1_encode_block(s, block[i], i);
552
            }
553
        }
554
        s->mb_incr = 1;
555
        if(s->mb_intra)
556
            s->i_tex_bits+= get_bits_diff(s);
557
        else
558
            s->p_tex_bits+= get_bits_diff(s);
559
    }
560

    
561
    // RAL: By this:
562
    if (s->mv_dir & MV_DIR_FORWARD)
563
        {
564
        s->last_mv[0][0][0]= s->mv[0][0][0];
565
        s->last_mv[0][0][1]= s->mv[0][0][1];
566
        }
567
    if (s->mv_dir & MV_DIR_BACKWARD)
568
        {
569
        s->last_mv[1][0][0]= s->mv[1][0][0];
570
        s->last_mv[1][0][1]= s->mv[1][0][1];
571
        }
572
}
573

    
574
// RAL: Parameter added: f_or_b_code
575
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
576
{
577
    int code, bit_size, l, m, bits, range, sign;
578

    
579
    if (val == 0) {
580
        /* zero vector */
581
        code = 0;
582
        put_bits(&s->pb,
583
                 mbMotionVectorTable[0][1], 
584
                 mbMotionVectorTable[0][0]); 
585
    } else {
586
        bit_size = f_or_b_code - 1;
587
        range = 1 << bit_size;
588
        /* modulo encoding */
589
        l = 16 * range;
590
        m = 2 * l;
591
        if (val < -l) {
592
            val += m;
593
        } else if (val >= l) {
594
            val -= m;
595
        }
596

    
597
        if (val >= 0) {
598
            val--;
599
            code = (val >> bit_size) + 1;
600
            bits = val & (range - 1);
601
            sign = 0;
602
        } else {
603
            val = -val;
604
            val--;
605
            code = (val >> bit_size) + 1;
606
            bits = val & (range - 1);
607
            sign = 1;
608
        }
609

    
610
        assert(code > 0 && code <= 16);
611

    
612
        put_bits(&s->pb,
613
                 mbMotionVectorTable[code][1], 
614
                 mbMotionVectorTable[code][0]); 
615

    
616
        put_bits(&s->pb, 1, sign);
617
        if (bit_size > 0) {
618
            put_bits(&s->pb, bit_size, bits);
619
        }
620
    }
621
}
622

    
623
void ff_mpeg1_encode_init(MpegEncContext *s)
624
{
625
    static int done=0;
626

    
627
    common_init(s);
628

    
629
    if(!done){
630
        int f_code;
631
        int mv;
632
        int i;
633

    
634
        done=1;
635
        init_rl(&rl_mpeg1);
636

    
637
        for(i=0; i<64; i++)
638
        {
639
                mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
640
                mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
641
        }
642
        
643
        init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_bits, uni_mpeg1_ac_vlc_len);
644

    
645
        /* build unified dc encoding tables */
646
        for(i=-255; i<256; i++)
647
        {
648
                int adiff, index;
649
                int bits, code;
650
                int diff=i;
651

    
652
                adiff = ABS(diff);
653
                if(diff<0) diff--;
654
                index = vlc_dc_table[adiff];
655

    
656
                bits= vlc_dc_lum_bits[index] + index;
657
                code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
658
                mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
659
                
660
                bits= vlc_dc_chroma_bits[index] + index;
661
                code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
662
                mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
663
        }
664

    
665
        for(f_code=1; f_code<=MAX_FCODE; f_code++){
666
            for(mv=-MAX_MV; mv<=MAX_MV; mv++){
667
                int len;
668

    
669
                if(mv==0) len= mbMotionVectorTable[0][1];
670
                else{
671
                    int val, bit_size, range, code;
672

    
673
                    bit_size = s->f_code - 1;
674
                    range = 1 << bit_size;
675

    
676
                    val=mv;
677
                    if (val < 0) 
678
                        val = -val;
679
                    val--;
680
                    code = (val >> bit_size) + 1;
681
                    if(code<17){
682
                        len= mbMotionVectorTable[code][1] + 1 + bit_size;
683
                    }else{
684
                        len= mbMotionVectorTable[16][1] + 2 + bit_size;
685
                    }
686
                }
687

    
688
                mv_penalty[f_code][mv+MAX_MV]= len;
689
            }
690
        }
691
        
692

    
693
        for(f_code=MAX_FCODE; f_code>0; f_code--){
694
            for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
695
                fcode_tab[mv+MAX_MV]= f_code;
696
            }
697
        }
698
    }
699
    s->me.mv_penalty= mv_penalty;
700
    s->fcode_tab= fcode_tab;
701
    s->min_qcoeff=-255;
702
    s->max_qcoeff= 255;
703
    s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
704
    s->inter_quant_bias= 0;
705
    s->intra_ac_vlc_length=
706
    s->inter_ac_vlc_length= uni_mpeg1_ac_vlc_len;
707
}
708

    
709
static inline void encode_dc(MpegEncContext *s, int diff, int component)
710
{
711
    if (component == 0) {
712
        put_bits(
713
            &s->pb, 
714
            mpeg1_lum_dc_uni[diff+255]&0xFF,
715
            mpeg1_lum_dc_uni[diff+255]>>8);
716
    } else {
717
        put_bits(
718
            &s->pb, 
719
            mpeg1_chr_dc_uni[diff+255]&0xFF,
720
            mpeg1_chr_dc_uni[diff+255]>>8);
721
    }
722
}
723

    
724
static void mpeg1_encode_block(MpegEncContext *s, 
725
                               DCTELEM *block, 
726
                               int n)
727
{
728
    int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
729
    int code, component;
730
//    RLTable *rl = &rl_mpeg1;
731

    
732
    last_index = s->block_last_index[n];
733

    
734
    /* DC coef */
735
    if (s->mb_intra) {
736
        component = (n <= 3 ? 0 : n - 4 + 1);
737
        dc = block[0]; /* overflow is impossible */
738
        diff = dc - s->last_dc[component];
739
        encode_dc(s, diff, component);
740
        s->last_dc[component] = dc;
741
        i = 1;
742
    } else {
743
        /* encode the first coefficient : needs to be done here because
744
           it is handled slightly differently */
745
        level = block[0];
746
        if (abs(level) == 1) {
747
                code = ((uint32_t)level >> 31); /* the sign bit */
748
                put_bits(&s->pb, 2, code | 0x02);
749
                i = 1;
750
        } else {
751
            i = 0;
752
            last_non_zero = -1;
753
            goto next_coef;
754
        }
755
    }
756

    
757
    /* now quantify & encode AC coefs */
758
    last_non_zero = i - 1;
759

    
760
    for(;i<=last_index;i++) {
761
        j = s->intra_scantable.permutated[i];
762
        level = block[j];
763
    next_coef:
764
#if 0
765
        if (level != 0)
766
            dprintf("level[%d]=%d\n", i, level);
767
#endif            
768
        /* encode using VLC */
769
        if (level != 0) {
770
            run = i - last_non_zero - 1;
771
            
772
            alevel= level;
773
            MASK_ABS(sign, alevel)
774
            sign&=1;
775

    
776
//            code = get_rl_index(rl, 0, run, alevel);
777
            if (alevel <= mpeg1_max_level[0][run]){
778
                code= mpeg1_index_run[0][run] + alevel - 1;
779
                    /* store the vlc & sign at once */
780
                put_bits(&s->pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign);
781
            } else {
782
                /* escape seems to be pretty rare <5% so i dont optimize it */
783
                put_bits(&s->pb, mpeg1_vlc[111/*rl->n*/][1], mpeg1_vlc[111/*rl->n*/][0]);
784
                /* escape: only clip in this case */
785
                put_bits(&s->pb, 6, run);
786
                if (alevel < 128) {
787
                    put_bits(&s->pb, 8, level & 0xff);
788
                } else {
789
                    if (level < 0) {
790
                        put_bits(&s->pb, 16, 0x8001 + level + 255);
791
                    } else {
792
                        put_bits(&s->pb, 16, level & 0xffff);
793
                    }
794
                }
795
            }
796
            last_non_zero = i;
797
        }
798
    }
799
    /* end of block */
800
    put_bits(&s->pb, 2, 0x2);
801
}
802
#endif //CONFIG_ENCODERS
803

    
804
/******************************************/
805
/* decoding */
806

    
807
static VLC dc_lum_vlc;
808
static VLC dc_chroma_vlc;
809
static VLC mv_vlc;
810
static VLC mbincr_vlc;
811
static VLC mb_ptype_vlc;
812
static VLC mb_btype_vlc;
813
static VLC mb_pat_vlc;
814

    
815
static void init_vlcs(MpegEncContext *s)
816
{
817
    static int done = 0;
818

    
819
    if (!done) {
820
        done = 1;
821

    
822
        init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12, 
823
                 vlc_dc_lum_bits, 1, 1,
824
                 vlc_dc_lum_code, 2, 2);
825
        init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12, 
826
                 vlc_dc_chroma_bits, 1, 1,
827
                 vlc_dc_chroma_code, 2, 2);
828
        init_vlc(&mv_vlc, MV_VLC_BITS, 17, 
829
                 &mbMotionVectorTable[0][1], 2, 1,
830
                 &mbMotionVectorTable[0][0], 2, 1);
831
        init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 35, 
832
                 &mbAddrIncrTable[0][1], 2, 1,
833
                 &mbAddrIncrTable[0][0], 2, 1);
834
        init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63, 
835
                 &mbPatTable[0][1], 2, 1,
836
                 &mbPatTable[0][0], 2, 1);
837
        
838
        init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 32, 
839
                 &table_mb_ptype[0][1], 2, 1,
840
                 &table_mb_ptype[0][0], 2, 1);
841
        init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 32, 
842
                 &table_mb_btype[0][1], 2, 1,
843
                 &table_mb_btype[0][0], 2, 1);
844
        init_rl(&rl_mpeg1);
845
        init_rl(&rl_mpeg2);
846

    
847
        init_2d_vlc_rl(&rl_mpeg1);
848
        init_2d_vlc_rl(&rl_mpeg2);
849
    }
850
}
851

    
852
static inline int get_dmv(MpegEncContext *s)
853
{
854
    if(get_bits1(&s->gb)) 
855
        return 1 - (get_bits1(&s->gb) << 1);
856
    else
857
        return 0;
858
}
859

    
860
static inline int get_qscale(MpegEncContext *s)
861
{
862
    int qscale;
863
    if (s->mpeg2) {
864
        if (s->q_scale_type) {
865
            qscale = non_linear_qscale[get_bits(&s->gb, 5)];
866
        } else {
867
            qscale = get_bits(&s->gb, 5) << 1;
868
        }
869
    } else {
870
        /* for mpeg1, we use the generic unquant code */
871
        qscale = get_bits(&s->gb, 5);
872
    }
873
    return qscale;
874
}
875

    
876
/* motion type (for mpeg2) */
877
#define MT_FIELD 1
878
#define MT_FRAME 2
879
#define MT_16X8  2
880
#define MT_DMV   3
881

    
882
static int mpeg_decode_mb(MpegEncContext *s,
883
                          DCTELEM block[6][64])
884
{
885
    int i, j, k, cbp, val, mb_type, motion_type;
886
    
887
    dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
888

    
889
    assert(s->mb_skiped==0);
890

    
891
    if (--s->mb_incr != 0) {
892
        /* skip mb */
893
        s->mb_intra = 0;
894
        for(i=0;i<6;i++)
895
            s->block_last_index[i] = -1;
896
        s->mv_type = MV_TYPE_16X16;
897
        if (s->pict_type == P_TYPE) {
898
            /* if P type, zero motion vector is implied */
899
            s->mv_dir = MV_DIR_FORWARD;
900
            s->mv[0][0][0] = s->mv[0][0][1] = 0;
901
            s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
902
            s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
903
            s->mb_skiped = 1;
904
        } else {
905
            /* if B type, reuse previous vectors and directions */
906
            s->mv[0][0][0] = s->last_mv[0][0][0];
907
            s->mv[0][0][1] = s->last_mv[0][0][1];
908
            s->mv[1][0][0] = s->last_mv[1][0][0];
909
            s->mv[1][0][1] = s->last_mv[1][0][1];
910

    
911
            if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0) 
912
                s->mb_skiped = 1;
913
        }
914

    
915
        return 0;
916
    }
917

    
918
    switch(s->pict_type) {
919
    default:
920
    case I_TYPE:
921
        if (get_bits1(&s->gb) == 0) {
922
            if (get_bits1(&s->gb) == 0)
923
                return -1;
924
            mb_type = MB_QUANT | MB_INTRA;
925
        } else {
926
            mb_type = MB_INTRA;
927
        }
928
        break;
929
    case P_TYPE:
930
        mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
931
        if (mb_type < 0){
932
            fprintf(stderr, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
933
            return -1;
934
        }
935
        break;
936
    case B_TYPE:
937
        mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
938
        if (mb_type < 0){
939
            fprintf(stderr, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
940
            return -1;
941
        }
942
        break;
943
    }
944
    dprintf("mb_type=%x\n", mb_type);
945
    motion_type = 0; /* avoid warning */
946
    if (mb_type & (MB_FOR|MB_BACK)) {
947
        /* get additionnal motion vector type */
948
        if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) 
949
            motion_type = MT_FRAME;
950
        else
951
            motion_type = get_bits(&s->gb, 2);
952
    }
953
    /* compute dct type */
954
    if (s->picture_structure == PICT_FRAME && 
955
        !s->frame_pred_frame_dct &&
956
        (mb_type & (MB_PAT | MB_INTRA))) {
957
        s->interlaced_dct = get_bits1(&s->gb);
958
#ifdef DEBUG
959
        if (s->interlaced_dct)
960
            printf("interlaced_dct\n");
961
#endif
962
    } else {
963
        s->interlaced_dct = 0; /* frame based */
964
    }
965

    
966
    if (mb_type & MB_QUANT) {
967
        s->qscale = get_qscale(s);
968
    }
969
    if (mb_type & MB_INTRA) {
970
        if (s->concealment_motion_vectors) {
971
            /* just parse them */
972
            if (s->picture_structure != PICT_FRAME) 
973
                skip_bits1(&s->gb); /* field select */
974
            mpeg_decode_motion(s, s->mpeg_f_code[0][0], 0);
975
            mpeg_decode_motion(s, s->mpeg_f_code[0][1], 0);
976
        }
977
        s->mb_intra = 1;
978
        cbp = 0x3f;
979
        memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
980
    } else {
981
        s->mb_intra = 0;
982
        cbp = 0;
983
    }
984
    /* special case of implicit zero motion vector */
985
    if (s->pict_type == P_TYPE && !(mb_type & MB_FOR)) {
986
        s->mv_dir = MV_DIR_FORWARD;
987
        s->mv_type = MV_TYPE_16X16;
988
        s->last_mv[0][0][0] = 0;
989
        s->last_mv[0][0][1] = 0;
990
        s->last_mv[0][1][0] = 0;
991
        s->last_mv[0][1][1] = 0;
992
        s->mv[0][0][0] = 0;
993
        s->mv[0][0][1] = 0;
994
    } else if (mb_type & (MB_FOR | MB_BACK)) {
995
        /* motion vectors */
996
        s->mv_dir = 0;
997
        for(i=0;i<2;i++) {
998
            if (mb_type & (MB_FOR >> i)) {
999
                s->mv_dir |= (MV_DIR_FORWARD >> i);
1000
                dprintf("motion_type=%d\n", motion_type);
1001
                switch(motion_type) {
1002
                case MT_FRAME: /* or MT_16X8 */
1003
                    if (s->picture_structure == PICT_FRAME) {
1004
                        /* MT_FRAME */
1005
                        s->mv_type = MV_TYPE_16X16;
1006
                        for(k=0;k<2;k++) {
1007
                            val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], 
1008
                                                     s->last_mv[i][0][k]);
1009
                            s->last_mv[i][0][k] = val;
1010
                            s->last_mv[i][1][k] = val;
1011
                            /* full_pel: only for mpeg1 */
1012
                            if (s->full_pel[i])
1013
                                val = val << 1;
1014
                            s->mv[i][0][k] = val;
1015
                            dprintf("mv%d: %d\n", k, val);
1016
                        }
1017
                    } else {
1018
                        /* MT_16X8 */
1019
                        s->mv_type = MV_TYPE_16X8;
1020
                        for(j=0;j<2;j++) {
1021
                            s->field_select[i][j] = get_bits1(&s->gb);
1022
                            for(k=0;k<2;k++) {
1023
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1024
                                                         s->last_mv[i][j][k]);
1025
                                s->last_mv[i][j][k] = val;
1026
                                s->mv[i][j][k] = val;
1027
                            }
1028
                        }
1029
                    }
1030
                    break;
1031
                case MT_FIELD:
1032
                    s->mv_type = MV_TYPE_FIELD;
1033
                    if (s->picture_structure == PICT_FRAME) {
1034
                        for(j=0;j<2;j++) {
1035
                            s->field_select[i][j] = get_bits1(&s->gb);
1036
                            val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1037
                                                     s->last_mv[i][j][0]);
1038
                            s->last_mv[i][j][0] = val;
1039
                            s->mv[i][j][0] = val;
1040
                            dprintf("fmx=%d\n", val);
1041
                            val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1042
                                                     s->last_mv[i][j][1] >> 1);
1043
                            s->last_mv[i][j][1] = val << 1;
1044
                            s->mv[i][j][1] = val;
1045
                            dprintf("fmy=%d\n", val);
1046
                        }
1047
                    } else {
1048
                        s->field_select[i][0] = get_bits1(&s->gb);
1049
                        for(k=0;k<2;k++) {
1050
                            val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1051
                                                     s->last_mv[i][0][k]);
1052
                            s->last_mv[i][0][k] = val;
1053
                            s->last_mv[i][1][k] = val;
1054
                            s->mv[i][0][k] = val;
1055
                        }
1056
                    }
1057
                    break;
1058
                case MT_DMV:
1059
                    {
1060
                        int dmx, dmy, mx, my, m;
1061

    
1062
                        mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 
1063
                                                s->last_mv[i][0][0]);
1064
                        s->last_mv[i][0][0] = mx;
1065
                        s->last_mv[i][1][0] = mx;
1066
                        dmx = get_dmv(s);
1067
                        my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 
1068
                                                s->last_mv[i][0][1] >> 1);
1069
                        dmy = get_dmv(s);
1070
                        s->mv_type = MV_TYPE_DMV;
1071
                        /* XXX: totally broken */
1072
                        if (s->picture_structure == PICT_FRAME) {
1073
                            s->last_mv[i][0][1] = my << 1;
1074
                            s->last_mv[i][1][1] = my << 1;
1075

    
1076
                            m = s->top_field_first ? 1 : 3;
1077
                            /* top -> top pred */
1078
                            s->mv[i][0][0] = mx; 
1079
                            s->mv[i][0][1] = my << 1;
1080
                            s->mv[i][1][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1081
                            s->mv[i][1][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1082
                            m = 4 - m;
1083
                            s->mv[i][2][0] = mx;
1084
                            s->mv[i][2][1] = my << 1;
1085
                            s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1086
                            s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1087
                        } else {
1088
                            s->last_mv[i][0][1] = my;
1089
                            s->last_mv[i][1][1] = my;
1090
                            s->mv[i][0][0] = mx;
1091
                            s->mv[i][0][1] = my;
1092
                            s->mv[i][1][0] = ((mx + (mx > 0)) >> 1) + dmx;
1093
                            s->mv[i][1][1] = ((my + (my > 0)) >> 1) + dmy - 1 
1094
                                /* + 2 * cur_field */;
1095
                        }
1096
                    }
1097
                    break;
1098
                }
1099
            }
1100
        }
1101
    }
1102

    
1103
    if ((mb_type & MB_INTRA) && s->concealment_motion_vectors) {
1104
        skip_bits1(&s->gb); /* marker */
1105
    }
1106
    
1107
    if (mb_type & MB_PAT) {
1108
        cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1109
        if (cbp < 0){
1110
            fprintf(stderr, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
1111
            return -1;
1112
        }
1113
        cbp++;
1114
    }
1115
    dprintf("cbp=%x\n", cbp);
1116

    
1117
    if (s->mpeg2) {
1118
        if (s->mb_intra) {
1119
            for(i=0;i<6;i++) {
1120
                if (mpeg2_decode_block_intra(s, block[i], i) < 0)
1121
                    return -1;
1122
            }
1123
        } else {
1124
            for(i=0;i<6;i++) {
1125
                if (cbp & 32) {
1126
                    if (mpeg2_decode_block_non_intra(s, block[i], i) < 0)
1127
                        return -1;
1128
                } else {
1129
                    s->block_last_index[i] = -1;
1130
                }
1131
                cbp+=cbp;
1132
            }
1133
        }
1134
    } else {
1135
        if (s->mb_intra) {
1136
            for(i=0;i<6;i++) {
1137
                if (mpeg1_decode_block_intra(s, block[i], i) < 0)
1138
                    return -1;
1139
            }
1140
        }else{
1141
            for(i=0;i<6;i++) {
1142
                if (cbp & 32) {
1143
                    if (mpeg1_decode_block_inter(s, block[i], i) < 0)
1144
                        return -1;
1145
                } else {
1146
                    s->block_last_index[i] = -1;
1147
                }
1148
                cbp+=cbp;
1149
            }
1150
        }
1151
    }
1152
    return 0;
1153
}
1154

    
1155
/* as h263, but only 17 codes */
1156
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
1157
{
1158
    int code, sign, val, m, l, shift;
1159

    
1160
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
1161
    if (code < 0) {
1162
        return 0xffff;
1163
    }
1164
    if (code == 0) {
1165
        return pred;
1166
    }
1167
    sign = get_bits1(&s->gb);
1168
    shift = fcode - 1;
1169
    val = (code - 1) << shift;
1170
    if (shift > 0)
1171
        val |= get_bits(&s->gb, shift);
1172
    val++;
1173
    if (sign)
1174
        val = -val;
1175
    val += pred;
1176
    
1177
    /* modulo decoding */
1178
    l = (1 << shift) * 16;
1179
    m = 2 * l;
1180
    if (val < -l) {
1181
        val += m;
1182
    } else if (val >= l) {
1183
        val -= m;
1184
    }
1185
    return val;
1186
}
1187

    
1188
static inline int decode_dc(MpegEncContext *s, int component)
1189
{
1190
    int code, diff;
1191

    
1192
    if (component == 0) {
1193
        code = get_vlc2(&s->gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1194
    } else {
1195
        code = get_vlc2(&s->gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1196
    }
1197
    if (code < 0){
1198
        fprintf(stderr, "invalid dc code at %d %d\n", s->mb_x, s->mb_y);
1199
        return 0xffff;
1200
    }
1201
    if (code == 0) {
1202
        diff = 0;
1203
    } else {
1204
        diff = get_bits(&s->gb, code);
1205
        if ((diff & (1 << (code - 1))) == 0) 
1206
            diff = (-1 << code) | (diff + 1);
1207
    }
1208
    return diff;
1209
}
1210

    
1211
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
1212
                               DCTELEM *block, 
1213
                               int n)
1214
{
1215
    int level, dc, diff, i, j, run;
1216
    int component;
1217
    RLTable *rl = &rl_mpeg1;
1218
    uint8_t * const scantable= s->intra_scantable.permutated;
1219
    const uint16_t *quant_matrix= s->intra_matrix;
1220
    const int qscale= s->qscale;
1221

    
1222
    /* DC coef */
1223
    component = (n <= 3 ? 0 : n - 4 + 1);
1224
    diff = decode_dc(s, component);
1225
    if (diff >= 0xffff)
1226
        return -1;
1227
    dc = s->last_dc[component];
1228
    dc += diff;
1229
    s->last_dc[component] = dc;
1230
    block[0] = dc<<3;
1231
    dprintf("dc=%d diff=%d\n", dc, diff);
1232
    i = 0;
1233
    {
1234
        OPEN_READER(re, &s->gb);    
1235
        /* now quantify & encode AC coefs */
1236
        for(;;) {
1237
            UPDATE_CACHE(re, &s->gb);
1238
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1239
            
1240
            if(level == 127){
1241
                break;
1242
            } else if(level != 0) {
1243
                i += run;
1244
                j = scantable[i];
1245
                level= (level*qscale*quant_matrix[j])>>3;
1246
                level= (level-1)|1;
1247
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1248
                LAST_SKIP_BITS(re, &s->gb, 1);
1249
            } else {
1250
                /* escape */
1251
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1252
                UPDATE_CACHE(re, &s->gb);
1253
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1254
                if (level == -128) {
1255
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1256
                } else if (level == 0) {
1257
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1258
                }
1259
                i += run;
1260
                j = scantable[i];
1261
                if(level<0){
1262
                    level= -level;
1263
                    level= (level*qscale*quant_matrix[j])>>3;
1264
                    level= (level-1)|1;
1265
                    level= -level;
1266
                }else{
1267
                    level= (level*qscale*quant_matrix[j])>>3;
1268
                    level= (level-1)|1;
1269
                }
1270
            }
1271
            if (i > 63){
1272
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1273
                return -1;
1274
            }
1275

    
1276
            block[j] = level;
1277
        }
1278
        CLOSE_READER(re, &s->gb);
1279
    }
1280
    s->block_last_index[n] = i;
1281
   return 0;
1282
}
1283

    
1284
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
1285
                               DCTELEM *block, 
1286
                               int n)
1287
{
1288
    int level, i, j, run;
1289
    RLTable *rl = &rl_mpeg1;
1290
    uint8_t * const scantable= s->intra_scantable.permutated;
1291
    const uint16_t *quant_matrix= s->inter_matrix;
1292
    const int qscale= s->qscale;
1293

    
1294
    {
1295
        int v;
1296
        OPEN_READER(re, &s->gb);
1297
        i = -1;
1298
        /* special case for the first coef. no need to add a second vlc table */
1299
        UPDATE_CACHE(re, &s->gb);
1300
        v= SHOW_UBITS(re, &s->gb, 2);
1301
        if (v & 2) {
1302
            LAST_SKIP_BITS(re, &s->gb, 2);
1303
            level= (3*qscale*quant_matrix[0])>>4;
1304
            level= (level-1)|1;
1305
            if(v&1)
1306
                level= -level;
1307
            block[0] = level;
1308
            i++;
1309
        }
1310

    
1311
        /* now quantify & encode AC coefs */
1312
        for(;;) {
1313
            UPDATE_CACHE(re, &s->gb);
1314
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1315
            
1316
            if(level == 127){
1317
                break;
1318
            } else if(level != 0) {
1319
                i += run;
1320
                j = scantable[i];
1321
                level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1322
                level= (level-1)|1;
1323
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1324
                LAST_SKIP_BITS(re, &s->gb, 1);
1325
            } else {
1326
                /* escape */
1327
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1328
                UPDATE_CACHE(re, &s->gb);
1329
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1330
                if (level == -128) {
1331
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1332
                } else if (level == 0) {
1333
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1334
                }
1335
                i += run;
1336
                j = scantable[i];
1337
                if(level<0){
1338
                    level= -level;
1339
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1340
                    level= (level-1)|1;
1341
                    level= -level;
1342
                }else{
1343
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1344
                    level= (level-1)|1;
1345
                }
1346
            }
1347
            if (i > 63){
1348
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1349
                return -1;
1350
            }
1351

    
1352
            block[j] = level;
1353
        }
1354
        CLOSE_READER(re, &s->gb);
1355
    }
1356
    s->block_last_index[n] = i;
1357
    return 0;
1358
}
1359

    
1360
/* Also does unquantization here, since I will never support mpeg2
1361
   encoding */
1362
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1363
                               DCTELEM *block, 
1364
                               int n)
1365
{
1366
    int level, i, j, run;
1367
    RLTable *rl = &rl_mpeg1;
1368
    uint8_t * const scantable= s->intra_scantable.permutated;
1369
    const uint16_t *quant_matrix;
1370
    const int qscale= s->qscale;
1371
    int mismatch;
1372

    
1373
    mismatch = 1;
1374

    
1375
    {
1376
        int v;
1377
        OPEN_READER(re, &s->gb);
1378
        i = -1;
1379
        if (n < 4)
1380
            quant_matrix = s->inter_matrix;
1381
        else
1382
            quant_matrix = s->chroma_inter_matrix;
1383

    
1384
        /* special case for the first coef. no need to add a second vlc table */
1385
        UPDATE_CACHE(re, &s->gb);
1386
        v= SHOW_UBITS(re, &s->gb, 2);
1387
        if (v & 2) {
1388
            LAST_SKIP_BITS(re, &s->gb, 2);
1389
            level= (3*qscale*quant_matrix[0])>>5;
1390
            if(v&1)
1391
                level= -level;
1392
            block[0] = level;
1393
            mismatch ^= level;
1394
            i++;
1395
        }
1396

    
1397
        /* now quantify & encode AC coefs */
1398
        for(;;) {
1399
            UPDATE_CACHE(re, &s->gb);
1400
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1401
            
1402
            if(level == 127){
1403
                break;
1404
            } else if(level != 0) {
1405
                i += run;
1406
                j = scantable[i];
1407
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1408
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1409
                LAST_SKIP_BITS(re, &s->gb, 1);
1410
            } else {
1411
                /* escape */
1412
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1413
                UPDATE_CACHE(re, &s->gb);
1414
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1415

    
1416
                i += run;
1417
                j = scantable[i];
1418
                if(level<0){
1419
                    level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1420
                    level= -level;
1421
                }else{
1422
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1423
                }
1424
            }
1425
            if (i > 63){
1426
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1427
                return -1;
1428
            }
1429
            
1430
            mismatch ^= level;
1431
            block[j] = level;
1432
        }
1433
        CLOSE_READER(re, &s->gb);
1434
    }
1435
    block[63] ^= (mismatch & 1);
1436
    
1437
    s->block_last_index[n] = i;
1438
    return 0;
1439
}
1440

    
1441
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
1442
                               DCTELEM *block, 
1443
                               int n)
1444
{
1445
    int level, dc, diff, i, j, run;
1446
    int component;
1447
    RLTable *rl;
1448
    uint8_t * const scantable= s->intra_scantable.permutated;
1449
    const uint16_t *quant_matrix;
1450
    const int qscale= s->qscale;
1451
    int mismatch;
1452

    
1453
    /* DC coef */
1454
    if (n < 4){
1455
        quant_matrix = s->intra_matrix;
1456
        component = 0; 
1457
    }else{
1458
        quant_matrix = s->chroma_intra_matrix;
1459
        component = n - 3;
1460
    }
1461
    diff = decode_dc(s, component);
1462
    if (diff >= 0xffff)
1463
        return -1;
1464
    dc = s->last_dc[component];
1465
    dc += diff;
1466
    s->last_dc[component] = dc;
1467
    block[0] = dc << (3 - s->intra_dc_precision);
1468
    dprintf("dc=%d\n", block[0]);
1469
    mismatch = block[0] ^ 1;
1470
    i = 0;
1471
    if (s->intra_vlc_format)
1472
        rl = &rl_mpeg2;
1473
    else
1474
        rl = &rl_mpeg1;
1475

    
1476
    {
1477
        OPEN_READER(re, &s->gb);    
1478
        /* now quantify & encode AC coefs */
1479
        for(;;) {
1480
            UPDATE_CACHE(re, &s->gb);
1481
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1482
            
1483
            if(level == 127){
1484
                break;
1485
            } else if(level != 0) {
1486
                i += run;
1487
                j = scantable[i];
1488
                level= (level*qscale*quant_matrix[j])>>4;
1489
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1490
                LAST_SKIP_BITS(re, &s->gb, 1);
1491
            } else {
1492
                /* escape */
1493
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1494
                UPDATE_CACHE(re, &s->gb);
1495
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1496
                i += run;
1497
                j = scantable[i];
1498
                if(level<0){
1499
                    level= (-level*qscale*quant_matrix[j])>>4;
1500
                    level= -level;
1501
                }else{
1502
                    level= (level*qscale*quant_matrix[j])>>4;
1503
                }
1504
            }
1505
            if (i > 63){
1506
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1507
                return -1;
1508
            }
1509
            
1510
            mismatch^= level;
1511
            block[j] = level;
1512
        }
1513
        CLOSE_READER(re, &s->gb);
1514
    }
1515
    block[63]^= mismatch&1;
1516
    
1517
    s->block_last_index[n] = i;
1518
    return 0;
1519
}
1520

    
1521
/* compressed picture size */
1522
#define PICTURE_BUFFER_SIZE 100000
1523

    
1524
typedef struct Mpeg1Context {
1525
    MpegEncContext mpeg_enc_ctx;
1526
    uint32_t header_state;
1527
    int start_code; /* current start code */
1528
    uint8_t buffer[PICTURE_BUFFER_SIZE]; 
1529
    uint8_t *buf_ptr;
1530
    int buffer_size;
1531
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1532
    int repeat_field; /* true if we must repeat the field */
1533
} Mpeg1Context;
1534

    
1535
static int mpeg_decode_init(AVCodecContext *avctx)
1536
{
1537
    Mpeg1Context *s = avctx->priv_data;
1538
    
1539
    s->mpeg_enc_ctx.flags= avctx->flags;
1540
    common_init(&s->mpeg_enc_ctx);
1541
    init_vlcs(&s->mpeg_enc_ctx);
1542

    
1543
    s->header_state = 0xff;
1544
    s->mpeg_enc_ctx_allocated = 0;
1545
    s->buffer_size = PICTURE_BUFFER_SIZE;
1546
    s->start_code = -1;
1547
    s->buf_ptr = s->buffer;
1548
    s->mpeg_enc_ctx.picture_number = 0;
1549
    s->repeat_field = 0;
1550
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1551
    return 0;
1552
}
1553

    
1554
/* return the 8 bit start code value and update the search
1555
   state. Return -1 if no start code found */
1556
static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end, 
1557
                           uint32_t *header_state)
1558
{
1559
    uint8_t *buf_ptr;
1560
    unsigned int state, v;
1561
    int val;
1562

    
1563
    state = *header_state;
1564
    buf_ptr = *pbuf_ptr;
1565
    while (buf_ptr < buf_end) {
1566
        v = *buf_ptr++;
1567
        if (state == 0x000001) {
1568
            state = ((state << 8) | v) & 0xffffff;
1569
            val = state;
1570
            goto found;
1571
        }
1572
        state = ((state << 8) | v) & 0xffffff;
1573
    }
1574
    val = -1;
1575
 found:
1576
    *pbuf_ptr = buf_ptr;
1577
    *header_state = state;
1578
    return val;
1579
}
1580

    
1581
static int mpeg1_decode_picture(AVCodecContext *avctx, 
1582
                                uint8_t *buf, int buf_size)
1583
{
1584
    Mpeg1Context *s1 = avctx->priv_data;
1585
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1586
    int ref, f_code;
1587

    
1588
    init_get_bits(&s->gb, buf, buf_size*8);
1589

    
1590
    ref = get_bits(&s->gb, 10); /* temporal ref */
1591
    s->pict_type = get_bits(&s->gb, 3);
1592
    dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number);
1593

    
1594
    skip_bits(&s->gb, 16);
1595
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
1596
        s->full_pel[0] = get_bits1(&s->gb);
1597
        f_code = get_bits(&s->gb, 3);
1598
        if (f_code == 0)
1599
            return -1;
1600
        s->mpeg_f_code[0][0] = f_code;
1601
        s->mpeg_f_code[0][1] = f_code;
1602
    }
1603
    if (s->pict_type == B_TYPE) {
1604
        s->full_pel[1] = get_bits1(&s->gb);
1605
        f_code = get_bits(&s->gb, 3);
1606
        if (f_code == 0)
1607
            return -1;
1608
        s->mpeg_f_code[1][0] = f_code;
1609
        s->mpeg_f_code[1][1] = f_code;
1610
    }
1611
    s->current_picture.pict_type= s->pict_type;
1612
    s->current_picture.key_frame= s->pict_type == I_TYPE;
1613
    
1614
    s->y_dc_scale = 8;
1615
    s->c_dc_scale = 8;
1616
    s->first_slice = 1;
1617
    return 0;
1618
}
1619

    
1620
static void mpeg_decode_sequence_extension(MpegEncContext *s)
1621
{
1622
    int horiz_size_ext, vert_size_ext;
1623
    int bit_rate_ext, vbv_buf_ext;
1624
    int frame_rate_ext_n, frame_rate_ext_d;
1625
    float aspect;
1626

    
1627
    skip_bits(&s->gb, 8); /* profil and level */
1628
    s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1629
    skip_bits(&s->gb, 2); /* chroma_format */
1630
    horiz_size_ext = get_bits(&s->gb, 2);
1631
    vert_size_ext = get_bits(&s->gb, 2);
1632
    s->width |= (horiz_size_ext << 12);
1633
    s->height |= (vert_size_ext << 12);
1634
    bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1635
    s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
1636
    skip_bits1(&s->gb); /* marker */
1637
    vbv_buf_ext = get_bits(&s->gb, 8);
1638
    s->low_delay = get_bits1(&s->gb);
1639
    frame_rate_ext_n = get_bits(&s->gb, 2);
1640
    frame_rate_ext_d = get_bits(&s->gb, 5);
1641
    if (frame_rate_ext_d >= 1)
1642
        s->frame_rate = (s->frame_rate * frame_rate_ext_n) / frame_rate_ext_d;
1643
    dprintf("sequence extension\n");
1644
    s->mpeg2 = 1;
1645
    s->avctx->sub_id = 2; /* indicates mpeg2 found */
1646

    
1647
    aspect= mpeg2_aspect[s->aspect_ratio_info];
1648
    if(aspect>0.0)      s->avctx->aspect_ratio= s->width/(aspect*s->height);
1649
    else if(aspect<0.0) s->avctx->aspect_ratio= -1.0/aspect;
1650
}
1651

    
1652
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1653
{
1654
    int i, v, j;
1655

    
1656
    dprintf("matrix extension\n");
1657

    
1658
    if (get_bits1(&s->gb)) {
1659
        for(i=0;i<64;i++) {
1660
            v = get_bits(&s->gb, 8);
1661
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1662
            s->intra_matrix[j] = v;
1663
            s->chroma_intra_matrix[j] = v;
1664
        }
1665
    }
1666
    if (get_bits1(&s->gb)) {
1667
        for(i=0;i<64;i++) {
1668
            v = get_bits(&s->gb, 8);
1669
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1670
            s->inter_matrix[j] = v;
1671
            s->chroma_inter_matrix[j] = v;
1672
        }
1673
    }
1674
    if (get_bits1(&s->gb)) {
1675
        for(i=0;i<64;i++) {
1676
            v = get_bits(&s->gb, 8);
1677
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1678
            s->chroma_intra_matrix[j] = v;
1679
        }
1680
    }
1681
    if (get_bits1(&s->gb)) {
1682
        for(i=0;i<64;i++) {
1683
            v = get_bits(&s->gb, 8);
1684
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1685
            s->chroma_inter_matrix[j] = v;
1686
        }
1687
    }
1688
}
1689

    
1690
static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
1691
{
1692
    s->full_pel[0] = s->full_pel[1] = 0;
1693
    s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1694
    s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1695
    s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1696
    s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1697
    s->intra_dc_precision = get_bits(&s->gb, 2);
1698
    s->picture_structure = get_bits(&s->gb, 2);
1699
    s->top_field_first = get_bits1(&s->gb);
1700
    s->frame_pred_frame_dct = get_bits1(&s->gb);
1701
    s->concealment_motion_vectors = get_bits1(&s->gb);
1702
    s->q_scale_type = get_bits1(&s->gb);
1703
    s->intra_vlc_format = get_bits1(&s->gb);
1704
    s->alternate_scan = get_bits1(&s->gb);
1705
    s->repeat_first_field = get_bits1(&s->gb);
1706
    s->chroma_420_type = get_bits1(&s->gb);
1707
    s->progressive_frame = get_bits1(&s->gb);
1708
    
1709
    if(s->picture_structure == PICT_FRAME)
1710
        s->first_field=0;
1711
    else{
1712
        s->first_field ^= 1;
1713
        memset(s->mbskip_table, 0, s->mb_width*s->mb_height);
1714
    }
1715
    
1716
    if(s->alternate_scan){
1717
        ff_init_scantable(s, &s->inter_scantable  , ff_alternate_vertical_scan);
1718
        ff_init_scantable(s, &s->intra_scantable  , ff_alternate_vertical_scan);
1719
        ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
1720
        ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
1721
    }else{
1722
        ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
1723
        ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
1724
        ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
1725
        ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
1726
    }
1727
    
1728
    /* composite display not parsed */
1729
    dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
1730
    dprintf("picture_structure=%d\n", s->picture_structure);
1731
    dprintf("top field first=%d\n", s->top_field_first);
1732
    dprintf("repeat first field=%d\n", s->repeat_first_field);
1733
    dprintf("conceal=%d\n", s->concealment_motion_vectors);
1734
    dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
1735
    dprintf("alternate_scan=%d\n", s->alternate_scan);
1736
    dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1737
    dprintf("progressive_frame=%d\n", s->progressive_frame);
1738
}
1739

    
1740
static void mpeg_decode_extension(AVCodecContext *avctx, 
1741
                                  uint8_t *buf, int buf_size)
1742
{
1743
    Mpeg1Context *s1 = avctx->priv_data;
1744
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1745
    int ext_type;
1746

    
1747
    init_get_bits(&s->gb, buf, buf_size*8);
1748
    
1749
    ext_type = get_bits(&s->gb, 4);
1750
    switch(ext_type) {
1751
    case 0x1:
1752
        /* sequence ext */
1753
        mpeg_decode_sequence_extension(s);
1754
        break;
1755
    case 0x3:
1756
        /* quant matrix extension */
1757
        mpeg_decode_quant_matrix_extension(s);
1758
        break;
1759
    case 0x8:
1760
        /* picture extension */
1761
        mpeg_decode_picture_coding_extension(s);
1762
        break;
1763
    }
1764
}
1765

    
1766
#define DECODE_SLICE_FATAL_ERROR -2
1767
#define DECODE_SLICE_ERROR -1
1768
#define DECODE_SLICE_OK 0
1769
#define DECODE_SLICE_EOP 1
1770

    
1771
/**
1772
 * decodes a slice.
1773
 * @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br>
1774
 *         DECODE_SLICE_ERROR if the slice is damaged<br>
1775
 *         DECODE_SLICE_OK if this slice is ok<br>
1776
 *         DECODE_SLICE_EOP if the end of the picture is reached
1777
 */
1778
static int mpeg_decode_slice(AVCodecContext *avctx, 
1779
                              AVFrame *pict,
1780
                              int start_code,
1781
                              uint8_t *buf, int buf_size)
1782
{
1783
    Mpeg1Context *s1 = avctx->priv_data;
1784
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1785
    int ret;
1786
    const int field_pic= s->picture_structure != PICT_FRAME;
1787

    
1788
    start_code = (start_code - 1) & 0xff;
1789
    if (start_code >= s->mb_height){
1790
        fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);
1791
        return DECODE_SLICE_ERROR;
1792
    }
1793
    s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
1794
    s->last_dc[1] = s->last_dc[0];
1795
    s->last_dc[2] = s->last_dc[0];
1796
    memset(s->last_mv, 0, sizeof(s->last_mv));
1797
        
1798
    /* start frame decoding */
1799
    if (s->first_slice && (s->first_field || s->picture_structure==PICT_FRAME)) {
1800
        if(MPV_frame_start(s, avctx) < 0)
1801
            return DECODE_SLICE_FATAL_ERROR;
1802
        /* first check if we must repeat the frame */
1803
        s->current_picture.repeat_pict = 0;
1804

    
1805
        if (s->repeat_first_field) {
1806
            if (s->progressive_sequence) {
1807
                if (s->top_field_first)
1808
                    s->current_picture.repeat_pict = 4;
1809
                else
1810
                    s->current_picture.repeat_pict = 2;
1811
            } else if (s->progressive_frame) {
1812
                s->current_picture.repeat_pict = 1;
1813
            }
1814
        }         
1815
//        printf("%d \n", s->current_picture.repeat_pict);
1816

    
1817
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1818
             printf("qp:%d fc:%2d%2d%2d%2d %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n", 
1819
                 s->qscale, s->mpeg_f_code[0][0],s->mpeg_f_code[0][1],s->mpeg_f_code[1][0],s->mpeg_f_code[1][1],
1820
                 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), 
1821
                 s->progressive_sequence ? "pro" :"", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"", 
1822
                 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1823
                 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1824
        }
1825
    }
1826
    s->first_slice = 0;
1827

    
1828
    init_get_bits(&s->gb, buf, buf_size*8);
1829

    
1830
    s->qscale = get_qscale(s);
1831
    /* extra slice info */
1832
    while (get_bits1(&s->gb) != 0) {
1833
        skip_bits(&s->gb, 8);
1834
    }
1835

    
1836
    s->mb_x=0;
1837
    for(;;) {
1838
        int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1839
        if (code < 0)
1840
            return -1; /* error = end of slice, but empty slice is bad or?*/
1841
        if (code >= 33) {
1842
            if (code == 33) {
1843
                s->mb_x += 33;
1844
            }
1845
            /* otherwise, stuffing, nothing to do */
1846
        } else {
1847
            s->mb_x += code;
1848
            break;
1849
        }
1850
    }
1851
    s->mb_y = start_code;
1852
    s->mb_incr= 1;
1853

    
1854
    for(;;) {
1855
        s->dsp.clear_blocks(s->block[0]);
1856
        
1857
        ret = mpeg_decode_mb(s, s->block);
1858
        dprintf("ret=%d\n", ret);
1859
        if (ret < 0)
1860
            return -1;
1861
//printf("%d %d\n", s->mb_x, s->mb_y);
1862
        //FIXME this isnt the most beautifull way to solve the problem ...
1863
        if(s->picture_structure!=PICT_FRAME){
1864
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1865
                s->current_picture.data[0] += s->linesize;
1866
                s->current_picture.data[1] += s->uvlinesize;
1867
                s->current_picture.data[2] += s->uvlinesize;
1868
            } 
1869
            s->linesize *= 2;
1870
            s->uvlinesize *= 2;
1871
        }
1872
        MPV_decode_mb(s, s->block);
1873
        if(s->picture_structure!=PICT_FRAME){
1874
            s->linesize /= 2;
1875
            s->uvlinesize /= 2;
1876
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1877
                s->current_picture.data[0] -= s->linesize;
1878
                s->current_picture.data[1] -= s->uvlinesize;
1879
                s->current_picture.data[2] -= s->uvlinesize;
1880
            } 
1881
        }
1882

    
1883
        if (++s->mb_x >= s->mb_width) {
1884
            if(s->picture_structure==PICT_FRAME){
1885
                ff_draw_horiz_band(s, 16*s->mb_y, 16);
1886
            }else{
1887
                if(!s->first_field){
1888
                    ff_draw_horiz_band(s, 32*s->mb_y, 32);
1889
                }
1890
            }
1891

    
1892
            s->mb_x = 0;
1893
            s->mb_y++;
1894
            PRINT_QP("%s", "\n");
1895
        }
1896
        PRINT_QP("%2d", s->qscale);
1897

    
1898
        /* skip mb handling */
1899
        if (s->mb_incr == 0) {
1900
            /* read again increment */
1901
            s->mb_incr = 1;
1902
            for(;;) {
1903
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1904
                if (code < 0)
1905
                    goto eos; /* error = end of slice */
1906
                if (code >= 33) {
1907
                    if (code == 33) {
1908
                        s->mb_incr += 33;
1909
                    }
1910
                    /* otherwise, stuffing, nothing to do */
1911
                } else {
1912
                    s->mb_incr += code;
1913
                    break;
1914
                }
1915
            }
1916
        }
1917
        if(s->mb_y<<field_pic >= s->mb_height){
1918
            fprintf(stderr, "slice too long\n");
1919
            return DECODE_SLICE_ERROR;
1920
        }
1921
    }
1922
eos: //end of slice
1923
    
1924
    emms_c();
1925
//intf("%d %d %d %d\n", s->mb_y, s->mb_height, s->pict_type, s->picture_number);
1926
    /* end of slice reached */
1927
    if (s->mb_y<<field_pic == s->mb_height && !s->first_field) {
1928
        /* end of image */
1929

    
1930
        if(s->mpeg2)
1931
            s->qscale >>=1;
1932

    
1933
        MPV_frame_end(s);
1934

    
1935
        if (s->pict_type == B_TYPE || s->low_delay) {
1936
            *pict= *(AVFrame*)&s->current_picture;
1937
        } else {
1938
            s->picture_number++;
1939
            /* latency of 1 frame for I and P frames */
1940
            /* XXX: use another variable than picture_number */
1941
            if (s->last_picture.data[0] == NULL) {
1942
                return DECODE_SLICE_OK;
1943
            } else {
1944
                *pict= *(AVFrame*)&s->last_picture;
1945
            }
1946
        }
1947
        return DECODE_SLICE_EOP;
1948
    } else {
1949
        return DECODE_SLICE_OK;
1950
    }
1951
}
1952

    
1953
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
1954
                                 uint8_t *buf, int buf_size)
1955
{
1956
    Mpeg1Context *s1 = avctx->priv_data;
1957
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1958
    int width, height, i, v, j;
1959
    float aspect;
1960

    
1961
    init_get_bits(&s->gb, buf, buf_size*8);
1962

    
1963
    width = get_bits(&s->gb, 12);
1964
    height = get_bits(&s->gb, 12);
1965
    s->aspect_ratio_info= get_bits(&s->gb, 4);
1966
    if(!s->mpeg2){
1967
        aspect= mpeg1_aspect[s->aspect_ratio_info];
1968
        if(aspect!=0.0) avctx->aspect_ratio= width/(aspect*height);
1969
    }
1970

    
1971
    s->frame_rate_index = get_bits(&s->gb, 4);
1972
    if (s->frame_rate_index == 0)
1973
        return -1;
1974
    s->bit_rate = get_bits(&s->gb, 18) * 400;
1975
    if (get_bits1(&s->gb) == 0) /* marker */
1976
        return -1;
1977
    if (width <= 0 || height <= 0 ||
1978
        (width % 2) != 0 || (height % 2) != 0)
1979
        return -1;
1980
    if (width != s->width ||
1981
        height != s->height) {
1982
        /* start new mpeg1 context decoding */
1983
        s->out_format = FMT_MPEG1;
1984
        if (s1->mpeg_enc_ctx_allocated) {
1985
            MPV_common_end(s);
1986
        }
1987
        s->width = width;
1988
        s->height = height;
1989
        avctx->has_b_frames= 1;
1990
        s->avctx = avctx;
1991
        avctx->width = width;
1992
        avctx->height = height;
1993
        if (s->frame_rate_index >= 9) {
1994
            /* at least give a valid frame rate (some old mpeg1 have this) */
1995
            avctx->frame_rate = 25 * FRAME_RATE_BASE;
1996
        } else {
1997
            avctx->frame_rate = frame_rate_tab[s->frame_rate_index];
1998
        }
1999
        s->frame_rate = avctx->frame_rate;
2000
        avctx->bit_rate = s->bit_rate;
2001
        
2002
        if (MPV_common_init(s) < 0)
2003
            return -1;
2004
        s1->mpeg_enc_ctx_allocated = 1;
2005
    }
2006

    
2007
    skip_bits(&s->gb, 10); /* vbv_buffer_size */
2008
    skip_bits(&s->gb, 1);
2009

    
2010
    /* get matrix */
2011
    if (get_bits1(&s->gb)) {
2012
        for(i=0;i<64;i++) {
2013
            v = get_bits(&s->gb, 8);
2014
            j = s->intra_scantable.permutated[i];
2015
            s->intra_matrix[j] = v;
2016
            s->chroma_intra_matrix[j] = v;
2017
        }
2018
#ifdef DEBUG
2019
        dprintf("intra matrix present\n");
2020
        for(i=0;i<64;i++)
2021
            dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
2022
        printf("\n");
2023
#endif
2024
    } else {
2025
        for(i=0;i<64;i++) {
2026
            int j= s->dsp.idct_permutation[i];
2027
            v = ff_mpeg1_default_intra_matrix[i];
2028
            s->intra_matrix[j] = v;
2029
            s->chroma_intra_matrix[j] = v;
2030
        }
2031
    }
2032
    if (get_bits1(&s->gb)) {
2033
        for(i=0;i<64;i++) {
2034
            v = get_bits(&s->gb, 8);
2035
            j = s->intra_scantable.permutated[i];
2036
            s->inter_matrix[j] = v;
2037
            s->chroma_inter_matrix[j] = v;
2038
        }
2039
#ifdef DEBUG
2040
        dprintf("non intra matrix present\n");
2041
        for(i=0;i<64;i++)
2042
            dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
2043
        printf("\n");
2044
#endif
2045
    } else {
2046
        for(i=0;i<64;i++) {
2047
            int j= s->dsp.idct_permutation[i];
2048
            v = ff_mpeg1_default_non_intra_matrix[i];
2049
            s->inter_matrix[j] = v;
2050
            s->chroma_inter_matrix[j] = v;
2051
        }
2052
    }
2053

    
2054
    /* we set mpeg2 parameters so that it emulates mpeg1 */
2055
    s->progressive_sequence = 1;
2056
    s->progressive_frame = 1;
2057
    s->picture_structure = PICT_FRAME;
2058
    s->frame_pred_frame_dct = 1;
2059
    s->mpeg2 = 0;
2060
    avctx->sub_id = 1; /* indicates mpeg1 */
2061
    return 0;
2062
}
2063

    
2064
static void mpeg_decode_user_data(AVCodecContext *avctx, 
2065
                                  const uint8_t *buf, int buf_size)
2066
{
2067
    const uint8_t *p;
2068
    int len, flags;
2069
    p = buf;
2070
    len = buf_size;
2071

    
2072
    /* we parse the DTG active format information */
2073
    if (len >= 5 &&
2074
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2075
        flags = p[4];
2076
        p += 5;
2077
        len -= 5;
2078
        if (flags & 0x80) {
2079
            /* skip event id */
2080
            if (len < 2)
2081
                return;
2082
            p += 2;
2083
            len -= 2;
2084
        }
2085
        if (flags & 0x40) {
2086
            if (len < 1)
2087
                return;
2088
            avctx->dtg_active_format = p[0] & 0x0f;
2089
        }
2090
    }
2091
}
2092

    
2093
/* handle buffering and image synchronisation */
2094
static int mpeg_decode_frame(AVCodecContext *avctx, 
2095
                             void *data, int *data_size,
2096
                             uint8_t *buf, int buf_size)
2097
{
2098
    Mpeg1Context *s = avctx->priv_data;
2099
    uint8_t *buf_end, *buf_ptr, *buf_start;
2100
    int len, start_code_found, ret, code, start_code, input_size;
2101
    AVFrame *picture = data;
2102
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2103
            
2104
    dprintf("fill_buffer\n");
2105

    
2106
    *data_size = 0;
2107

    
2108
    /* special case for last picture */
2109
    if (buf_size == 0) {
2110
        if (s2->picture_number > 0) {
2111
            *picture= *(AVFrame*)&s2->next_picture;
2112

    
2113
            *data_size = sizeof(AVFrame);
2114
        }
2115
        return 0;
2116
    }
2117

    
2118
    buf_ptr = buf;
2119
    buf_end = buf + buf_size;
2120

    
2121
#if 0    
2122
    if (s->repeat_field % 2 == 1) { 
2123
        s->repeat_field++;
2124
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2125
        //        s2->picture_number, s->repeat_field);
2126
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2127
            *data_size = sizeof(AVPicture);
2128
            goto the_end;
2129
        }
2130
    }
2131
#endif
2132
    while (buf_ptr < buf_end) {
2133
        buf_start = buf_ptr;
2134
        /* find start next code */
2135
        code = find_start_code(&buf_ptr, buf_end, &s->header_state);
2136
        if (code >= 0) {
2137
            start_code_found = 1;
2138
        } else {
2139
            start_code_found = 0;
2140
        }
2141
        /* copy to buffer */
2142
        len = buf_ptr - buf_start;
2143
        if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
2144
            /* data too big : flush */
2145
            s->buf_ptr = s->buffer;
2146
            if (start_code_found)
2147
                s->start_code = code;
2148
        } else {
2149
            memcpy(s->buf_ptr, buf_start, len);
2150
            s->buf_ptr += len;
2151
            if(   (!(s2->flags&CODEC_FLAG_TRUNCATED)) && (!start_code_found) 
2152
               && s->buf_ptr+4<s->buffer+s->buffer_size){
2153
                start_code_found= 1;
2154
                code= 0x1FF;
2155
                s->header_state=0xFF;
2156
                s->buf_ptr[0]=0;
2157
                s->buf_ptr[1]=0;
2158
                s->buf_ptr[2]=1;
2159
                s->buf_ptr[3]=0xFF;
2160
                s->buf_ptr+=4;
2161
            }
2162
            if (start_code_found) {
2163
                /* prepare data for next start code */
2164
                input_size = s->buf_ptr - s->buffer;
2165
                start_code = s->start_code;
2166
                s->buf_ptr = s->buffer;
2167
                s->start_code = code;
2168
                switch(start_code) {
2169
                case SEQ_START_CODE:
2170
                    mpeg1_decode_sequence(avctx, s->buffer, 
2171
                                          input_size);
2172
                    break;
2173
                            
2174
                case PICTURE_START_CODE:
2175
                    /* we have a complete image : we try to decompress it */
2176
                    mpeg1_decode_picture(avctx, 
2177
                                         s->buffer, input_size);
2178
                    break;
2179
                case EXT_START_CODE:
2180
                    mpeg_decode_extension(avctx,
2181
                                          s->buffer, input_size);
2182
                    break;
2183
                case USER_START_CODE:
2184
                    mpeg_decode_user_data(avctx, 
2185
                                          s->buffer, input_size);
2186
                    break;
2187
                default:
2188
                    if (start_code >= SLICE_MIN_START_CODE &&
2189
                        start_code <= SLICE_MAX_START_CODE) {
2190
                        
2191
                        /* skip b frames if we dont have reference frames */
2192
                        if(s2->last_picture.data[0]==NULL && s2->pict_type==B_TYPE) break;
2193
                        /* skip b frames if we are in a hurry */
2194
                        if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
2195
                        /* skip everything if we are in a hurry>=5 */
2196
                        if(avctx->hurry_up>=5) break;
2197

    
2198
                        ret = mpeg_decode_slice(avctx, picture,
2199
                                                start_code, s->buffer, input_size);
2200

    
2201
                        if (ret == DECODE_SLICE_EOP) {
2202
                            *data_size = sizeof(AVPicture);
2203
                            goto the_end;
2204
                        }else if(ret<0){
2205
                            fprintf(stderr,"Error while decoding slice\n");
2206
                            if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
2207
                        }
2208
                    }
2209
                    break;
2210
                }
2211
            }
2212
        }
2213
    }
2214
 the_end:
2215
    return buf_ptr - buf;
2216
}
2217

    
2218
static int mpeg_decode_end(AVCodecContext *avctx)
2219
{
2220
    Mpeg1Context *s = avctx->priv_data;
2221

    
2222
    if (s->mpeg_enc_ctx_allocated)
2223
        MPV_common_end(&s->mpeg_enc_ctx);
2224
    return 0;
2225
}
2226

    
2227
AVCodec mpeg_decoder = {
2228
    "mpegvideo",
2229
    CODEC_TYPE_VIDEO,
2230
    CODEC_ID_MPEG1VIDEO,
2231
    sizeof(Mpeg1Context),
2232
    mpeg_decode_init,
2233
    NULL,
2234
    mpeg_decode_end,
2235
    mpeg_decode_frame,
2236
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2237
};