Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ c009df3f

History | View | Annotate | Download (78.6 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
#endif
77

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

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

    
117
static void init_uni_ac_vlc(RLTable *rl, uint32_t *uni_ac_vlc_bits, uint8_t *uni_ac_vlc_len){
118
    int i;
119

    
120
    for(i=0; i<128; i++){
121
        int level= i-64;
122
        int run;
123
        for(run=0; run<64; run++){
124
            int len, bits, code;
125
            
126
            int alevel= ABS(level);
127
            int sign= (level>>31)&1;
128

    
129
            if (alevel > rl->max_level[0][run])
130
                code= 111; /*rl->n*/
131
            else
132
                code= rl->index_run[0][run] + alevel - 1;
133

    
134
            if (code < 111 /* rl->n */) {
135
                    /* store the vlc & sign at once */
136
                len=   mpeg1_vlc[code][1]+1;
137
                bits= (mpeg1_vlc[code][0]<<1) + sign;
138
            } else {
139
                len=  mpeg1_vlc[111/*rl->n*/][1]+6;
140
                bits= mpeg1_vlc[111/*rl->n*/][0]<<6;
141

    
142
                bits|= run;
143
                if (alevel < 128) {
144
                    bits<<=8; len+=8;
145
                    bits|= level & 0xff;
146
                } else {
147
                    bits<<=16; len+=16;
148
                    bits|= level & 0xff;
149
                    if (level < 0) {
150
                        bits|= 0x8001 + level + 255;
151
                    } else {
152
                        bits|= level & 0xffff;
153
                    }
154
                }
155
            }
156

    
157
            uni_ac_vlc_bits[UNI_AC_ENC_INDEX(run, i)]= bits;
158
            uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len;
159
        }
160
    }
161
}
162

    
163
static void put_header(MpegEncContext *s, int header)
164
{
165
    align_put_bits(&s->pb);
166
    put_bits(&s->pb, 16, header>>16);
167
    put_bits(&s->pb, 16, header&0xFFFF);
168
}
169

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

    
223
            if(s->avctx->rc_buffer_size)
224
                vbv_buffer_size = s->avctx->rc_buffer_size;
225
            else
226
                /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */
227
                vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;         
228
            put_bits(&s->pb, 10, (vbv_buffer_size + 16383) / 16384); 
229
            put_bits(&s->pb, 1, 1); /* constrained parameter flag */
230
            put_bits(&s->pb, 1, 0); /* no custom intra matrix */
231
            put_bits(&s->pb, 1, 0); /* no custom non intra matrix */
232

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

    
249
        if (s->avctx->frame_rate < (24 * s->avctx->frame_rate_base) && s->picture_number > 0) {
250
            /* insert empty P pictures to slow down to the desired
251
               frame rate. Each fake pictures takes about 20 bytes */
252
            fps = frame_rate_tab[s->frame_rate_index];
253
            n = av_rescale((int64_t)s->picture_number * s->avctx->frame_rate_base, fps, s->avctx->frame_rate) / MPEG1_FRAME_RATE_BASE - 1;
254
            while (s->fake_picture_number < n) {
255
                mpeg1_skip_picture(s, s->fake_picture_number - 
256
                                   s->gop_picture_number); 
257
                s->fake_picture_number++;
258
            }
259

    
260
        }
261
}
262

    
263
static inline void encode_mb_skip_run(MpegEncContext *s, int run){
264
    while (run >= 33) {
265
        put_bits(&s->pb, 11, 0x008);
266
        run -= 33;
267
    }
268
    put_bits(&s->pb, mbAddrIncrTable[run][1], 
269
             mbAddrIncrTable[run][0]);
270
}
271

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

    
302
    /* output a number of empty slice */
303
    encode_mb_skip_run(s, s->mb_width * s->mb_height - 2);
304
    
305
    /* empty macroblock */
306
    put_bits(&s->pb, 3, 1); /* motion only */
307
    
308
    /* zero motion x & y */
309
    put_bits(&s->pb, 1, 1); 
310
    put_bits(&s->pb, 1, 1); 
311
}
312

    
313
static void common_init(MpegEncContext *s)
314
{
315
    s->y_dc_scale_table=
316
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
317
}
318

    
319
#ifdef CONFIG_ENCODERS
320

    
321
void ff_mpeg1_encode_slice_header(MpegEncContext *s){
322
    put_header(s, SLICE_MIN_START_CODE + s->mb_y);
323
    put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
324
    put_bits(&s->pb, 1, 0); /* slice extra information */
325
}
326

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

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

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

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

    
362
    put_bits(&s->pb, 1, 0); /* extra bit picture */
363
    
364
    s->mb_y=0;
365
    ff_mpeg1_encode_slice_header(s);
366
}
367

    
368
void mpeg1_encode_mb(MpegEncContext *s,
369
                     DCTELEM block[6][64],
370
                     int motion_x, int motion_y)
