Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ e0560448

History | View | Annotate | Download (79.1 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

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

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

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

    
70
#ifdef CONFIG_ENCODERS
71
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
72
static uint8_t fcode_tab[MAX_MV*2+1];
73

    
74
static uint32_t uni_mpeg1_ac_vlc_bits[64*64*2];
75
static uint8_t  uni_mpeg1_ac_vlc_len [64*64*2];
76

    
77
/* simple include everything table for dc, first byte is bits number next 3 are code*/
78
static uint32_t mpeg1_lum_dc_uni[512];
79
static uint32_t mpeg1_chr_dc_uni[512];
80

    
81
static uint8_t mpeg1_index_run[2][64];
82
static int8_t mpeg1_max_level[2][64];
83
#endif
84

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

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

    
124
#ifdef CONFIG_ENCODERS
125
static void init_uni_ac_vlc(RLTable *rl, uint32_t *uni_ac_vlc_bits, uint8_t *uni_ac_vlc_len){
126
    int i;
127

    
128
    for(i=0; i<128; i++){
129
        int level= i-64;
130
        int run;
131
        for(run=0; run<64; run++){
132
            int len, bits, code;
133
            
134
            int alevel= ABS(level);
135
            int sign= (level>>31)&1;
136

    
137
            if (alevel > rl->max_level[0][run])
138
                code= 111; /*rl->n*/
139
            else
140
                code= rl->index_run[0][run] + alevel - 1;
141

    
142
            if (code < 111 /* rl->n */) {
143
                    /* store the vlc & sign at once */
144
                len=   mpeg1_vlc[code][1]+1;
145
                bits= (mpeg1_vlc[code][0]<<1) + sign;
146
            } else {
147
                len=  mpeg1_vlc[111/*rl->n*/][1]+6;
148
                bits= mpeg1_vlc[111/*rl->n*/][0]<<6;
149

    
150
                bits|= run;
151
                if (alevel < 128) {
152
                    bits<<=8; len+=8;
153
                    bits|= level & 0xff;
154
                } else {
155
                    bits<<=16; len+=16;
156
                    bits|= level & 0xff;
157
                    if (level < 0) {
158
                        bits|= 0x8001 + level + 255;
159
                    } else {
160
                        bits|= level & 0xffff;
161
                    }
162
                }
163
            }
164

    
165
            uni_ac_vlc_bits[UNI_AC_ENC_INDEX(run, i)]= bits;
166
            uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len;
167
        }
168
    }
169
}
170

    
171
static void put_header(MpegEncContext *s, int header)
172
{
173
    align_put_bits(&s->pb);
174
    put_bits(&s->pb, 16, header>>16);
175
    put_bits(&s->pb, 16, header&0xFFFF);
176
}
177

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

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

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

    
257
        if (s->avctx->frame_rate < (24 * s->avctx->frame_rate_base) && s->picture_number > 0) {
258
            /* insert empty P pictures to slow down to the desired
259
               frame rate. Each fake pictures takes about 20 bytes */
260
            fps = frame_rate_tab[s->frame_rate_index];
261
            n = av_rescale((int64_t)s->picture_number * s->avctx->frame_rate_base, fps, s->avctx->frame_rate) / MPEG1_FRAME_RATE_BASE - 1;
262
            while (s->fake_picture_number < n) {
263
                mpeg1_skip_picture(s, s->fake_picture_number - 
264
                                   s->gop_picture_number); 
265
                s->fake_picture_number++;
266
            }
267

    
268
        }
269
}
270

    
271
static inline void encode_mb_skip_run(MpegEncContext *s, int run){
272
    while (run >= 33) {
273
        put_bits(&s->pb, 11, 0x008);
274
        run -= 33;
275
    }
276
    put_bits(&s->pb, mbAddrIncrTable[run][1], 
277
             mbAddrIncrTable[run][0]);
278
}
279

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

    
310
    /* output a number of empty slice */
311
    encode_mb_skip_run(s, s->mb_width * s->mb_height - 2);
312
    
313
    /* empty macroblock */
314
    put_bits(&s->pb, 3, 1); /* motion only */
315
    
316
    /* zero motion x & y */
317
    put_bits(&s->pb, 1, 1); 
318
    put_bits(&s->pb, 1, 1); 
319
}
320
#endif
321

    
322
static void common_init(MpegEncContext *s)
323
{
324
    s->y_dc_scale_table=
325
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
326
}
327

    
328
void ff_mpeg1_clean_buffers(MpegEncContext *s){
329
    s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
330
    s->last_dc[1] = s->last_dc[0];
331
    s->last_dc[2] = s->last_dc[0];
332
    memset(s->last_mv, 0, sizeof(s->last_mv));
333
}
334

    
335
#ifdef CONFIG_ENCODERS
336

    
337
void ff_mpeg1_encode_slice_header(MpegEncContext *s){
338
    put_header(s, SLICE_MIN_START_CODE + s->mb_y);
339
    put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
340
    put_bits(&s->pb, 1, 0); /* slice extra information */
341
}
342

    
343
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
344
{
345
    mpeg1_encode_sequence_header(s);
346

    
347
    /* mpeg1 picture header */
348
    put_header(s, PICTURE_START_CODE);
349
    /* temporal reference */
350

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

    
371
    put_bits(&s->pb, 1, 0); /* extra bit picture */
372
    
373
    s->mb_y=0;
374
    ff_mpeg1_encode_slice_header(s);
375
}
376

    
377
void mpeg1_encode_mb(MpegEncContext *s,
378
                     DCTELEM block[6][64],
379
                     int motion_x, int motion_y)
380
{
381
    int i, cbp;
382
    const int mb_x = s->mb_x;
383
    const int mb_y = s->mb_y;
384
    const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
385

    
386
    /* compute cbp */
387
    cbp = 0;
388
    for(i=0;i<6;i++) {
389
        if (s->block_last_index[i] >= 0)
390
            cbp |= 1 << (5 - i);
391
    }
392

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

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

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

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

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

    
612
        assert(code > 0 && code <= 16);
613

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

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

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

    
629
    common_init(s);
630

    
631
    if(!done){
632
        int f_code;
633
        int mv;
634
        int i;
635

    
636
        done=1;
637
        init_rl(&rl_mpeg1);
638

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

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

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

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

    
667
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
668

    
669
        for(f_code=1; f_code<=MAX_FCODE; f_code++){
670
            for(mv=-MAX_MV; mv<=MAX_MV; mv++){
671
                int len;
672

    
673
                if(mv==0) len= mbMotionVectorTable[0][1];
674
                else{
675
                    int val, bit_size, range, code;
676

    
677
                    bit_size = s->f_code - 1;
678
                    range = 1 << bit_size;
679

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

    
692
                mv_penalty[f_code][mv+MAX_MV]= len;
693
            }
694
        }
695
        
696

    
697
        for(f_code=MAX_FCODE; f_code>0; f_code--){
698
            for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
699
                fcode_tab[mv+MAX_MV]= f_code;
700
            }
701
        }
702
    }
703
    s->me.mv_penalty= mv_penalty;
704
    s->fcode_tab= fcode_tab;
705
    s->min_qcoeff=-255;
706
    s->max_qcoeff= 255;
707
    s->intra_ac_vlc_length=
708
    s->inter_ac_vlc_length= uni_mpeg1_ac_vlc_len;
709
}
710

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

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

    
734
    last_index = s->block_last_index[n];
735

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

    
759
    /* now quantify & encode AC coefs */