371
{
372
    int i, cbp;
373
    const int mb_x = s->mb_x;
374
    const int mb_y = s->mb_y;
375
    const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
376

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

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

    
554
    // RAL: By this:
555
    if (s->mv_dir & MV_DIR_FORWARD)
556
        {
557
        s->last_mv[0][0][0]= s->mv[0][0][0];
558
        s->last_mv[0][0][1]= s->mv[0][0][1];
559
        }
560
    if (s->mv_dir & MV_DIR_BACKWARD)
561
        {
562
        s->last_mv[1][0][0]= s->mv[1][0][0];
563
        s->last_mv[1][0][1]= s->mv[1][0][1];
564
        }
565
}
566

    
567
// RAL: Parameter added: f_or_b_code
568
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
569
{
570
    int code, bit_size, l, m, bits, range, sign;
571

    
572
    if (val == 0) {
573
        /* zero vector */
574
        code = 0;
575
        put_bits(&s->pb,
576
                 mbMotionVectorTable[0][1], 
577
                 mbMotionVectorTable[0][0]); 
578
    } else {
579
        bit_size = f_or_b_code - 1;
580
        range = 1 << bit_size;
581
        /* modulo encoding */
582
        l = 16 * range;
583
        m = 2 * l;
584
        if (val < -l) {
585
            val += m;
586
        } else if (val >= l) {
587
            val -= m;
588
        }
589

    
590
        if (val >= 0) {
591
            val--;
592
            code = (val >> bit_size) + 1;
593
            bits = val & (range - 1);
594
            sign = 0;
595
        } else {
596
            val = -val;
597
            val--;
598
            code = (val >> bit_size) + 1;
599
            bits = val & (range - 1);
600
            sign = 1;
601
        }
602

    
603
        assert(code > 0 && code <= 16);
604

    
605
        put_bits(&s->pb,
606
                 mbMotionVectorTable[code][1], 
607
                 mbMotionVectorTable[code][0]); 
608

    
609
        put_bits(&s->pb, 1, sign);
610
        if (bit_size > 0) {
611
            put_bits(&s->pb, bit_size, bits);
612
        }
613
    }
614
}
615

    
616
void ff_mpeg1_encode_init(MpegEncContext *s)
617
{
618
    static int done=0;
619

    
620
    common_init(s);
621

    
622
    if(!done){
623
        int f_code;
624
        int mv;
625
        int i;
626

    
627
        done=1;
628
        init_rl(&rl_mpeg1);
629

    
630
        for(i=0; i<64; i++)
631
        {
632
                mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
633
                mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
634
        }
635
        
636
        init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_bits, uni_mpeg1_ac_vlc_len);
637

    
638
        /* build unified dc encoding tables */
639
        for(i=-255; i<256; i++)
640
        {
641
                int adiff, index;
642
                int bits, code;
643
                int diff=i;
644

    
645
                adiff = ABS(diff);
646
                if(diff<0) diff--;
647
                index = vlc_dc_table[adiff];
648

    
649
                bits= vlc_dc_lum_bits[index] + index;
650
                code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
651
                mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
652
                
653
                bits= vlc_dc_chroma_bits[index] + index;
654
                code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
655
                mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
656
        }
657

    
658
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
659

    
660
        for(f_code=1; f_code<=MAX_FCODE; f_code++){
661
            for(mv=-MAX_MV; mv<=MAX_MV; mv++){
662
                int len;
663

    
664
                if(mv==0) len= mbMotionVectorTable[0][1];
665
                else{
666
                    int val, bit_size, range, code;
667

    
668
                    bit_size = s->f_code - 1;
669
                    range = 1 << bit_size;
670

    
671
                    val=mv;
672
                    if (val < 0) 
673
                        val = -val;
674
                    val--;
675
                    code = (val >> bit_size) + 1;
676
                    if(code<17){
677
                        len= mbMotionVectorTable[code][1] + 1 + bit_size;
678
                    }else{
679
                        len= mbMotionVectorTable[16][1] + 2 + bit_size;
680
                    }
681
                }
682

    
683
                mv_penalty[f_code][mv+MAX_MV]= len;
684
            }
685
        }
686
        
687

    
688
        for(f_code=MAX_FCODE; f_code>0; f_code--){
689
            for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
690
                fcode_tab[mv+MAX_MV]= f_code;
691
            }
692
        }
693
    }
694
    s->me.mv_penalty= mv_penalty;
695
    s->fcode_tab= fcode_tab;
696
    s->min_qcoeff=-255;
697
    s->max_qcoeff= 255;
698
    s->intra_ac_vlc_length=
699
    s->inter_ac_vlc_length= uni_mpeg1_ac_vlc_len;
700
}
701

    
702
static inline void encode_dc(MpegEncContext *s, int diff, int component)
703
{
704
    if (component == 0) {
705
        put_bits(
706
            &s->pb, 
707
            mpeg1_lum_dc_uni[diff+255]&0xFF,
708
            mpeg1_lum_dc_uni[diff+255]>>8);
709
    } else {
710
        put_bits(
711
            &s->pb, 
712
            mpeg1_chr_dc_uni[diff+255]&0xFF,
713
            mpeg1_chr_dc_uni[diff+255]>>8);
714
    }
715
}
716

    
717
static void mpeg1_encode_block(MpegEncContext *s, 
718
                               DCTELEM *block, 
719
                               int n)
720
{
721
    int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
722
    int code, component;
723
//    RLTable *rl = &rl_mpeg1;
724

    
725
    last_index = s->block_last_index[n];
726

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

    
750
    /* now quantify & encode AC coefs */
751
    last_non_zero = i - 1;
752

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

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

    
797
/******************************************/
798
/* decoding */
799

    
800
static VLC dc_lum_vlc;
801
static VLC dc_chroma_vlc;
802
static VLC mv_vlc;
803
static VLC mbincr_vlc;
804
static VLC mb_ptype_vlc;
805
static VLC mb_btype_vlc;
806
static VLC mb_pat_vlc;
807

    
808
static void init_vlcs(MpegEncContext *s)
809
{
810
    static int done = 0;
811

    
812
    if (!done) {
813
        done = 1;
814

    
815
        init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12, 
816
                 vlc_dc_lum_bits, 1, 1,
817
                 vlc_dc_lum_code, 2, 2);
818
        init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12, 
819
                 vlc_dc_chroma_bits, 1, 1,
820
                 vlc_dc_chroma_code, 2, 2);
821
        init_vlc(&mv_vlc, MV_VLC_BITS, 17, 
822
                 &mbMotionVectorTable[0][1], 2, 1,
823
                 &mbMotionVectorTable[0][0], 2, 1);
824
        init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36, 
825
                 &mbAddrIncrTable[0][1], 2, 1,
826
                 &mbAddrIncrTable[0][0], 2, 1);
827
        init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63, 
828
                 &mbPatTable[0][1], 2, 1,
829
                 &mbPatTable[0][0], 2, 1);
830
        
831
        init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7, 
832
                 &table_mb_ptype[0][1], 2, 1,
833
                 &table_mb_ptype[0][0], 2, 1);
834
        init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11, 
835
                 &table_mb_btype[0][1], 2, 1,
836
                 &table_mb_btype[0][0], 2, 1);
837
        init_rl(&rl_mpeg1);
838
        init_rl(&rl_mpeg2);
839

    
840
        init_2d_vlc_rl(&rl_mpeg1);
841
        init_2d_vlc_rl(&rl_mpeg2);
842
    }
843
}
844

    
845
static inline int get_dmv(MpegEncContext *s)
846
{
847
    if(get_bits1(&s->gb)) 
848
        return 1 - (get_bits1(&s->gb) << 1);
849
    else
850
        return 0;
851
}
852

    
853
static inline int get_qscale(MpegEncContext *s)
854
{
855
    int qscale = get_bits(&s->gb, 5);
856
    if (s->mpeg2) {
857
        if (s->q_scale_type) {
858
            return non_linear_qscale[qscale];
859
        } else {
860
            return qscale << 1;
861
        }
862
    }
863
    return qscale;
864
}
865

    
866
/* motion type (for mpeg2) */
867
#define MT_FIELD 1
868
#define MT_FRAME 2
869
#define MT_16X8  2
870
#define MT_DMV   3
871

    
872
static int mpeg_decode_mb(MpegEncContext *s,
873
                          DCTELEM block[6][64])
874
{
875
    int i, j, k, cbp, val, mb_type, motion_type;
876
    
877
    dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
878

    
879
    assert(s->mb_skiped==0);
880

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

    
907
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= 
908
                s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1] | MB_TYPE_SKIP;