760
    last_non_zero = i - 1;
761

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

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

    
806
/******************************************/
807
/* decoding */
808

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

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

    
821
    if (!done) {
822
        done = 1;
823

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

    
849
        init_2d_vlc_rl(&rl_mpeg1);
850
        init_2d_vlc_rl(&rl_mpeg2);
851
    }
852
}
853

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

    
862
static inline int get_qscale(MpegEncContext *s)
863
{
864
    int qscale = get_bits(&s->gb, 5);
865
    if (s->mpeg2) {
866
        if (s->q_scale_type) {
867
            return non_linear_qscale[qscale];
868
        } else {
869
            return qscale << 1;
870
        }
871
    }
872
    return qscale;
873
}
874

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

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

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

    
890
    if (s->mb_skip_run-- != 0) {
891
        if(s->pict_type == I_TYPE){
892
            fprintf(stderr, "skiped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
893
            return -1;
894
        }
895
    
896
        /* skip mb */
897
        s->mb_intra = 0;
898
        for(i=0;i<6;i++)
899
            s->block_last_index[i] = -1;
900
        s->mv_type = MV_TYPE_16X16;
901
        if (s->pict_type == P_TYPE) {
902
            /* if P type, zero motion vector is implied */
903
            s->mv_dir = MV_DIR_FORWARD;
904
            s->mv[0][0][0] = s->mv[0][0][1] = 0;
905
            s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
906
            s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
907
            s->mb_skiped = 1;
908
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
909
        } else {
910
            /* if B type, reuse previous vectors and directions */
911
            s->mv[0][0][0] = s->last_mv[0][0][0];
912
            s->mv[0][0][1] = s->last_mv[0][0][1];
913
            s->mv[1][0][0] = s->last_mv[1][0][0];
914
            s->mv[1][0][1] = s->last_mv[1][0][1];
915

    
916
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= 
917
                s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1] | MB_TYPE_SKIP;
918
//            assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
919

    
920
            if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0) 
921
                s->mb_skiped = 1;
922
        }
923

    
924
        return 0;
925
    }
926

    
927
    switch(s->pict_type) {
928
    default:
929
    case I_TYPE:
930
        if (get_bits1(&s->gb) == 0) {
931
            if (get_bits1(&s->gb) == 0)
932
                return -1;
933
            mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
934
        } else {
935
            mb_type = MB_TYPE_INTRA;
936
        }
937
        break;
938
    case P_TYPE:
939
        mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
940
        if (mb_type < 0){
941
            fprintf(stderr, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
942
            return -1;
943
        }
944
        mb_type = ptype2mb_type[ mb_type ];
945
        break;
946
    case B_TYPE:
947
        mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
948
        if (mb_type < 0){
949
            fprintf(stderr, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
950
            return -1;
951
        }
952
        mb_type = btype2mb_type[ mb_type ];
953
        break;
954
    }
955
    dprintf("mb_type=%x\n", mb_type);
956
//    motion_type = 0; /* avoid warning */
957
    if (IS_INTRA(mb_type)) {
958
        /* compute dct type */
959
        if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
960
            !s->frame_pred_frame_dct) {
961
            s->interlaced_dct = get_bits1(&s->gb);
962
        }
963

    
964
        if (IS_QUANT(mb_type))
965
            s->qscale = get_qscale(s);
966
        
967
        if (s->concealment_motion_vectors) {
968
            /* just parse them */
969
            if (s->picture_structure != PICT_FRAME) 
970
                skip_bits1(&s->gb); /* field select */
971
            
972
            s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] = 
973
                mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
974
            s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] = 
975
                mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
976

    
977
            skip_bits1(&s->gb); /* marker */
978
        }else
979
            memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
980
        s->mb_intra = 1;
981

    
982
        if (s->mpeg2) {
983
            for(i=0;i<6;i++) {
984
                if (mpeg2_decode_block_intra(s, block[i], i) < 0)
985
                    return -1;
986
            }
987
        } else {
988
            for(i=0;i<6;i++) {
989
                if (mpeg1_decode_block_intra(s, block[i], i) < 0)
990
                    return -1;
991
            }
992
        }
993
    } else {
994
        if (mb_type & MB_TYPE_ZERO_MV){
995
            assert(mb_type & MB_TYPE_PAT);
996

    
997
            /* compute dct type */
998
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
999
                !s->frame_pred_frame_dct) {
1000
                s->interlaced_dct = get_bits1(&s->gb);
1001
            }
1002

    
1003
            if (IS_QUANT(mb_type))
1004
                s->qscale = get_qscale(s);
1005

    
1006
            s->mv_dir = MV_DIR_FORWARD;
1007
            s->mv_type = MV_TYPE_16X16;
1008
            s->last_mv[0][0][0] = 0;
1009
            s->last_mv[0][0][1] = 0;
1010
            s->last_mv[0][1][0] = 0;
1011
            s->last_mv[0][1][1] = 0;
1012
            s->mv[0][0][0] = 0;
1013
            s->mv[0][0][1] = 0;
1014
        }else{
1015
            assert(mb_type & MB_TYPE_L0L1);
1016
//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
1017
            /* get additionnal motion vector type */
1018
            if (s->frame_pred_frame_dct) 
1019
                motion_type = MT_FRAME;
1020
            else{
1021
                motion_type = get_bits(&s->gb, 2);
1022
            }
1023

    
1024
            /* compute dct type */
1025
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1026
                !s->frame_pred_frame_dct && IS_PAT(mb_type)) {
1027
                s->interlaced_dct = get_bits1(&s->gb);
1028
            }
1029

    
1030
            if (IS_QUANT(mb_type))
1031
                s->qscale = get_qscale(s);
1032

    
1033
            /* motion vectors */
1034
            s->mv_dir = 0;
1035
            for(i=0;i<2;i++) {
1036
                if (USES_LIST(mb_type, i)) {
1037
                    s->mv_dir |= (MV_DIR_FORWARD >> i);
1038
                    dprintf("motion_type=%d\n", motion_type);
1039
                    switch(motion_type) {
1040
                    case MT_FRAME: /* or MT_16X8 */
1041
                        if (s->picture_structure == PICT_FRAME) {
1042
                            /* MT_FRAME */
1043
                            mb_type |= MB_TYPE_16x16; 
1044
                            s->mv_type = MV_TYPE_16X16;
1045
                            s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] = 
1046
                                mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
1047
                            s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] = 
1048
                                mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
1049
                            /* full_pel: only for mpeg1 */
1050
                            if (s->full_pel[i]){
1051
                                s->mv[i][0][0] <<= 1;
1052
                                s->mv[i][0][1] <<= 1;
1053
                            }
1054
                        } else {
1055
                            /* MT_16X8 */
1056
                            mb_type |= MB_TYPE_16x8; 
1057
                            s->mv_type = MV_TYPE_16X8;
1058
                            for(j=0;j<2;j++) {
1059
                                s->field_select[i][j] = get_bits1(&s->gb);
1060
                                for(k=0;k<2;k++) {
1061
                                    val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1062
                                                             s->last_mv[i][j][k]);
1063
                                    s->last_mv[i][j][k] = val;
1064
                                    s->mv[i][j][k] = val;
1065
                                }
1066
                            }
1067
                        }
1068
                        break;
1069
                    case MT_FIELD:
1070
                        s->mv_type = MV_TYPE_FIELD;