909
//            assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
910

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

    
915
        return 0;
916
    }
917

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

    
955
        if (IS_QUANT(mb_type))
956
            s->qscale = get_qscale(s);
957
        
958
        if (s->concealment_motion_vectors) {
959
            /* just parse them */
960
            if (s->picture_structure != PICT_FRAME) 
961
                skip_bits1(&s->gb); /* field select */
962
            mpeg_decode_motion(s, s->mpeg_f_code[0][0], 0);
963
            mpeg_decode_motion(s, s->mpeg_f_code[0][1], 0);
964
            skip_bits1(&s->gb); /* marker */
965
        }
966
        s->mb_intra = 1;
967
        memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
968

    
969
        if (s->mpeg2) {
970
            for(i=0;i<6;i++) {
971
                if (mpeg2_decode_block_intra(s, block[i], i) < 0)
972
                    return -1;
973
            }
974
        } else {
975
            for(i=0;i<6;i++) {
976
                if (mpeg1_decode_block_intra(s, block[i], i) < 0)
977
                    return -1;
978
            }
979
        }
980
    } else {
981
        if (mb_type & MB_TYPE_ZERO_MV){
982
            assert(mb_type & MB_TYPE_PAT);
983

    
984
            /* compute dct type */
985
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
986
                !s->frame_pred_frame_dct) {
987
                s->interlaced_dct = get_bits1(&s->gb);
988
            }
989

    
990
            if (IS_QUANT(mb_type))
991
                s->qscale = get_qscale(s);
992

    
993
            s->mv_dir = MV_DIR_FORWARD;
994
            s->mv_type = MV_TYPE_16X16;
995
            s->last_mv[0][0][0] = 0;
996
            s->last_mv[0][0][1] = 0;
997
            s->last_mv[0][1][0] = 0;
998
            s->last_mv[0][1][1] = 0;
999
            s->mv[0][0][0] = 0;
1000
            s->mv[0][0][1] = 0;
1001
        }else{
1002
            assert(mb_type & MB_TYPE_L0L1);
1003
//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
1004
            /* get additionnal motion vector type */
1005
            if (s->frame_pred_frame_dct) 
1006
                motion_type = MT_FRAME;
1007
            else{
1008
                motion_type = get_bits(&s->gb, 2);
1009
            }
1010

    
1011
            /* compute dct type */
1012
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1013
                !s->frame_pred_frame_dct && IS_PAT(mb_type)) {
1014
                s->interlaced_dct = get_bits1(&s->gb);
1015
            }
1016

    
1017
            if (IS_QUANT(mb_type))
1018
                s->qscale = get_qscale(s);
1019

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

    
1089
                            mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 
1090
                                                    s->last_mv[i][0][0]);
1091
                            s->last_mv[i][0][0] = mx;
1092
                            s->last_mv[i][1][0] = mx;
1093
                            dmx = get_dmv(s);
1094
                            my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 
1095
                                                    s->last_mv[i][0][1] >> 1);
1096
                            dmy = get_dmv(s);
1097
                            s->mv_type = MV_TYPE_DMV;
1098
                            /* XXX: totally broken */
1099
                            if (s->picture_structure == PICT_FRAME) {
1100
                                mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED; 
1101

    
1102
                                s->last_mv[i][0][1] = my << 1;
1103
                                s->last_mv[i][1][1] = my << 1;
1104

    
1105
                                m = s->top_field_first ? 1 : 3;
1106
                                /* top -> top pred */
1107
                                s->mv[i][0][0] = mx; 
1108
                                s->mv[i][0][1] = my << 1;
1109
                                s->mv[i][1][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1110
                                s->mv[i][1][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1111
                                m = 4 - m;
1112
                                s->mv[i][2][0] = mx;
1113
                                s->mv[i][2][1] = my << 1;
1114
                                s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1115
                                s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1116
                            } else {
1117
                                mb_type |= MB_TYPE_16x16;
1118

    
1119
                                s->last_mv[i][0][1] = my;
1120
                                s->last_mv[i][1][1] = my;
1121
                                s->mv[i][0][0] = mx;
1122
                                s->mv[i][0][1] = my;
1123
                                s->mv[i][1][0] = ((mx + (mx > 0)) >> 1) + dmx;
1124
                                s->mv[i][1][1] = ((my + (my > 0)) >> 1) + dmy - 1 
1125
                                    /* + 2 * cur_field */;
1126
                            }
1127
                        }
1128
                        break;
1129
                    }
1130
                }
1131
            }
1132
        }
1133
        
1134
        s->mb_intra = 0;
1135

    
1136
        if (IS_PAT(mb_type)) {
1137
            cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1138
            if (cbp < 0){
1139
                fprintf(stderr, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
1140
                return -1;
1141
            }
1142
            cbp++;
1143

    
1144
            if (s->mpeg2) {
1145
                for(i=0;i<6;i++) {
1146
                    if (cbp & 32) {
1147
                        if (mpeg2_decode_block_non_intra(s, block[i], i) < 0)
1148
                            return -1;
1149
                    } else {
1150
                        s->block_last_index[i] = -1;
1151
                    }
1152
                    cbp+=cbp;
1153
                }
1154
            } else {
1155
                for(i=0;i<6;i++) {
1156
                    if (cbp & 32) {
1157
                        if (mpeg1_decode_block_inter(s, block[i], i) < 0)
1158
                            return -1;
1159
                    } else {
1160
                        s->block_last_index[i] = -1;
1161
                    }
1162
                    cbp+=cbp;
1163
                }
1164
            }
1165
        }else{
1166
            for(i=0;i<6;i++)
1167
                s->block_last_index[i] = -1;
1168
        }
1169
    }
1170

    
1171
    s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
1172

    
1173
    return 0;
1174
}
1175

    
1176
/* as h263, but only 17 codes */
1177
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
1178
{
1179
    int code, sign, val, l, shift;
1180

    
1181
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
1182
    if (code == 0) {
1183
        return pred;
1184
    }
1185
    if (code < 0) {
1186
        return 0xffff;
1187
    }
1188

    
1189
    sign = get_bits1(&s->gb);
1190
    shift = fcode - 1;
1191
    val = code;
1192
    if (shift) {
1193
        val = (val - 1) << shift;
1194
        val |= get_bits(&s->gb, shift);
1195
        val++;
1196
    }
1197
    if (sign)
1198
        val = -val;
1199
    val += pred;
1200
    
1201
    /* modulo decoding */
1202
    l = 1 << (shift+4);
1203
    val = ((val + l)&(l*2-1)) - l;
1204
    return val;
1205
}
1206

    
1207
static inline int decode_dc(MpegEncContext *s, int component)
1208
{
1209
    int code, diff;
1210

    
1211
    if (component == 0) {
1212
        code = get_vlc2(&s->gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1213
    } else {
1214
        code = get_vlc2(&s->gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1215
    }
1216
    if (code < 0){
1217
        fprintf(stderr, "invalid dc code at %d %d\n", s->mb_x, s->mb_y);
1218
        return 0xffff;
1219
    }
1220
    if (code == 0) {
1221
        diff = 0;
1222
    } else {
1223
        diff = get_xbits(&s->gb, code);
1224
    }
1225
    return diff;
1226
}
1227

    
1228
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
1229
                               DCTELEM *block, 
1230
                               int n)
1231
{
1232
    int level, dc, diff, i, j, run;
1233
    int component;
1234
    RLTable *rl = &rl_mpeg1;
1235
    uint8_t * const scantable= s->intra_scantable.permutated;
1236
    const uint16_t *quant_matrix= s->intra_matrix;
1237
    const int qscale= s->qscale;
1238

    
1239
    /* DC coef */
1240
    component = (n <= 3 ? 0 : n - 4 + 1);
1241
    diff = decode_dc(s, component);
1242
    if (diff >= 0xffff)
1243
        return -1;
1244
    dc = s->last_dc[component];
1245
    dc += diff;
1246
    s->last_dc[component] = dc;
1247
    block[0] = dc<<3;
1248
    dprintf("dc=%d diff=%d\n", dc, diff);
1249
    i = 0;
1250
    {
1251
        OPEN_READER(re, &s->gb);    
1252
        /* now quantify & encode AC coefs */
1253
        for(;;) {
1254
            UPDATE_CACHE(re, &s->gb);
1255
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1256
            
1257
            if(level == 127){
1258
                break;
1259
            } else if(level != 0) {
1260
                i += run;
1261
                j = scantable[i];
1262
                level= (level*qscale*quant_matrix[j])>>3;
1263
                level= (level-1)|1;
1264
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1265
                LAST_SKIP_BITS(re, &s->gb, 1);
1266
            } else {
1267
                /* escape */
1268
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1269
                UPDATE_CACHE(re, &s->gb);
1270
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1271
                if (level == -128) {
1272
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1273
                } else if (level == 0) {
1274
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1275
                }
1276
                i += run;
1277
                j = scantable[i];
1278
                if(level<0){
1279
                    level= -level;
1280
                    level= (level*qscale*quant_matrix[j])>>3;
1281
                    level= (level-1)|1;
1282
                    level= -level;
1283
                }else{
1284
                    level= (level*qscale*quant_matrix[j])>>3;
1285
                    level= (level-1)|1;
1286
                }
1287
            }
1288
            if (i > 63){
1289
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1290
                return -1;
1291
            }
1292

    
1293
            block[j] = level;
1294
        }
1295
        CLOSE_READER(re, &s->gb);
1296
    }
1297
    s->block_last_index[n] = i;
1298
   return 0;
1299
}
1300

    
1301
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
1302
                               DCTELEM *block, 
1303
                               int n)
1304
{
1305
    int level, i, j, run;
1306
    RLTable *rl = &rl_mpeg1;
1307
    uint8_t * const scantable= s->intra_scantable.permutated;
1308
    const uint16_t *quant_matrix= s->inter_matrix;
1309
    const int qscale= s->qscale;
1310

    
1311
    {
1312
        int v;
1313
        OPEN_READER(re, &s->gb);
1314
        i = -1;
1315
        /* special case for the first coef. no need to add a second vlc table */
1316
        UPDATE_CACHE(re, &s->gb);
1317
        v= SHOW_UBITS(re, &s->gb, 2);
1318
        if (v & 2) {
1319
            LAST_SKIP_BITS(re, &s->gb, 2);
1320
            level= (3*qscale*quant_matrix[0])>>4;
1321
            level= (level-1)|1;
1322
            if(v&1)
1323
                level= -level;
1324
            block[0] = level;
1325
            i++;
1326
        }
1327

    
1328
        /* now quantify & encode AC coefs */
1329
        for(;;) {
1330
            UPDATE_CACHE(re, &s->gb);
1331
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1332
            
1333
            if(level == 127){
1334
                break;
1335
            } else if(level != 0) {
1336
                i += run;
1337
                j = scantable[i];
1338
                level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1339
                level= (level-1)|1;
1340
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1341
                LAST_SKIP_BITS(re, &s->gb, 1);
1342
            } else {
1343
                /* escape */
1344
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1345
                UPDATE_CACHE(re, &s->gb);
1346
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1347
                if (level == -128) {
1348
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1349
                } else if (level == 0) {
1350
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1351
                }
1352
                i += run;
1353
                j = scantable[i];
1354
                if(level<0){
1355
                    level= -level;
1356
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1357
                    level= (level-1)|1;
1358
                    level= -level;
1359
                }else{
1360
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1361
                    level= (level-1)|1;
1362
                }
1363
            }
1364
            if (i > 63){
1365
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1366
                return -1;
1367
            }
1368

    
1369
            block[j] = level;
1370
        }
1371
        CLOSE_READER(re, &s->gb);
1372
    }
1373
    s->block_last_index[n] = i;
1374
    return 0;
1375
}
1376

    
1377
/* Also does unquantization here, since I will never support mpeg2
1378
   encoding */
1379
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1380
                               DCTELEM *block, 
1381
                               int n)
1382
{
1383
    int level, i, j, run;
1384
    RLTable *rl = &rl_mpeg1;
1385
    uint8_t * const scantable= s->intra_scantable.permutated;
1386
    const uint16_t *quant_matrix;
1387
    const int qscale= s->qscale;
1388
    int mismatch;
1389

    
1390
    mismatch = 1;
1391

    
1392
    {
1393
        int v;
1394
        OPEN_READER(re, &s->gb);
1395
        i = -1;
1396
        if (n < 4)
1397
            quant_matrix = s->inter_matrix;
1398
        else
1399
            quant_matrix = s->chroma_inter_matrix;
1400

    
1401
        /* special case for the first coef. no need to add a second vlc table */
1402
        UPDATE_CACHE(re, &s->gb);
1403
        v= SHOW_UBITS(re, &s->gb, 2);
1404
        if (v & 2) {
1405
            LAST_SKIP_BITS(re, &s->gb, 2);
1406
            level= (3*qscale*quant_matrix[0])>>5;
1407
            if(v&1)
1408
                level= -level;
1409
            block[0] = level;
1410
            mismatch ^= level;
1411
            i++;
1412
        }
1413

    
1414
        /* now quantify & encode AC coefs */
1415
        for(;;) {
1416
            UPDATE_CACHE(re, &s->gb);
1417
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1418
            
1419
            if(level == 127){
1420
                break;
1421
            } else if(level != 0) {
1422
                i += run;
1423
                j = scantable[i];
1424
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1425
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1426
                LAST_SKIP_BITS(re, &s->gb, 1);
1427
            } else {
1428
                /* escape */
1429
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1430
                UPDATE_CACHE(re, &s->gb);
1431
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1432

    
1433
                i += run;
1434
                j = scantable[i];
1435
                if(level<0){
1436
                    level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1437
                    level= -level;
1438
                }else{
1439
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1440
                }
1441
            }
1442
            if (i > 63){
1443
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1444
                return -1;
1445
            }
1446
            
1447
            mismatch ^= level;
1448
            block[j] = level;
1449
        }
1450
        CLOSE_READER(re, &s->gb);
1451
    }
1452
    block[63] ^= (mismatch & 1);
1453
    
1454
    s->block_last_index[n] = i;
1455
    return 0;
1456
}
1457

    
1458
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
1459
                               DCTELEM *block, 