1071
                        if (s->picture_structure == PICT_FRAME) {
1072
                            mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; 
1073
                            for(j=0;j<2;j++) {
1074
                                s->field_select[i][j] = get_bits1(&s->gb);
1075
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1076
                                                         s->last_mv[i][j][0]);
1077
                                s->last_mv[i][j][0] = val;
1078
                                s->mv[i][j][0] = val;
1079
                                dprintf("fmx=%d\n", val);
1080
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1081
                                                         s->last_mv[i][j][1] >> 1);
1082
                                s->last_mv[i][j][1] = val << 1;
1083
                                s->mv[i][j][1] = val;
1084
                                dprintf("fmy=%d\n", val);
1085
                            }
1086
                        } else {
1087
                            mb_type |= MB_TYPE_16x16; 
1088
                            s->field_select[i][0] = get_bits1(&s->gb);
1089
                            for(k=0;k<2;k++) {
1090
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1091
                                                         s->last_mv[i][0][k]);
1092
                                s->last_mv[i][0][k] = val;
1093
                                s->last_mv[i][1][k] = val;
1094
                                s->mv[i][0][k] = val;
1095
                            }
1096
                        }
1097
                        break;
1098
                    case MT_DMV:
1099
                        {
1100
                            int dmx, dmy, mx, my, m;
1101

    
1102
                            mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 
1103
                                                    s->last_mv[i][0][0]);
1104
                            s->last_mv[i][0][0] = mx;
1105
                            s->last_mv[i][1][0] = mx;
1106
                            dmx = get_dmv(s);
1107
                            my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 
1108
                                                    s->last_mv[i][0][1] >> 1);
1109
                            dmy = get_dmv(s);
1110
                            s->mv_type = MV_TYPE_DMV;
1111

    
1112

    
1113
                            s->last_mv[i][0][1] = my<<1;
1114
                            s->last_mv[i][1][1] = my<<1;
1115

    
1116
                            s->mv[i][0][0] = mx;
1117
                            s->mv[i][0][1] = my;
1118
                            s->mv[i][1][0] = mx;//not used
1119
                            s->mv[i][1][1] = my;//not used
1120

    
1121
                            if (s->picture_structure == PICT_FRAME) {
1122
                                mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED; 
1123

    
1124
                                //m = 1 + 2 * s->top_field_first;
1125
                                m = s->top_field_first ? 1 : 3;
1126

    
1127
                                /* top -> top pred */
1128
                                s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1129
                                s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1130
                                m = 4 - m;
1131
                                s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1132
                                s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1133
                            } else {
1134
                                mb_type |= MB_TYPE_16x16;
1135

    
1136
                                s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
1137
                                s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
1138
                                if(s->picture_structure == PICT_TOP_FIELD)
1139
                                    s->mv[i][2][1]--;
1140
                                else 
1141
                                    s->mv[i][2][1]++;
1142
                            }
1143
                        }
1144
                        break;
1145
                    }
1146
                }
1147
            }
1148
        }
1149
        
1150
        s->mb_intra = 0;
1151

    
1152
        if (IS_PAT(mb_type)) {
1153
            cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1154
            if (cbp < 0){
1155
                fprintf(stderr, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
1156
                return -1;
1157
            }
1158
            cbp++;
1159

    
1160
            if (s->mpeg2) {
1161
                for(i=0;i<6;i++) {
1162
                    if (cbp & 32) {
1163
                        if (mpeg2_decode_block_non_intra(s, block[i], i) < 0)
1164
                            return -1;
1165
                    } else {
1166
                        s->block_last_index[i] = -1;
1167
                    }
1168
                    cbp+=cbp;
1169
                }
1170
            } else {
1171
                for(i=0;i<6;i++) {
1172
                    if (cbp & 32) {
1173
                        if (mpeg1_decode_block_inter(s, block[i], i) < 0)
1174
                            return -1;
1175
                    } else {
1176
                        s->block_last_index[i] = -1;
1177
                    }
1178
                    cbp+=cbp;
1179
                }
1180
            }
1181
        }else{
1182
            for(i=0;i<6;i++)
1183
                s->block_last_index[i] = -1;
1184
        }
1185
    }
1186

    
1187
    s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
1188

    
1189
    return 0;
1190
}
1191

    
1192
/* as h263, but only 17 codes */
1193
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
1194
{
1195
    int code, sign, val, l, shift;
1196

    
1197
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
1198
    if (code == 0) {
1199
        return pred;
1200
    }
1201
    if (code < 0) {
1202
        return 0xffff;
1203
    }
1204

    
1205
    sign = get_bits1(&s->gb);
1206
    shift = fcode - 1;
1207
    val = code;
1208
    if (shift) {
1209
        val = (val - 1) << shift;
1210
        val |= get_bits(&s->gb, shift);
1211
        val++;
1212
    }
1213
    if (sign)
1214
        val = -val;
1215
    val += pred;
1216
    
1217
    /* modulo decoding */
1218
    l = 1 << (shift+4);
1219
    val = ((val + l)&(l*2-1)) - l;
1220
    return val;
1221
}
1222

    
1223
static inline int decode_dc(MpegEncContext *s, int component)
1224
{
1225
    int code, diff;
1226

    
1227
    if (component == 0) {
1228
        code = get_vlc2(&s->gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1229
    } else {
1230
        code = get_vlc2(&s->gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1231
    }
1232
    if (code < 0){
1233
        fprintf(stderr, "invalid dc code at %d %d\n", s->mb_x, s->mb_y);
1234
        return 0xffff;
1235
    }
1236
    if (code == 0) {
1237
        diff = 0;
1238
    } else {
1239
        diff = get_xbits(&s->gb, code);
1240
    }
1241
    return diff;
1242
}
1243

    
1244
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
1245
                               DCTELEM *block, 
1246
                               int n)
1247
{
1248
    int level, dc, diff, i, j, run;
1249
    int component;
1250
    RLTable *rl = &rl_mpeg1;
1251
    uint8_t * const scantable= s->intra_scantable.permutated;
1252
    const uint16_t *quant_matrix= s->intra_matrix;
1253
    const int qscale= s->qscale;
1254

    
1255
    /* DC coef */
1256
    component = (n <= 3 ? 0 : n - 4 + 1);
1257
    diff = decode_dc(s, component);
1258
    if (diff >= 0xffff)
1259
        return -1;
1260
    dc = s->last_dc[component];
1261
    dc += diff;
1262
    s->last_dc[component] = dc;
1263
    block[0] = dc<<3;
1264
    dprintf("dc=%d diff=%d\n", dc, diff);
1265
    i = 0;
1266
    {
1267
        OPEN_READER(re, &s->gb);    
1268
        /* now quantify & encode AC coefs */
1269
        for(;;) {
1270
            UPDATE_CACHE(re, &s->gb);
1271
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1272
            
1273
            if(level == 127){
1274
                break;
1275
            } else if(level != 0) {
1276
                i += run;
1277
                j = scantable[i];
1278
                level= (level*qscale*quant_matrix[j])>>3;
1279
                level= (level-1)|1;
1280
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1281
                LAST_SKIP_BITS(re, &s->gb, 1);
1282
            } else {
1283
                /* escape */
1284
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1285
                UPDATE_CACHE(re, &s->gb);
1286
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1287
                if (level == -128) {
1288
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1289
                } else if (level == 0) {
1290
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1291
                }
1292
                i += run;
1293
                j = scantable[i];
1294
                if(level<0){
1295
                    level= -level;
1296
                    level= (level*qscale*quant_matrix[j])>>3;
1297
                    level= (level-1)|1;
1298
                    level= -level;
1299
                }else{
1300
                    level= (level*qscale*quant_matrix[j])>>3;
1301
                    level= (level-1)|1;
1302
                }
1303
            }
1304
            if (i > 63){
1305
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1306
                return -1;
1307
            }
1308

    
1309
            block[j] = level;
1310
        }
1311
        CLOSE_READER(re, &s->gb);
1312
    }
1313
    s->block_last_index[n] = i;
1314
   return 0;
1315
}
1316

    
1317
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
1318
                               DCTELEM *block, 
1319
                               int n)