1460
                               int n)
1461
{
1462
    int level, dc, diff, i, j, run;
1463
    int component;
1464
    RLTable *rl;
1465
    uint8_t * const scantable= s->intra_scantable.permutated;
1466
    const uint16_t *quant_matrix;
1467
    const int qscale= s->qscale;
1468
    int mismatch;
1469

    
1470
    /* DC coef */
1471
    if (n < 4){
1472
        quant_matrix = s->intra_matrix;
1473
        component = 0; 
1474
    }else{
1475
        quant_matrix = s->chroma_intra_matrix;
1476
        component = n - 3;
1477
    }
1478
    diff = decode_dc(s, component);
1479
    if (diff >= 0xffff)
1480
        return -1;
1481
    dc = s->last_dc[component];
1482
    dc += diff;
1483
    s->last_dc[component] = dc;
1484
    block[0] = dc << (3 - s->intra_dc_precision);
1485
    dprintf("dc=%d\n", block[0]);
1486
    mismatch = block[0] ^ 1;
1487
    i = 0;
1488
    if (s->intra_vlc_format)
1489
        rl = &rl_mpeg2;
1490
    else
1491
        rl = &rl_mpeg1;
1492

    
1493
    {
1494
        OPEN_READER(re, &s->gb);    
1495
        /* now quantify & encode AC coefs */
1496
        for(;;) {
1497
            UPDATE_CACHE(re, &s->gb);
1498
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1499
            
1500
            if(level == 127){
1501
                break;
1502
            } else if(level != 0) {
1503
                i += run;
1504
                j = scantable[i];
1505
                level= (level*qscale*quant_matrix[j])>>4;
1506
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1507
                LAST_SKIP_BITS(re, &s->gb, 1);
1508
            } else {
1509
                /* escape */
1510
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1511
                UPDATE_CACHE(re, &s->gb);
1512
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1513
                i += run;
1514
                j = scantable[i];
1515
                if(level<0){
1516
                    level= (-level*qscale*quant_matrix[j])>>4;
1517
                    level= -level;
1518
                }else{
1519
                    level= (level*qscale*quant_matrix[j])>>4;
1520
                }
1521
            }
1522
            if (i > 63){
1523
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1524
                return -1;
1525
            }
1526
            
1527
            mismatch^= level;
1528
            block[j] = level;
1529
        }
1530
        CLOSE_READER(re, &s->gb);
1531
    }
1532
    block[63]^= mismatch&1;
1533
    
1534
    s->block_last_index[n] = i;
1535
    return 0;
1536
}
1537

    
1538
typedef struct Mpeg1Context {
1539
    MpegEncContext mpeg_enc_ctx;
1540
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1541
    int repeat_field; /* true if we must repeat the field */
1542
} Mpeg1Context;
1543

    
1544
static int mpeg_decode_init(AVCodecContext *avctx)
1545
{
1546
    Mpeg1Context *s = avctx->priv_data;
1547
    
1548
    s->mpeg_enc_ctx.flags= avctx->flags;
1549
    common_init(&s->mpeg_enc_ctx);
1550
    init_vlcs(&s->mpeg_enc_ctx);
1551

    
1552
    s->mpeg_enc_ctx_allocated = 0;
1553
    s->mpeg_enc_ctx.picture_number = 0;
1554
    s->repeat_field = 0;
1555
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1556
    return 0;
1557
}
1558

    
1559
/* return the 8 bit start code value and update the search
1560
   state. Return -1 if no start code found */
1561
static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end)
1562
{
1563
    uint8_t *buf_ptr;
1564
    unsigned int state=0xFFFFFFFF, v;
1565
    int val;
1566

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

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

    
1590
    init_get_bits(&s->gb, buf, buf_size*8);
1591

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

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

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

    
1629
    skip_bits(&s->gb, 8); /* profil and level */
1630
    s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1631
    skip_bits(&s->gb, 2); /* chroma_format */
1632
    horiz_size_ext = get_bits(&s->gb, 2);
1633
    vert_size_ext = get_bits(&s->gb, 2);
1634
    s->width |= (horiz_size_ext << 12);
1635
    s->height |= (vert_size_ext << 12);
1636
    bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1637
    s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
1638
    skip_bits1(&s->gb); /* marker */
1639
    vbv_buf_ext = get_bits(&s->gb, 8);
1640
    s->low_delay = get_bits1(&s->gb);
1641
    frame_rate_ext_n = get_bits(&s->gb, 2);
1642
    frame_rate_ext_d = get_bits(&s->gb, 5);
1643
    av_reduce(
1644
        &s->avctx->frame_rate, 
1645
        &s->avctx->frame_rate_base, 
1646
        frame_rate_tab[s->frame_rate_index] * (frame_rate_ext_n+1),
1647
        MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d+1),
1648
        1<<30);
1649

    
1650
    dprintf("sequence extension\n");
1651
    s->mpeg2 = 1;
1652
    s->avctx->sub_id = 2; /* indicates mpeg2 found */
1653

    
1654
    aspect= mpeg2_aspect[s->aspect_ratio_info];
1655
    if(aspect>0.0)      s->avctx->aspect_ratio= s->width/(aspect*s->height);
1656
    else if(aspect<0.0) s->avctx->aspect_ratio= -1.0/aspect;
1657
}
1658

    
1659
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1660
{
1661
    int i, v, j;
1662

    
1663
    dprintf("matrix extension\n");
1664

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

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

    
1747
static void mpeg_decode_extension(AVCodecContext *avctx, 
1748
                                  uint8_t *buf, int buf_size)
1749
{
1750
    Mpeg1Context *s1 = avctx->priv_data;
1751
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1752
    int ext_type;
1753

    
1754
    init_get_bits(&s->gb, buf, buf_size*8);
1755
    
1756
    ext_type = get_bits(&s->gb, 4);
1757
    switch(ext_type) {
1758
    case 0x1:
1759
        /* sequence ext */
1760
        mpeg_decode_sequence_extension(s);
1761
        break;
1762
    case 0x3:
1763
        /* quant matrix extension */
1764
        mpeg_decode_quant_matrix_extension(s);
1765
        break;
1766
    case 0x8:
1767
        /* picture extension */
1768
        mpeg_decode_picture_coding_extension(s);
1769
        break;
1770
    }
1771
}
1772

    
1773
#define DECODE_SLICE_FATAL_ERROR -2
1774
#define DECODE_SLICE_ERROR -1
1775
#define DECODE_SLICE_OK 0
1776

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

    
1793
    s->resync_mb_x= s->mb_x = 
1794
    s->resync_mb_y= s->mb_y = -1;
1795
    
1796
    start_code = (start_code - 1) & 0xff;
1797
    if (start_code >= s->mb_height){
1798
        fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);
1799
        return -1;
1800
    }
1801
    
1802
    ff_mpeg1_clean_buffers(s);
1803
    s->interlaced_dct = 0;
1804
        
1805
    /* start frame decoding */
1806
    if (s->first_slice) {
1807
      if(s->first_field || s->picture_structure==PICT_FRAME){
1808
        if(MPV_frame_start(s, avctx) < 0)
1809
            return DECODE_SLICE_FATAL_ERROR;
1810

    
1811
        ff_er_frame_start(s);
1812

    
1813
        /* first check if we must repeat the frame */
1814
        s->current_picture.repeat_pict = 0;
1815

    
1816
        if (s->repeat_first_field) {
1817
            if (s->progressive_sequence) {
1818
                if (s->top_field_first)
1819
                    s->current_picture.repeat_pict = 4;
1820
                else
1821
                    s->current_picture.repeat_pict = 2;
1822
            } else if (s->progressive_frame) {
1823
                s->current_picture.repeat_pict = 1;
1824
            }
1825
        }         
1826
//        printf("%d \n", s->current_picture.repeat_pict);
1827

    
1828
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1829
             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", 
1830
                 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],
1831
                 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), 
1832
                 s->progressive_sequence ? "pro" :"", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"", 
1833
                 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1834
                 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1835
        }
1836
      }else{ //second field
1837
            int i;
1838
            
1839
            if(!s->current_picture_ptr){
1840
                fprintf(stderr, "first field missing\n");
1841
                return -1;
1842
            }
1843
            
1844
            for(i=0; i<4; i++){
1845
                s->current_picture.data[i] = s->current_picture_ptr->data[i];
1846
                if(s->picture_structure == PICT_BOTTOM_FIELD){
1847
                    s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
1848
                } 
1849
            }
1850
      }
1851
    }
1852
    s->first_slice = 0;
1853

    
1854
    init_get_bits(&s->gb, *buf, buf_size*8);
1855

    
1856
    s->qscale = get_qscale(s);
1857
    if(s->qscale == 0){
1858
        fprintf(stderr, "qscale == 0\n");
1859
        return -1;
1860
    }
1861
    
1862
    /* extra slice info */
1863
    while (get_bits1(&s->gb) != 0) {
1864
        skip_bits(&s->gb, 8);
1865
    }
1866
    
1867
    s->mb_x=0;
1868

    
1869
    for(;;) {
1870
        int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1871
        if (code < 0){
1872
            fprintf(stderr, "first mb_incr damaged\n");
1873
            return -1;
1874
        }
1875
        if (code >= 33) {
1876
            if (code == 33) {
1877
                s->mb_x += 33;
1878
            }
1879
            /* otherwise, stuffing, nothing to do */
1880
        } else {
1881
            s->mb_x += code;
1882
            break;
1883
        }
1884
    }
1885
    
1886
    s->resync_mb_x= s->mb_x;
1887
    s->resync_mb_y= s->mb_y = start_code;
1888
    s->mb_skip_run= 0;
1889

    
1890
    for(;;) {
1891
        s->dsp.clear_blocks(s->block[0]);
1892

    
1893
        ret = mpeg_decode_mb(s, s->block);
1894

    
1895
        dprintf("ret=%d\n", ret);
1896
        if (ret < 0)
1897
            return -1;
1898
            
1899
        if(s->motion_val && s->pict_type != B_TYPE){ //note motion_val is normally NULL unless we want to extract the MVs
1900
            const int wrap = s->block_wrap[0];
1901
            const int xy = s->mb_x*2 + 1 + (s->mb_y*2 +1)*wrap;
1902
            int motion_x, motion_y;
1903

    
1904
            if (s->mb_intra) {
1905
                motion_x = motion_y = 0;
1906
            }else if (s->mv_type == MV_TYPE_16X16) {
1907
                motion_x = s->mv[0][0][0];
1908
                motion_y = s->mv[0][0][1];
1909
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1910
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1911
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1912
                motion_x = (motion_x>>1) | (motion_x&1);
1913
            }
1914
            s->motion_val[xy][0] = motion_x;
1915
            s->motion_val[xy][1] = motion_y;
1916
            s->motion_val[xy + 1][0] = motion_x;
1917
            s->motion_val[xy + 1][1] = motion_y;
1918
            s->motion_val[xy + wrap][0] = motion_x;
1919
            s->motion_val[xy + wrap][1] = motion_y;
1920
            s->motion_val[xy + 1 + wrap][0] = motion_x;
1921
            s->motion_val[xy + 1 + wrap][1] = motion_y;
1922
        }
1923
        
1924
        MPV_decode_mb(s, s->block);
1925

    
1926
        if (++s->mb_x >= s->mb_width) {
1927
            if(s->picture_structure==PICT_FRAME){
1928
                ff_draw_horiz_band(s, 16*s->mb_y, 16);
1929
            }else{
1930
                if(!s->first_field){
1931
                    ff_draw_horiz_band(s, 32*s->mb_y, 32);
1932
                }
1933
            }
1934

    
1935
            s->mb_x = 0;
1936
            s->mb_y++;
1937

    
1938
            if(s->mb_y<<field_pic >= s->mb_height){
1939
                int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1940

    
1941
                if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)))
1942
                   || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
1943
                    fprintf(stderr, "end missmatch left=%d\n", left);
1944
                    return -1;
1945
                }else
1946
                    goto eos;
1947
            }
1948
        }
1949

    
1950
        /* skip mb handling */