1320
{
1321
    int level, i, j, run;
1322
    RLTable *rl = &rl_mpeg1;
1323
    uint8_t * const scantable= s->intra_scantable.permutated;
1324
    const uint16_t *quant_matrix= s->inter_matrix;
1325
    const int qscale= s->qscale;
1326

    
1327
    {
1328
        int v;
1329
        OPEN_READER(re, &s->gb);
1330
        i = -1;
1331
        /* special case for the first coef. no need to add a second vlc table */
1332
        UPDATE_CACHE(re, &s->gb);
1333
        v= SHOW_UBITS(re, &s->gb, 2);
1334
        if (v & 2) {
1335
            LAST_SKIP_BITS(re, &s->gb, 2);
1336
            level= (3*qscale*quant_matrix[0])>>4;
1337
            level= (level-1)|1;
1338
            if(v&1)
1339
                level= -level;
1340
            block[0] = level;
1341
            i++;
1342
        }
1343

    
1344
        /* now quantify & encode AC coefs */
1345
        for(;;) {
1346
            UPDATE_CACHE(re, &s->gb);
1347
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1348
            
1349
            if(level == 127){
1350
                break;
1351
            } else if(level != 0) {
1352
                i += run;
1353
                j = scantable[i];
1354
                level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1355
                level= (level-1)|1;
1356
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1357
                LAST_SKIP_BITS(re, &s->gb, 1);
1358
            } else {
1359
                /* escape */
1360
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1361
                UPDATE_CACHE(re, &s->gb);
1362
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1363
                if (level == -128) {
1364
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1365
                } else if (level == 0) {
1366
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1367
                }
1368
                i += run;
1369
                j = scantable[i];
1370
                if(level<0){
1371
                    level= -level;
1372
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1373
                    level= (level-1)|1;
1374
                    level= -level;
1375
                }else{
1376
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1377
                    level= (level-1)|1;
1378
                }
1379
            }
1380
            if (i > 63){
1381
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1382
                return -1;
1383
            }
1384

    
1385
            block[j] = level;
1386
        }
1387
        CLOSE_READER(re, &s->gb);
1388
    }
1389
    s->block_last_index[n] = i;
1390
    return 0;
1391
}
1392

    
1393
/* Also does unquantization here, since I will never support mpeg2
1394
   encoding */
1395
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1396
                               DCTELEM *block, 
1397
                               int n)
1398
{
1399
    int level, i, j, run;
1400
    RLTable *rl = &rl_mpeg1;
1401
    uint8_t * const scantable= s->intra_scantable.permutated;
1402
    const uint16_t *quant_matrix;
1403
    const int qscale= s->qscale;
1404
    int mismatch;
1405

    
1406
    mismatch = 1;
1407

    
1408
    {
1409
        int v;
1410
        OPEN_READER(re, &s->gb);
1411
        i = -1;
1412
        if (n < 4)
1413
            quant_matrix = s->inter_matrix;
1414
        else
1415
            quant_matrix = s->chroma_inter_matrix;
1416

    
1417
        /* special case for the first coef. no need to add a second vlc table */
1418
        UPDATE_CACHE(re, &s->gb);
1419
        v= SHOW_UBITS(re, &s->gb, 2);
1420
        if (v & 2) {
1421
            LAST_SKIP_BITS(re, &s->gb, 2);
1422
            level= (3*qscale*quant_matrix[0])>>5;
1423
            if(v&1)
1424
                level= -level;
1425
            block[0] = level;
1426
            mismatch ^= level;
1427
            i++;
1428
        }
1429

    
1430
        /* now quantify & encode AC coefs */
1431
        for(;;) {
1432
            UPDATE_CACHE(re, &s->gb);
1433
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1434
            
1435
            if(level == 127){
1436
                break;
1437
            } else if(level != 0) {
1438
                i += run;
1439
                j = scantable[i];
1440
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1441
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1442
                LAST_SKIP_BITS(re, &s->gb, 1);
1443
            } else {
1444
                /* escape */
1445
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1446
                UPDATE_CACHE(re, &s->gb);
1447
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1448

    
1449
                i += run;
1450
                j = scantable[i];
1451
                if(level<0){
1452
                    level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1453
                    level= -level;
1454
                }else{
1455
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1456
                }
1457
            }
1458
            if (i > 63){
1459
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1460
                return -1;
1461
            }
1462
            
1463
            mismatch ^= level;
1464
            block[j] = level;
1465
        }
1466
        CLOSE_READER(re, &s->gb);
1467
    }
1468
    block[63] ^= (mismatch & 1);
1469
    
1470
    s->block_last_index[n] = i;
1471
    return 0;
1472
}
1473

    
1474
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
1475
                               DCTELEM *block, 
1476
                               int n)
1477
{
1478
    int level, dc, diff, i, j, run;
1479
    int component;
1480
    RLTable *rl;
1481
    uint8_t * const scantable= s->intra_scantable.permutated;
1482
    const uint16_t *quant_matrix;
1483
    const int qscale= s->qscale;
1484
    int mismatch;
1485

    
1486
    /* DC coef */
1487
    if (n < 4){
1488
        quant_matrix = s->intra_matrix;
1489
        component = 0; 
1490
    }else{
1491
        quant_matrix = s->chroma_intra_matrix;
1492
        component = n - 3;
1493
    }
1494
    diff = decode_dc(s, component);
1495
    if (diff >= 0xffff)
1496
        return -1;
1497
    dc = s->last_dc[component];
1498
    dc += diff;
1499
    s->last_dc[component] = dc;
1500
    block[0] = dc << (3 - s->intra_dc_precision);
1501
    dprintf("dc=%d\n", block[0]);
1502
    mismatch = block[0] ^ 1;
1503
    i = 0;
1504
    if (s->intra_vlc_format)
1505
        rl = &rl_mpeg2;
1506
    else
1507
        rl = &rl_mpeg1;
1508

    
1509
    {
1510
        OPEN_READER(re, &s->gb);    
1511
        /* now quantify & encode AC coefs */
1512
        for(;;) {
1513
            UPDATE_CACHE(re, &s->gb);
1514
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1515
            
1516
            if(level == 127){
1517
                break;
1518
            } else if(level != 0) {
1519
                i += run;
1520
                j = scantable[i];
1521
                level= (level*qscale*quant_matrix[j])>>4;
1522
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1523
                LAST_SKIP_BITS(re, &s->gb, 1);
1524
            } else {
1525
                /* escape */
1526
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1527
                UPDATE_CACHE(re, &s->gb);
1528
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1529
                i += run;
1530
                j = scantable[i];
1531
                if(level<0){
1532
                    level= (-level*qscale*quant_matrix[j])>>4;
1533
                    level= -level;
1534
                }else{
1535
                    level= (level*qscale*quant_matrix[j])>>4;
1536
                }
1537
            }
1538
            if (i > 63){
1539
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1540
                return -1;
1541
            }
1542
            
1543
            mismatch^= level;
1544
            block[j] = level;
1545
        }
1546
        CLOSE_READER(re, &s->gb);
1547
    }
1548
    block[63]^= mismatch&1;
1549
    
1550
    s->block_last_index[n] = i;
1551
    return 0;
1552
}
1553

    
1554
typedef struct Mpeg1Context {
1555
    MpegEncContext mpeg_enc_ctx;
1556
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1557
    int repeat_field; /* true if we must repeat the field */
1558
} Mpeg1Context;
1559

    
1560
static int mpeg_decode_init(AVCodecContext *avctx)
1561
{
1562
    Mpeg1Context *s = avctx->priv_data;
1563
    
1564
    s->mpeg_enc_ctx.flags= avctx->flags;
1565
    common_init(&s->mpeg_enc_ctx);
1566
    init_vlcs(&s->mpeg_enc_ctx);
1567

    
1568
    s->mpeg_enc_ctx_allocated = 0;
1569
    s->mpeg_enc_ctx.picture_number = 0;
1570
    s->repeat_field = 0;
1571
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1572
    return 0;
1573
}
1574

    
1575
/* return the 8 bit start code value and update the search
1576
   state. Return -1 if no start code found */