1951
        if (s->mb_skip_run == -1) {
1952
            /* read again increment */
1953
            s->mb_skip_run = 0;
1954
            for(;;) {
1955
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1956
                if (code < 0){
1957
                    fprintf(stderr, "mb incr damaged\n");
1958
                    return -1;
1959
                }
1960
                if (code >= 33) {
1961
                    if (code == 33) {
1962
                        s->mb_skip_run += 33;
1963
                    }else if(code == 35){
1964
                        if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
1965
                            fprintf(stderr, "slice missmatch\n");
1966
                            return -1;
1967
                        }
1968
                        goto eos; /* end of slice */
1969
                    }
1970
                    /* otherwise, stuffing, nothing to do */
1971
                } else {
1972
                    s->mb_skip_run += code;
1973
                    break;
1974
                }
1975
            }
1976
        }
1977
    }
1978
eos: // end of slice
1979
    *buf += get_bits_count(&s->gb)/8 - 1;
1980
//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
1981
    return 0;
1982
}
1983

    
1984
/**
1985
 * handles slice ends.
1986
 * @return 1 if it seems to be the last slice of 
1987
 */
1988
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
1989
{
1990
    Mpeg1Context *s1 = avctx->priv_data;
1991
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1992
       
1993
    if (!s1->mpeg_enc_ctx_allocated)
1994
        return 0;
1995

    
1996
    /* end of slice reached */
1997
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
1998
        /* end of image */
1999

    
2000
        if(s->mpeg2){
2001
            s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
2002
        }else
2003
            s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG1;
2004

    
2005
        ff_er_frame_end(s);
2006

    
2007
        MPV_frame_end(s);
2008

    
2009
        if (s->pict_type == B_TYPE || s->low_delay) {
2010
            *pict= *(AVFrame*)&s->current_picture;
2011
            ff_print_debug_info(s, s->current_picture_ptr);
2012
        } else {
2013
            s->picture_number++;
2014
            /* latency of 1 frame for I and P frames */
2015
            /* XXX: use another variable than picture_number */
2016
            if (s->last_picture_ptr != NULL) {
2017
                *pict= *(AVFrame*)&s->last_picture;
2018
                 ff_print_debug_info(s, s->last_picture_ptr);
2019
            }
2020
        }
2021
        return 1;
2022
    } else {
2023
        return 0;
2024
    }
2025
}
2026

    
2027
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
2028
                                 uint8_t *buf, int buf_size)
2029
{
2030
    Mpeg1Context *s1 = avctx->priv_data;
2031
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2032
    int width, height, i, v, j;
2033
    float aspect;
2034

    
2035
    init_get_bits(&s->gb, buf, buf_size*8);
2036

    
2037
    width = get_bits(&s->gb, 12);
2038
    height = get_bits(&s->gb, 12);
2039
    s->aspect_ratio_info= get_bits(&s->gb, 4);
2040
    if(!s->mpeg2){
2041
        aspect= mpeg1_aspect[s->aspect_ratio_info];
2042
        if(aspect!=0.0) avctx->aspect_ratio= width/(aspect*height);
2043
    }
2044

    
2045
    s->frame_rate_index = get_bits(&s->gb, 4);
2046
    if (s->frame_rate_index == 0)
2047
        return -1;
2048
    s->bit_rate = get_bits(&s->gb, 18) * 400;
2049
    if (get_bits1(&s->gb) == 0) /* marker */
2050
        return -1;
2051
    if (width <= 0 || height <= 0 ||
2052
        (width % 2) != 0 || (height % 2) != 0)
2053
        return -1;
2054
    if (width != s->width ||
2055
        height != s->height) {
2056
        /* start new mpeg1 context decoding */
2057
        s->out_format = FMT_MPEG1;
2058
        if (s1->mpeg_enc_ctx_allocated) {
2059
            MPV_common_end(s);
2060
        }
2061
        s->width = width;
2062
        s->height = height;
2063
        avctx->has_b_frames= 1;
2064
        s->avctx = avctx;
2065
        avctx->width = width;
2066
        avctx->height = height;
2067
        av_reduce(
2068
            &avctx->frame_rate, 
2069
            &avctx->frame_rate_base,
2070
            frame_rate_tab[s->frame_rate_index],
2071
            MPEG1_FRAME_RATE_BASE, //FIXME store in allready reduced form 
2072
            1<<30
2073
            );
2074
        avctx->bit_rate = s->bit_rate;
2075
        
2076
        if (MPV_common_init(s) < 0)
2077
            return -1;
2078
        s1->mpeg_enc_ctx_allocated = 1;
2079
    }
2080

    
2081
    skip_bits(&s->gb, 10); /* vbv_buffer_size */
2082
    skip_bits(&s->gb, 1);
2083

    
2084
    /* get matrix */
2085
    if (get_bits1(&s->gb)) {
2086
        for(i=0;i<64;i++) {
2087
            v = get_bits(&s->gb, 8);
2088
            j = s->intra_scantable.permutated[i];
2089
            s->intra_matrix[j] = v;
2090
            s->chroma_intra_matrix[j] = v;
2091
        }
2092
#ifdef DEBUG
2093
        dprintf("intra matrix present\n");
2094
        for(i=0;i<64;i++)
2095
            dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
2096
        printf("\n");
2097
#endif
2098
    } else {
2099
        for(i=0;i<64;i++) {
2100
            int j= s->dsp.idct_permutation[i];
2101
            v = ff_mpeg1_default_intra_matrix[i];
2102
            s->intra_matrix[j] = v;
2103
            s->chroma_intra_matrix[j] = v;
2104
        }
2105
    }
2106
    if (get_bits1(&s->gb)) {
2107
        for(i=0;i<64;i++) {
2108
            v = get_bits(&s->gb, 8);
2109
            j = s->intra_scantable.permutated[i];
2110
            s->inter_matrix[j] = v;
2111
            s->chroma_inter_matrix[j] = v;
2112
        }
2113
#ifdef DEBUG
2114
        dprintf("non intra matrix present\n");
2115
        for(i=0;i<64;i++)
2116
            dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
2117
        printf("\n");
2118
#endif
2119
    } else {
2120
        for(i=0;i<64;i++) {
2121
            int j= s->dsp.idct_permutation[i];
2122
            v = ff_mpeg1_default_non_intra_matrix[i];
2123
            s->inter_matrix[j] = v;
2124
            s->chroma_inter_matrix[j] = v;
2125
        }
2126
    }
2127

    
2128
    /* we set mpeg2 parameters so that it emulates mpeg1 */
2129
    s->progressive_sequence = 1;
2130
    s->progressive_frame = 1;
2131
    s->picture_structure = PICT_FRAME;
2132
    s->frame_pred_frame_dct = 1;
2133
    s->mpeg2 = 0;
2134
    avctx->sub_id = 1; /* indicates mpeg1 */
2135
    return 0;
2136
}
2137

    
2138
static void mpeg_decode_user_data(AVCodecContext *avctx, 
2139
                                  const uint8_t *buf, int buf_size)
2140
{
2141
    const uint8_t *p;
2142
    int len, flags;
2143
    p = buf;
2144
    len = buf_size;
2145

    
2146
    /* we parse the DTG active format information */
2147
    if (len >= 5 &&
2148
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2149
        flags = p[4];
2150
        p += 5;
2151
        len -= 5;
2152
        if (flags & 0x80) {
2153
            /* skip event id */
2154
            if (len < 2)
2155
                return;
2156
            p += 2;
2157
            len -= 2;
2158
        }
2159
        if (flags & 0x40) {
2160
            if (len < 1)
2161
                return;
2162
            avctx->dtg_active_format = p[0] & 0x0f;
2163
        }
2164
    }
2165
}
2166

    
2167
/**
2168
 * finds the end of the current frame in the bitstream.
2169
 * @return the position of the first byte of the next frame, or -1
2170
 */
2171
static int mpeg1_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
2172
    ParseContext *pc= &s->parse_context;
2173
    int i;
2174
    uint32_t state;
2175
    
2176
    state= pc->state;
2177
    
2178
    i=0;
2179
    if(!pc->frame_start_found){
2180
        for(i=0; i<buf_size; i++){
2181
            state= (state<<8) | buf[i];
2182
            if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2183
                i++;
2184
                pc->frame_start_found=1;
2185
                break;
2186
            }
2187
        }
2188
    }
2189
    
2190
    if(pc->frame_start_found){
2191
        for(; i<buf_size; i++){
2192
            state= (state<<8) | buf[i];
2193
            if((state&0xFFFFFF00) == 0x100){
2194
                if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2195
                    pc->frame_start_found=0;
2196
                    pc->state=-1; 
2197
                    return i-3;
2198
                }
2199
            }
2200
        }
2201
    }        
2202
    pc->state= state;
2203
    return END_NOT_FOUND;
2204
}
2205

    
2206
/* handle buffering and image synchronisation */
2207
static int mpeg_decode_frame(AVCodecContext *avctx, 
2208
                             void *data, int *data_size,
2209
                             uint8_t *buf, int buf_size)
2210
{
2211
    Mpeg1Context *s = avctx->priv_data;
2212
    uint8_t *buf_end, *buf_ptr;
2213
    int ret, start_code, input_size;
2214
    AVFrame *picture = data;
2215
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2216
    dprintf("fill_buffer\n");
2217

    
2218
    *data_size = 0;
2219

    
2220
    /* special case for last picture */
2221
    if (buf_size == 0) {
2222
        if (s2->picture_number > 0) {
2223
            *picture= *(AVFrame*)&s2->next_picture;
2224

    
2225
            *data_size = sizeof(AVFrame);
2226
        }
2227
        return 0;
2228
    }
2229

    
2230
    if(s2->flags&CODEC_FLAG_TRUNCATED){
2231
        int next= mpeg1_find_frame_end(s2, buf, buf_size);
2232
        
2233
        if( ff_combine_frame(s2, next, &buf, &buf_size) < 0 )
2234
            return buf_size;
2235
    }    
2236
    
2237
    buf_ptr = buf;
2238
    buf_end = buf + buf_size;
2239

    
2240
#if 0    
2241
    if (s->repeat_field % 2 == 1) { 
2242
        s->repeat_field++;
2243
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2244
        //        s2->picture_number, s->repeat_field);
2245
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2246
            *data_size = sizeof(AVPicture);
2247
            goto the_end;
2248
        }
2249
    }
2250
#endif
2251
    for(;;) {
2252
        /* find start next code */
2253
        start_code = find_start_code(&buf_ptr, buf_end);
2254
        if (start_code < 0){
2255
            if (slice_end(avctx, picture)) {
2256
                if(s2->last_picture_ptr) //FIXME merge with the stuff in mpeg_decode_slice
2257
                    *data_size = sizeof(AVPicture);
2258
            }
2259
            return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2260
        }
2261
        
2262
        input_size = buf_end - buf_ptr;
2263

    
2264
        if(avctx->debug & FF_DEBUG_STARTCODE){
2265
            printf("%3X at %d left %d\n", start_code, buf_ptr-buf, input_size);
2266
        }
2267

    
2268
                /* prepare data for next start code */
2269
                switch(start_code) {
2270
                case SEQ_START_CODE:
2271
                    mpeg1_decode_sequence(avctx, buf_ptr, 
2272
                                          input_size);
2273
                    break;
2274
                            
2275
                case PICTURE_START_CODE:
2276
                    /* we have a complete image : we try to decompress it */
2277
                    mpeg1_decode_picture(avctx, 
2278
                                         buf_ptr, input_size);
2279
                    break;
2280
                case EXT_START_CODE:
2281
                    mpeg_decode_extension(avctx,
2282
                                          buf_ptr, input_size);
2283
                    break;
2284
                case USER_START_CODE:
2285
                    mpeg_decode_user_data(avctx, 
2286
                                          buf_ptr, input_size);
2287
                    break;
2288
                default:
2289
                    if (start_code >= SLICE_MIN_START_CODE &&
2290
                        start_code <= SLICE_MAX_START_CODE) {
2291
                        
2292
                        /* skip b frames if we dont have reference frames */
2293
                        if(s2->last_picture_ptr==NULL && s2->pict_type==B_TYPE) break;
2294
                        /* skip b frames if we are in a hurry */
2295
                        if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
2296
                        /* skip everything if we are in a hurry>=5 */
2297
                        if(avctx->hurry_up>=5) break;
2298
                        
2299
                        if (!s->mpeg_enc_ctx_allocated) break;
2300

    
2301
                        ret = mpeg_decode_slice(avctx, picture,
2302
                                                start_code, &buf_ptr, input_size);
2303
                        emms_c();
2304

    
2305
                        if(ret < 0){
2306
                            if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2307
                                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);
2308
                            if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
2309
                        }else{
2310
                            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);
2311
                        }
2312
                    }
2313
                    break;
2314
                }
2315
    }
2316
}
2317

    
2318
static int mpeg_decode_end(AVCodecContext *avctx)
2319
{
2320
    Mpeg1Context *s = avctx->priv_data;
2321

    
2322
    if (s->mpeg_enc_ctx_allocated)
2323
        MPV_common_end(&s->mpeg_enc_ctx);
2324
    return 0;
2325
}
2326

    
2327
AVCodec mpeg_decoder = {
2328
    "mpegvideo",
2329
    CODEC_TYPE_VIDEO,
2330
    CODEC_ID_MPEG1VIDEO,
2331
    sizeof(Mpeg1Context),
2332
    mpeg_decode_init,
2333
    NULL,
2334
    mpeg_decode_end,
2335
    mpeg_decode_frame,
2336
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2337
};