1577
static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end)
1578
{
1579
    uint8_t *buf_ptr;
1580
    unsigned int state=0xFFFFFFFF, v;
1581
    int val;
1582

    
1583
    buf_ptr = *pbuf_ptr;
1584
    while (buf_ptr < buf_end) {
1585
        v = *buf_ptr++;
1586
        if (state == 0x000001) {
1587
            state = ((state << 8) | v) & 0xffffff;
1588
            val = state;
1589
            goto found;
1590
        }
1591
        state = ((state << 8) | v) & 0xffffff;
1592
    }
1593
    val = -1;
1594
 found:
1595
    *pbuf_ptr = buf_ptr;
1596
    return val;
1597
}
1598

    
1599
static int mpeg1_decode_picture(AVCodecContext *avctx, 
1600
                                uint8_t *buf, int buf_size)
1601
{
1602
    Mpeg1Context *s1 = avctx->priv_data;
1603
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1604
    int ref, f_code;
1605

    
1606
    init_get_bits(&s->gb, buf, buf_size*8);
1607

    
1608
    ref = get_bits(&s->gb, 10); /* temporal ref */
1609
    s->pict_type = get_bits(&s->gb, 3);
1610
    dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number);
1611

    
1612
    skip_bits(&s->gb, 16);
1613
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
1614
        s->full_pel[0] = get_bits1(&s->gb);
1615
        f_code = get_bits(&s->gb, 3);
1616
        if (f_code == 0)
1617
            return -1;
1618
        s->mpeg_f_code[0][0] = f_code;
1619
        s->mpeg_f_code[0][1] = f_code;
1620
    }
1621
    if (s->pict_type == B_TYPE) {
1622
        s->full_pel[1] = get_bits1(&s->gb);
1623
        f_code = get_bits(&s->gb, 3);
1624
        if (f_code == 0)
1625
            return -1;
1626
        s->mpeg_f_code[1][0] = f_code;
1627
        s->mpeg_f_code[1][1] = f_code;
1628
    }
1629
    s->current_picture.pict_type= s->pict_type;
1630
    s->current_picture.key_frame= s->pict_type == I_TYPE;
1631
    
1632
    s->y_dc_scale = 8;
1633
    s->c_dc_scale = 8;
1634
    s->first_slice = 1;
1635
    return 0;
1636
}
1637

    
1638
static void mpeg_decode_sequence_extension(MpegEncContext *s)
1639
{
1640
    int horiz_size_ext, vert_size_ext;
1641
    int bit_rate_ext, vbv_buf_ext;
1642
    int frame_rate_ext_n, frame_rate_ext_d;
1643
    float aspect;
1644

    
1645
    skip_bits(&s->gb, 8); /* profil and level */
1646
    s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1647
    skip_bits(&s->gb, 2); /* chroma_format */
1648
    horiz_size_ext = get_bits(&s->gb, 2);
1649
    vert_size_ext = get_bits(&s->gb, 2);
1650
    s->width |= (horiz_size_ext << 12);
1651
    s->height |= (vert_size_ext << 12);
1652
    bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1653
    s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
1654
    skip_bits1(&s->gb); /* marker */
1655
    vbv_buf_ext = get_bits(&s->gb, 8);
1656

    
1657
    s->low_delay = get_bits1(&s->gb);
1658
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
1659

    
1660
    frame_rate_ext_n = get_bits(&s->gb, 2);
1661
    frame_rate_ext_d = get_bits(&s->gb, 5);
1662
    av_reduce(
1663
        &s->avctx->frame_rate, 
1664
        &s->avctx->frame_rate_base, 
1665
        frame_rate_tab[s->frame_rate_index] * (frame_rate_ext_n+1),
1666
        MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d+1),
1667
        1<<30);
1668

    
1669
    dprintf("sequence extension\n");
1670
    s->mpeg2 = 1;
1671
    s->avctx->sub_id = 2; /* indicates mpeg2 found */
1672

    
1673
    aspect= mpeg2_aspect[s->aspect_ratio_info];
1674
    if(aspect>0.0)      s->avctx->aspect_ratio= s->width/(aspect*s->height);
1675
    else if(aspect<0.0) s->avctx->aspect_ratio= -1.0/aspect;
1676
}
1677

    
1678
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1679
{
1680
    int i, v, j;
1681

    
1682
    dprintf("matrix extension\n");
1683

    
1684
    if (get_bits1(&s->gb)) {
1685
        for(i=0;i<64;i++) {
1686
            v = get_bits(&s->gb, 8);
1687
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1688
            s->intra_matrix[j] = v;
1689
            s->chroma_intra_matrix[j] = v;
1690
        }
1691
    }
1692
    if (get_bits1(&s->gb)) {
1693
        for(i=0;i<64;i++) {
1694
            v = get_bits(&s->gb, 8);
1695
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1696
            s->inter_matrix[j] = v;
1697
            s->chroma_inter_matrix[j] = v;
1698
        }
1699
    }
1700
    if (get_bits1(&s->gb)) {
1701
        for(i=0;i<64;i++) {
1702
            v = get_bits(&s->gb, 8);
1703
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1704
            s->chroma_intra_matrix[j] = v;
1705
        }
1706
    }
1707
    if (get_bits1(&s->gb)) {
1708
        for(i=0;i<64;i++) {
1709
            v = get_bits(&s->gb, 8);
1710
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1711
            s->chroma_inter_matrix[j] = v;
1712
        }
1713
    }
1714
}
1715

    
1716
static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
1717
{
1718
    s->full_pel[0] = s->full_pel[1] = 0;
1719
    s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1720
    s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1721
    s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1722
    s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1723
    s->intra_dc_precision = get_bits(&s->gb, 2);
1724
    s->picture_structure = get_bits(&s->gb, 2);
1725
    s->top_field_first = get_bits1(&s->gb);
1726
    s->frame_pred_frame_dct = get_bits1(&s->gb);
1727
    s->concealment_motion_vectors = get_bits1(&s->gb);
1728
    s->q_scale_type = get_bits1(&s->gb);
1729
    s->intra_vlc_format = get_bits1(&s->gb);
1730
    s->alternate_scan = get_bits1(&s->gb);
1731
    s->repeat_first_field = get_bits1(&s->gb);
1732
    s->chroma_420_type = get_bits1(&s->gb);
1733
    s->progressive_frame = get_bits1(&s->gb);
1734
    
1735
    if(s->picture_structure == PICT_FRAME)
1736
        s->first_field=0;
1737
    else{
1738
        s->first_field ^= 1;
1739
        memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
1740
    }
1741
    
1742
    if(s->alternate_scan){
1743
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
1744
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
1745
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
1746
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
1747
    }else{
1748
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
1749
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
1750
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
1751
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
1752
    }
1753
    
1754
    /* composite display not parsed */
1755
    dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
1756
    dprintf("picture_structure=%d\n", s->picture_structure);
1757
    dprintf("top field first=%d\n", s->top_field_first);
1758
    dprintf("repeat first field=%d\n", s->repeat_first_field);
1759
    dprintf("conceal=%d\n", s->concealment_motion_vectors);
1760
    dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
1761
    dprintf("alternate_scan=%d\n", s->alternate_scan);
1762
    dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1763
    dprintf("progressive_frame=%d\n", s->progressive_frame);
1764
}
1765

    
1766
static void mpeg_decode_extension(AVCodecContext *avctx, 
1767
                                  uint8_t *buf, int buf_size)
1768
{
1769
    Mpeg1Context *s1 = avctx->priv_data;
1770
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1771
    int ext_type;
1772

    
1773
    init_get_bits(&s->gb, buf, buf_size*8);
1774
    
1775
    ext_type = get_bits(&s->gb, 4);
1776
    switch(ext_type) {
1777
    case 0x1:
1778
        /* sequence ext */
1779
        mpeg_decode_sequence_extension(s);
1780
        break;
1781
    case 0x3:
1782
        /* quant matrix extension */
1783
        mpeg_decode_quant_matrix_extension(s);
1784
        break;
1785
    case 0x8:
1786
        /* picture extension */
1787
        mpeg_decode_picture_coding_extension(s);
1788
        break;
1789
    }
1790
}
1791

    
1792
#define DECODE_SLICE_FATAL_ERROR -2
1793
#define DECODE_SLICE_ERROR -1
1794
#define DECODE_SLICE_OK 0
1795

    
1796
/**
1797
 * decodes a slice.
1798
 * @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br>
1799
 *         DECODE_SLICE_ERROR if the slice is damaged<br>
1800
 *         DECODE_SLICE_OK if this slice is ok<br>
1801
 */
1802
static int mpeg_decode_slice(AVCodecContext *avctx, 
1803
                              AVFrame *pict,
1804
                              int start_code,
1805
                              uint8_t **buf, int buf_size)
1806
{
1807
    Mpeg1Context *s1 = avctx->priv_data;
1808
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1809
    int ret;
1810
    const int field_pic= s->picture_structure != PICT_FRAME;
1811

    
1812
    s->resync_mb_x= s->mb_x = 
1813
    s->resync_mb_y= s->mb_y = -1;
1814
    
1815
    start_code = (start_code - 1) & 0xff;
1816
    if (start_code >= s->mb_height){
1817
        fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);
1818
        return -1;
1819
    }
1820
    
1821
    ff_mpeg1_clean_buffers(s);
1822
    s->interlaced_dct = 0;
1823
        
1824
    /* start frame decoding */
1825
    if (s->first_slice) {
1826
      if(s->first_field || s->picture_structure==PICT_FRAME){
1827
        if(MPV_frame_start(s, avctx) < 0)
1828
            return DECODE_SLICE_FATAL_ERROR;
1829

    
1830
        ff_er_frame_start(s);
1831

    
1832
        /* first check if we must repeat the frame */
1833
        s->current_picture.repeat_pict = 0;
1834

    
1835
        if (s->repeat_first_field) {
1836
            if (s->progressive_sequence) {
1837
                if (s->top_field_first)
1838
                    s->current_picture.repeat_pict = 4;
1839
                else
1840
                    s->current_picture.repeat_pict = 2;
1841
            } else if (s->progressive_frame) {
1842
                s->current_picture.repeat_pict = 1;
1843
            }
1844
        }         
1845
//        printf("%d \n", s->current_picture.repeat_pict);
1846

    
1847
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1848
             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", 
1849
                 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],
1850
                 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), 
1851
                 s->progressive_sequence ? "pro" :"", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"", 
1852
                 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1853
                 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1854
        }
1855
      }else{ //second field
1856
            int i;
1857
            
1858
            if(!s->current_picture_ptr){
1859
                fprintf(stderr, "first field missing\n");
1860
                return -1;
1861
            }
1862
            
1863
            for(i=0; i<4; i++){
1864
                s->current_picture.data[i] = s->current_picture_ptr->data[i];
1865
                if(s->picture_structure == PICT_BOTTOM_FIELD){
1866
                    s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
1867
                } 
1868
            }
1869
      }
1870
    }
1871
    s->first_slice = 0;
1872

    
1873
    init_get_bits(&s->gb, *buf, buf_size*8);
1874

    
1875
    s->qscale = get_qscale(s);
1876
    if(s->qscale == 0){
1877
        fprintf(stderr, "qscale == 0\n");
1878
        return -1;
1879
    }
1880
    
1881
    /* extra slice info */
1882
    while (get_bits1(&s->gb) != 0) {
1883
        skip_bits(&s->gb, 8);
1884
    }
1885
    
1886
    s->mb_x=0;
1887

    
1888
    for(;;) {
1889
        int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1890
        if (code < 0){
1891
            fprintf(stderr, "first mb_incr damaged\n");
1892
            return -1;
1893
        }
1894
        if (code >= 33) {
1895
            if (code == 33) {
1896
                s->mb_x += 33;
1897
            }
1898
            /* otherwise, stuffing, nothing to do */
1899
        } else {
1900
            s->mb_x += code;
1901
            break;
1902
        }
1903
    }
1904
    
1905
    s->resync_mb_x= s->mb_x;
1906
    s->resync_mb_y= s->mb_y = start_code;
1907
    s->mb_skip_run= 0;
1908

    
1909
    for(;;) {
1910
        s->dsp.clear_blocks(s->block[0]);
1911

    
1912
        ret = mpeg_decode_mb(s, s->block);
1913

    
1914
        dprintf("ret=%d\n", ret);
1915
        if (ret < 0)
1916
            return -1;
1917
            
1918
        if(s->motion_val && s->pict_type != B_TYPE){ //note motion_val is normally NULL unless we want to extract the MVs
1919
            const int wrap = s->block_wrap[0];
1920
            const int xy = s->mb_x*2 + 1 + (s->mb_y*2 +1)*wrap;
1921
            int motion_x, motion_y;
1922

    
1923
            if (s->mb_intra) {
1924
                motion_x = motion_y = 0;
1925
            }else if (s->mv_type == MV_TYPE_16X16) {
1926
                motion_x = s->mv[0][0][0];
1927
                motion_y = s->mv[0][0][1];
1928
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1929
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1930
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1931
                motion_x = (motion_x>>1) | (motion_x&1);
1932
            }
1933
            s->motion_val[xy][0] = motion_x;
1934
            s->motion_val[xy][1] = motion_y;
1935
            s->motion_val[xy + 1][0] = motion_x;
1936
            s->motion_val[xy + 1][1] = motion_y;
1937
            s->motion_val[xy + wrap][0] = motion_x;
1938
            s->motion_val[xy + wrap][1] = motion_y;
1939
            s->motion_val[xy + 1 + wrap][0] = motion_x;
1940
            s->motion_val[xy + 1 + wrap][1] = motion_y;
1941
        }
1942
        
1943
        MPV_decode_mb(s, s->block);
1944

    
1945
        if (++s->mb_x >= s->mb_width) {
1946
            if(s->picture_structure==PICT_FRAME){
1947
                ff_draw_horiz_band(s, 16*s->mb_y, 16);
1948
            }else{
1949
                if(!s->first_field){
1950
                    ff_draw_horiz_band(s, 32*s->mb_y, 32);
1951
                }
1952
            }
1953

    
1954
            s->mb_x = 0;
1955
            s->mb_y++;
1956

    
1957
            if(s->mb_y<<field_pic >= s->mb_height){
1958
                int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1959

    
1960
                if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)))
1961
                   || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
1962
                    fprintf(stderr, "end missmatch left=%d\n", left);
1963
                    return -1;
1964
                }else
1965
                    goto eos;
1966
            }
1967
        }
1968

    
1969
        /* skip mb handling */
1970
        if (s->mb_skip_run == -1) {
1971
            /* read again increment */
1972
            s->mb_skip_run = 0;
1973
            for(;;) {
1974
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1975
                if (code < 0){
1976
                    fprintf(stderr, "mb incr damaged\n");
1977
                    return -1;
1978
                }
1979
                if (code >= 33) {
1980
                    if (code == 33) {
1981
                        s->mb_skip_run += 33;
1982
                    }else if(code == 35){
1983
                        if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
1984
                            fprintf(stderr, "slice missmatch\n");
1985
                            return -1;
1986
                        }
1987
                        goto eos; /* end of slice */
1988
                    }
1989
                    /* otherwise, stuffing, nothing to do */
1990
                } else {
1991
                    s->mb_skip_run += code;
1992
                    break;
1993
                }
1994
            }
1995
        }
1996
    }
1997
eos: // end of slice
1998
    *buf += get_bits_count(&s->gb)/8 - 1;
1999
//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
2000
    return 0;
2001
}
2002

    
2003
/**
2004
 * handles slice ends.
2005
 * @return 1 if it seems to be the last slice of 
2006
 */
2007
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2008
{
2009
    Mpeg1Context *s1 = avctx->priv_data;
2010
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2011
       
2012
    if (!s1->mpeg_enc_ctx_allocated)
2013
        return 0;
2014

    
2015
    /* end of slice reached */
2016
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
2017
        /* end of image */
2018

    
2019
        if(s->mpeg2){
2020
            s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
2021
        }else
2022
            s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG1;
2023

    
2024
        ff_er_frame_end(s);
2025

    
2026
        MPV_frame_end(s);
2027

    
2028
        if (s->pict_type == B_TYPE || s->low_delay) {
2029
            *pict= *(AVFrame*)s->current_picture_ptr;
2030
            ff_print_debug_info(s, s->current_picture_ptr);
2031
        } else {
2032
            s->picture_number++;
2033
            /* latency of 1 frame for I and P frames */
2034
            /* XXX: use another variable than picture_number */
2035
            if (s->last_picture_ptr != NULL) {
2036
                *pict= *(AVFrame*)s->last_picture_ptr;
2037
                 ff_print_debug_info(s, s->last_picture_ptr);
2038
            }
2039
        }
2040
        return 1;
2041
    } else {
2042
        return 0;
2043
    }
2044
}
2045

    
2046
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
2047
                                 uint8_t *buf, int buf_size)
2048
{
2049
    Mpeg1Context *s1 = avctx->priv_data;
2050
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2051
    int width, height, i, v, j;
2052
    float aspect;
2053

    
2054
    init_get_bits(&s->gb, buf, buf_size*8);
2055

    
2056
    width = get_bits(&s->gb, 12);
2057
    height = get_bits(&s->gb, 12);
2058
    s->aspect_ratio_info= get_bits(&s->gb, 4);
2059
    if(!s->mpeg2){
2060
        aspect= mpeg1_aspect[s->aspect_ratio_info];
2061
        if(aspect!=0.0) avctx->aspect_ratio= width/(aspect*height);
2062
    }
2063

    
2064
    s->frame_rate_index = get_bits(&s->gb, 4);
2065
    if (s->frame_rate_index == 0)
2066
        return -1;
2067
    s->bit_rate = get_bits(&s->gb, 18) * 400;
2068
    if (get_bits1(&s->gb) == 0) /* marker */
2069
        return -1;
2070
    if (width <= 0 || height <= 0 ||
2071
        (width % 2) != 0 || (height % 2) != 0)
2072
        return -1;
2073
    if (width != s->width ||
2074
        height != s->height) {
2075
        /* start new mpeg1 context decoding */
2076
        s->out_format = FMT_MPEG1;
2077
        if (s1->mpeg_enc_ctx_allocated) {
2078
            MPV_common_end(s);
2079
        }
2080
        s->width = width;
2081
        s->height = height;
2082
        avctx->has_b_frames= 1;
2083
        s->avctx = avctx;
2084
        avctx->width = width;
2085
        avctx->height = height;
2086
        av_reduce(
2087
            &avctx->frame_rate, 
2088
            &avctx->frame_rate_base,
2089
            frame_rate_tab[s->frame_rate_index],
2090
            MPEG1_FRAME_RATE_BASE, //FIXME store in allready reduced form 
2091
            1<<30
2092
            );
2093
        avctx->bit_rate = s->bit_rate;
2094
        
2095
        if (MPV_common_init(s) < 0)
2096
            return -1;
2097
        s1->mpeg_enc_ctx_allocated = 1;
2098
    }
2099

    
2100
    skip_bits(&s->gb, 10); /* vbv_buffer_size */
2101
    skip_bits(&s->gb, 1);
2102

    
2103
    /* get matrix */
2104
    if (get_bits1(&s->gb)) {
2105
        for(i=0;i<64;i++) {
2106
            v = get_bits(&s->gb, 8);
2107
            j = s->intra_scantable.permutated[i];
2108
            s->intra_matrix[j] = v;
2109
            s->chroma_intra_matrix[j] = v;
2110
        }
2111
#ifdef DEBUG
2112
        dprintf("intra matrix present\n");
2113
        for(i=0;i<64;i++)
2114
            dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
2115
        printf("\n");
2116
#endif
2117
    } else {
2118
        for(i=0;i<64;i++) {
2119
            int j= s->dsp.idct_permutation[i];
2120
            v = ff_mpeg1_default_intra_matrix[i];
2121
            s->intra_matrix[j] = v;
2122
            s->chroma_intra_matrix[j] = v;
2123
        }
2124
    }
2125
    if (get_bits1(&s->gb)) {
2126
        for(i=0;i<64;i++) {
2127
            v = get_bits(&s->gb, 8);
2128
            j = s->intra_scantable.permutated[i];
2129
            s->inter_matrix[j] = v;
2130
            s->chroma_inter_matrix[j] = v;
2131
        }
2132
#ifdef DEBUG
2133
        dprintf("non intra matrix present\n");
2134
        for(i=0;i<64;i++)
2135
            dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
2136
        printf("\n");
2137
#endif
2138
    } else {
2139
        for(i=0;i<64;i++) {
2140
            int j= s->dsp.idct_permutation[i];
2141
            v = ff_mpeg1_default_non_intra_matrix[i];
2142
            s->inter_matrix[j] = v;
2143
            s->chroma_inter_matrix[j] = v;
2144
        }
2145
    }
2146

    
2147
    /* we set mpeg2 parameters so that it emulates mpeg1 */
2148
    s->progressive_sequence = 1;
2149
    s->progressive_frame = 1;
2150
    s->picture_structure = PICT_FRAME;
2151
    s->frame_pred_frame_dct = 1;
2152
    s->mpeg2 = 0;
2153
    avctx->sub_id = 1; /* indicates mpeg1 */
2154
    return 0;
2155
}
2156

    
2157
static void mpeg_decode_user_data(AVCodecContext *avctx, 
2158
                                  const uint8_t *buf, int buf_size)
2159
{
2160
    const uint8_t *p;
2161
    int len, flags;
2162
    p = buf;
2163
    len = buf_size;
2164

    
2165
    /* we parse the DTG active format information */
2166
    if (len >= 5 &&
2167
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2168
        flags = p[4];
2169
        p += 5;
2170
        len -= 5;
2171
        if (flags & 0x80) {
2172
            /* skip event id */
2173
            if (len < 2)
2174
                return;
2175
            p += 2;
2176
            len -= 2;
2177
        }
2178
        if (flags & 0x40) {
2179
            if (len < 1)
2180
                return;
2181
            avctx->dtg_active_format = p[0] & 0x0f;
2182
        }
2183
    }
2184
}
2185

    
2186
/**
2187
 * finds the end of the current frame in the bitstream.
2188
 * @return the position of the first byte of the next frame, or -1
2189
 */
2190
static int mpeg1_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
2191
    ParseContext *pc= &s->parse_context;
2192
    int i;
2193
    uint32_t state;
2194
    
2195
    state= pc->state;
2196
    
2197
    i=0;
2198
    if(!pc->frame_start_found){
2199
        for(i=0; i<buf_size; i++){
2200
            state= (state<<8) | buf[i];
2201
            if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2202
                i++;
2203
                pc->frame_start_found=1;
2204
                break;
2205
            }
2206
        }
2207
    }
2208
    
2209
    if(pc->frame_start_found){
2210
        for(; i<buf_size; i++){
2211
            state= (state<<8) | buf[i];
2212
            if((state&0xFFFFFF00) == 0x100){
2213
                if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2214
                    pc->frame_start_found=0;
2215
                    pc->state=-1; 
2216
                    return i-3;
2217
                }
2218
            }
2219
        }
2220
    }        
2221
    pc->state= state;
2222
    return END_NOT_FOUND;
2223
}
2224

    
2225
/* handle buffering and image synchronisation */
2226
static int mpeg_decode_frame(AVCodecContext *avctx, 
2227
                             void *data, int *data_size,
2228
                             uint8_t *buf, int buf_size)
2229
{
2230
    Mpeg1Context *s = avctx->priv_data;
2231
    uint8_t *buf_end, *buf_ptr;
2232
    int ret, start_code, input_size;
2233
    AVFrame *picture = data;
2234
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2235
    dprintf("fill_buffer\n");
2236

    
2237
    *data_size = 0;
2238

    
2239
    /* special case for last picture */
2240
    if (buf_size == 0) {
2241
        if (s2->picture_number > 0) {
2242
            *picture= *(AVFrame*)&s2->next_picture;
2243

    
2244
            *data_size = sizeof(AVFrame);
2245
        }
2246
        return 0;
2247
    }
2248

    
2249
    if(s2->flags&CODEC_FLAG_TRUNCATED){
2250
        int next= mpeg1_find_frame_end(s2, buf, buf_size);
2251
        
2252
        if( ff_combine_frame(s2, next, &buf, &buf_size) < 0 )
2253
            return buf_size;
2254
    }    
2255
    
2256
    buf_ptr = buf;
2257
    buf_end = buf + buf_size;
2258

    
2259
#if 0    
2260
    if (s->repeat_field % 2 == 1) { 
2261
        s->repeat_field++;
2262
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2263
        //        s2->picture_number, s->repeat_field);
2264
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2265
            *data_size = sizeof(AVPicture);
2266
            goto the_end;
2267
        }
2268
    }
2269
#endif
2270
    for(;;) {
2271
        /* find start next code */
2272
        start_code = find_start_code(&buf_ptr, buf_end);
2273
        if (start_code < 0){
2274
            if (slice_end(avctx, picture)) {
2275
                if(s2->last_picture_ptr) //FIXME merge with the stuff in mpeg_decode_slice
2276
                    *data_size = sizeof(AVPicture);
2277
            }
2278
            return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2279
        }
2280
        
2281
        input_size = buf_end - buf_ptr;
2282

    
2283
        if(avctx->debug & FF_DEBUG_STARTCODE){
2284
            printf("%3X at %d left %d\n", start_code, buf_ptr-buf, input_size);
2285
        }
2286

    
2287
                /* prepare data for next start code */
2288
                switch(start_code) {
2289
                case SEQ_START_CODE:
2290
                    mpeg1_decode_sequence(avctx, buf_ptr, 
2291
                                          input_size);
2292
                    break;
2293
                            
2294
                case PICTURE_START_CODE:
2295
                    /* we have a complete image : we try to decompress it */
2296
                    mpeg1_decode_picture(avctx, 
2297
                                         buf_ptr, input_size);
2298
                    break;
2299
                case EXT_START_CODE:
2300
                    mpeg_decode_extension(avctx,
2301
                                          buf_ptr, input_size);
2302
                    break;
2303
                case USER_START_CODE:
2304
                    mpeg_decode_user_data(avctx, 
2305
                                          buf_ptr, input_size);
2306
                    break;
2307
                default:
2308
                    if (start_code >= SLICE_MIN_START_CODE &&
2309
                        start_code <= SLICE_MAX_START_CODE) {
2310
                        
2311
                        /* skip b frames if we dont have reference frames */
2312
                        if(s2->last_picture_ptr==NULL && s2->pict_type==B_TYPE) break;
2313
                        /* skip b frames if we are in a hurry */
2314
                        if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
2315
                        /* skip everything if we are in a hurry>=5 */
2316
                        if(avctx->hurry_up>=5) break;
2317
                        
2318
                        if (!s->mpeg_enc_ctx_allocated) break;
2319

    
2320
                        ret = mpeg_decode_slice(avctx, picture,
2321
                                                start_code, &buf_ptr, input_size);
2322
                        emms_c();
2323

    
2324
                        if(ret < 0){
2325
                            if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2326
                                ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, AC_ERROR|DC_ERROR|MV_ERROR);
2327
                            if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
2328
                        }else{
2329
                            ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, AC_END|DC_END|MV_END);
2330
                        }
2331
                    }
2332
                    break;
2333
                }
2334
    }
2335
}
2336

    
2337
static int mpeg_decode_end(AVCodecContext *avctx)
2338
{
2339
    Mpeg1Context *s = avctx->priv_data;
2340

    
2341
    if (s->mpeg_enc_ctx_allocated)
2342
        MPV_common_end(&s->mpeg_enc_ctx);
2343
    return 0;
2344
}
2345

    
2346
AVCodec mpeg_decoder = {
2347
    "mpegvideo",
2348
    CODEC_TYPE_VIDEO,
2349
    CODEC_ID_MPEG1VIDEO,
2350
    sizeof(Mpeg1Context),
2351
    mpeg_decode_init,
2352
    NULL,
2353
    mpeg_decode_end,
2354
    mpeg_decode_frame,
2355
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2356
};