Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ 7bc9090a

History | View | Annotate | Download (78 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, 35, 
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;
856
    if (s->mpeg2) {
857
        if (s->q_scale_type) {
858
            qscale = non_linear_qscale[get_bits(&s->gb, 5)];
859
        } else {
860
            qscale = get_bits(&s->gb, 5) << 1;
861
        }
862
    } else {
863
        /* for mpeg1, we use the generic unquant code */
864
        qscale = get_bits(&s->gb, 5);
865
    }
866
    return qscale;
867
}
868

    
869
/* motion type (for mpeg2) */
870
#define MT_FIELD 1
871
#define MT_FRAME 2
872
#define MT_16X8  2
873
#define MT_DMV   3
874

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

    
882
    assert(s->mb_skiped==0);
883

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

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

    
914
            if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0) 
915
                s->mb_skiped = 1;
916
        }
917

    
918
        return 0;
919
    }
920

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

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

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

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

    
993
            if (IS_QUANT(mb_type))
994
                s->qscale = get_qscale(s);
995

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

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

    
1020
            if (IS_QUANT(mb_type))
1021
                s->qscale = get_qscale(s);
1022

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

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

    
1105
                                s->last_mv[i][0][1] = my << 1;
1106
                                s->last_mv[i][1][1] = my << 1;
1107

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

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

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

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

    
1174
    s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
1175

    
1176
    return 0;
1177
}
1178

    
1179
/* as h263, but only 17 codes */
1180
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
1181
{
1182
    int code, sign, val, m, l, shift;
1183

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

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

    
1213
static inline int decode_dc(MpegEncContext *s, int component)
1214
{
1215
    int code, diff;
1216

    
1217
    if (component == 0) {
1218
        code = get_vlc2(&s->gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1219
    } else {
1220
        code = get_vlc2(&s->gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1221
    }
1222
    if (code < 0){
1223
        fprintf(stderr, "invalid dc code at %d %d\n", s->mb_x, s->mb_y);
1224
        return 0xffff;
1225
    }
1226
    if (code == 0) {
1227
        diff = 0;
1228
    } else {
1229
        diff = get_bits(&s->gb, code);
1230
        if ((diff & (1 << (code - 1))) == 0) 
1231
            diff = (-1 << code) | (diff + 1);
1232
    }
1233
    return diff;
1234
}
1235

    
1236
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
1237
                               DCTELEM *block, 
1238
                               int n)
1239
{
1240
    int level, dc, diff, i, j, run;
1241
    int component;
1242
    RLTable *rl = &rl_mpeg1;
1243
    uint8_t * const scantable= s->intra_scantable.permutated;
1244
    const uint16_t *quant_matrix= s->intra_matrix;
1245
    const int qscale= s->qscale;
1246

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

    
1301
            block[j] = level;
1302
        }
1303
        CLOSE_READER(re, &s->gb);
1304
    }
1305
    s->block_last_index[n] = i;
1306
   return 0;
1307
}
1308

    
1309
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
1310
                               DCTELEM *block, 
1311
                               int n)
1312
{
1313
    int level, i, j, run;
1314
    RLTable *rl = &rl_mpeg1;
1315
    uint8_t * const scantable= s->intra_scantable.permutated;
1316
    const uint16_t *quant_matrix= s->inter_matrix;
1317
    const int qscale= s->qscale;
1318

    
1319
    {
1320
        int v;
1321
        OPEN_READER(re, &s->gb);
1322
        i = -1;
1323
        /* special case for the first coef. no need to add a second vlc table */
1324
        UPDATE_CACHE(re, &s->gb);
1325
        v= SHOW_UBITS(re, &s->gb, 2);
1326
        if (v & 2) {
1327
            LAST_SKIP_BITS(re, &s->gb, 2);
1328
            level= (3*qscale*quant_matrix[0])>>4;
1329
            level= (level-1)|1;
1330
            if(v&1)
1331
                level= -level;
1332
            block[0] = level;
1333
            i++;
1334
        }
1335

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

    
1377
            block[j] = level;
1378
        }
1379
        CLOSE_READER(re, &s->gb);
1380
    }
1381
    s->block_last_index[n] = i;
1382
    return 0;
1383
}
1384

    
1385
/* Also does unquantization here, since I will never support mpeg2
1386
   encoding */
1387
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1388
                               DCTELEM *block, 
1389
                               int n)
1390
{
1391
    int level, i, j, run;
1392
    RLTable *rl = &rl_mpeg1;
1393
    uint8_t * const scantable= s->intra_scantable.permutated;
1394
    const uint16_t *quant_matrix;
1395
    const int qscale= s->qscale;
1396
    int mismatch;
1397

    
1398
    mismatch = 1;
1399

    
1400
    {
1401
        int v;
1402
        OPEN_READER(re, &s->gb);
1403
        i = -1;
1404
        if (n < 4)
1405
            quant_matrix = s->inter_matrix;
1406
        else
1407
            quant_matrix = s->chroma_inter_matrix;
1408

    
1409
        /* special case for the first coef. no need to add a second vlc table */
1410
        UPDATE_CACHE(re, &s->gb);
1411
        v= SHOW_UBITS(re, &s->gb, 2);
1412
        if (v & 2) {
1413
            LAST_SKIP_BITS(re, &s->gb, 2);
1414
            level= (3*qscale*quant_matrix[0])>>5;
1415
            if(v&1)
1416
                level= -level;
1417
            block[0] = level;
1418
            mismatch ^= level;
1419
            i++;
1420
        }
1421

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

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

    
1466
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
1467
                               DCTELEM *block, 
1468
                               int n)
1469
{
1470
    int level, dc, diff, i, j, run;
1471
    int component;
1472
    RLTable *rl;
1473
    uint8_t * const scantable= s->intra_scantable.permutated;
1474
    const uint16_t *quant_matrix;
1475
    const int qscale= s->qscale;
1476
    int mismatch;
1477

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

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

    
1546
/* compressed picture size */
1547
#define PICTURE_BUFFER_SIZE 100000
1548

    
1549
typedef struct Mpeg1Context {
1550
    MpegEncContext mpeg_enc_ctx;
1551
    uint32_t header_state;
1552
    int start_code; /* current start code */
1553
    uint8_t buffer[PICTURE_BUFFER_SIZE]; 
1554
    uint8_t *buf_ptr;
1555
    int buffer_size;
1556
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1557
    int repeat_field; /* true if we must repeat the field */
1558
} Mpeg1Context;
1559

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

    
1568
    s->header_state = 0xff;
1569
    s->mpeg_enc_ctx_allocated = 0;
1570
    s->buffer_size = PICTURE_BUFFER_SIZE;
1571
    s->start_code = -1;
1572
    s->buf_ptr = s->buffer;
1573
    s->mpeg_enc_ctx.picture_number = 0;
1574
    s->repeat_field = 0;
1575
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1576
    return 0;
1577
}
1578

    
1579
/* return the 8 bit start code value and update the search
1580
   state. Return -1 if no start code found */
1581
static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end, 
1582
                           uint32_t *header_state)
1583
{
1584
    uint8_t *buf_ptr;
1585
    unsigned int state, v;
1586
    int val;
1587

    
1588
    state = *header_state;
1589
    buf_ptr = *pbuf_ptr;
1590
    while (buf_ptr < buf_end) {
1591
        v = *buf_ptr++;
1592
        if (state == 0x000001) {
1593
            state = ((state << 8) | v) & 0xffffff;
1594
            val = state;
1595
            goto found;
1596
        }
1597
        state = ((state << 8) | v) & 0xffffff;
1598
    }
1599
    val = -1;
1600
 found:
1601
    *pbuf_ptr = buf_ptr;
1602
    *header_state = state;
1603
    return val;
1604
}
1605

    
1606
static int mpeg1_decode_picture(AVCodecContext *avctx, 
1607
                                uint8_t *buf, int buf_size)
1608
{
1609
    Mpeg1Context *s1 = avctx->priv_data;
1610
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1611
    int ref, f_code;
1612

    
1613
    init_get_bits(&s->gb, buf, buf_size*8);
1614

    
1615
    ref = get_bits(&s->gb, 10); /* temporal ref */
1616
    s->pict_type = get_bits(&s->gb, 3);
1617
    dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number);
1618

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

    
1645
static void mpeg_decode_sequence_extension(MpegEncContext *s)
1646
{
1647
    int horiz_size_ext, vert_size_ext;
1648
    int bit_rate_ext, vbv_buf_ext;
1649
    int frame_rate_ext_n, frame_rate_ext_d;
1650
    float aspect;
1651

    
1652
    skip_bits(&s->gb, 8); /* profil and level */
1653
    s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1654
    skip_bits(&s->gb, 2); /* chroma_format */
1655
    horiz_size_ext = get_bits(&s->gb, 2);
1656
    vert_size_ext = get_bits(&s->gb, 2);
1657
    s->width |= (horiz_size_ext << 12);
1658
    s->height |= (vert_size_ext << 12);
1659
    bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1660
    s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
1661
    skip_bits1(&s->gb); /* marker */
1662
    vbv_buf_ext = get_bits(&s->gb, 8);
1663
    s->low_delay = get_bits1(&s->gb);
1664
    frame_rate_ext_n = get_bits(&s->gb, 2);
1665
    frame_rate_ext_d = get_bits(&s->gb, 5);
1666
    av_reduce(
1667
        &s->avctx->frame_rate, 
1668
        &s->avctx->frame_rate_base, 
1669
        frame_rate_tab[s->frame_rate_index] * (frame_rate_ext_n+1),
1670
        MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d+1),
1671
        1<<30);
1672

    
1673
    dprintf("sequence extension\n");
1674
    s->mpeg2 = 1;
1675
    s->avctx->sub_id = 2; /* indicates mpeg2 found */
1676

    
1677
    aspect= mpeg2_aspect[s->aspect_ratio_info];
1678
    if(aspect>0.0)      s->avctx->aspect_ratio= s->width/(aspect*s->height);
1679
    else if(aspect<0.0) s->avctx->aspect_ratio= -1.0/aspect;
1680
}
1681

    
1682
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1683
{
1684
    int i, v, j;
1685

    
1686
    dprintf("matrix extension\n");
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->intra_matrix[j] = v;
1693
            s->chroma_intra_matrix[j] = v;
1694
        }
1695
    }
1696
    if (get_bits1(&s->gb)) {
1697
        for(i=0;i<64;i++) {
1698
            v = get_bits(&s->gb, 8);
1699
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1700
            s->inter_matrix[j] = v;
1701
            s->chroma_inter_matrix[j] = v;
1702
        }
1703
    }
1704
    if (get_bits1(&s->gb)) {
1705
        for(i=0;i<64;i++) {
1706
            v = get_bits(&s->gb, 8);
1707
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1708
            s->chroma_intra_matrix[j] = v;
1709
        }
1710
    }
1711
    if (get_bits1(&s->gb)) {
1712
        for(i=0;i<64;i++) {
1713
            v = get_bits(&s->gb, 8);
1714
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1715
            s->chroma_inter_matrix[j] = v;
1716
        }
1717
    }
1718
}
1719

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

    
1770
static void mpeg_decode_extension(AVCodecContext *avctx, 
1771
                                  uint8_t *buf, int buf_size)
1772
{
1773
    Mpeg1Context *s1 = avctx->priv_data;
1774
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1775
    int ext_type;
1776

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

    
1796
#define DECODE_SLICE_MB_ADDR_ERROR -3 //we faild decoding the mb_x/y info
1797
#define DECODE_SLICE_FATAL_ERROR -2
1798
#define DECODE_SLICE_ERROR -1
1799
#define DECODE_SLICE_OK 0
1800
#define DECODE_SLICE_EOP 1
1801

    
1802
/**
1803
 * decodes a slice.
1804
 * @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br>
1805
 *         DECODE_SLICE_ERROR if the slice is damaged<br>
1806
 *         DECODE_SLICE_OK if this slice is ok<br>
1807
 *         DECODE_SLICE_EOP if the end of the picture is reached
1808
 */
1809
static int mpeg_decode_slice(AVCodecContext *avctx, 
1810
                              AVFrame *pict,
1811
                              int start_code,
1812
                              uint8_t *buf, int buf_size)
1813
{
1814
    Mpeg1Context *s1 = avctx->priv_data;
1815
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1816
    int ret;
1817
    const int field_pic= s->picture_structure != PICT_FRAME;
1818

    
1819
    start_code = (start_code - 1) & 0xff;
1820
    if (start_code >= s->mb_height){
1821
        fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);
1822
        return DECODE_SLICE_MB_ADDR_ERROR;
1823
    }
1824
    
1825
    ff_mpeg1_clean_buffers(s);
1826
    s->interlaced_dct = 0;
1827
        
1828
    /* start frame decoding */
1829
    if (s->first_slice) {
1830
      if(s->first_field || s->picture_structure==PICT_FRAME){
1831
        if(MPV_frame_start(s, avctx) < 0)
1832
            return DECODE_SLICE_FATAL_ERROR;
1833

    
1834
        ff_er_frame_start(s);
1835

    
1836
        /* first check if we must repeat the frame */
1837
        s->current_picture.repeat_pict = 0;
1838

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

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

    
1871
    init_get_bits(&s->gb, buf, buf_size*8);
1872

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

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

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

    
1910
        ret = mpeg_decode_mb(s, s->block);
1911

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

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

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

    
1951
            s->mb_x = 0;
1952
            s->mb_y++;
1953
        }
1954

    
1955
        /* skip mb handling */
1956
        if (s->mb_skip_run == -1) {
1957
            /* read again increment */
1958
            s->mb_skip_run = 0;
1959
            for(;;) {
1960
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1961
                if (code < 0){
1962
                    align_get_bits(&s->gb);
1963
                    if(s->mb_skip_run != 0 || show_bits(&s->gb, 24) != 1){
1964
                        fprintf(stderr, "slice end missmatch\n");
1965
                        return -1;
1966
                    }
1967
                    goto eos; /* error = end of slice */
1968
                }
1969
                if (code >= 33) {
1970
                    if (code == 33) {
1971
                        s->mb_skip_run += 33;
1972
                    }
1973
                    /* otherwise, stuffing, nothing to do */
1974
                } else {
1975
                    s->mb_skip_run += code;
1976
                    break;
1977
                }
1978
            }
1979
        }
1980
        if(s->mb_y<<field_pic >= s->mb_height){
1981
            fprintf(stderr, "slice too long\n");
1982
            return DECODE_SLICE_ERROR;
1983
        }
1984
    }
1985
eos: //end of slice
1986
//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
1987
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
1988

    
1989
    emms_c();
1990
    
1991
//intf("%d %d %d %d\n", s->mb_y, s->mb_height, s->pict_type, s->picture_number);
1992
    /* end of slice reached */
1993
    if (s->mb_y<<field_pic == s->mb_height && !s->first_field) {
1994
        /* end of image */
1995

    
1996
        if(s->mpeg2)
1997
            s->qscale >>=1;
1998
        ff_er_frame_end(s);
1999

    
2000
        MPV_frame_end(s);
2001

    
2002
        if (s->pict_type == B_TYPE || s->low_delay) {
2003
            *pict= *(AVFrame*)&s->current_picture;
2004
            ff_print_debug_info(s, s->current_picture_ptr);
2005
        } else {
2006
            s->picture_number++;
2007
            /* latency of 1 frame for I and P frames */
2008
            /* XXX: use another variable than picture_number */
2009
            if (s->last_picture_ptr == NULL) {
2010
                return DECODE_SLICE_OK;
2011
            } else {
2012
                *pict= *(AVFrame*)&s->last_picture;
2013
                 ff_print_debug_info(s, s->last_picture_ptr);
2014
            }
2015
        }
2016
        return DECODE_SLICE_EOP;
2017
    } else {
2018
        return DECODE_SLICE_OK;
2019
    }
2020
}
2021

    
2022
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
2023
                                 uint8_t *buf, int buf_size)
2024
{
2025
    Mpeg1Context *s1 = avctx->priv_data;
2026
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2027
    int width, height, i, v, j;
2028
    float aspect;
2029

    
2030
    init_get_bits(&s->gb, buf, buf_size*8);
2031

    
2032
    width = get_bits(&s->gb, 12);
2033
    height = get_bits(&s->gb, 12);
2034
    s->aspect_ratio_info= get_bits(&s->gb, 4);
2035
    if(!s->mpeg2){
2036
        aspect= mpeg1_aspect[s->aspect_ratio_info];
2037
        if(aspect!=0.0) avctx->aspect_ratio= width/(aspect*height);
2038
    }
2039

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

    
2076
    skip_bits(&s->gb, 10); /* vbv_buffer_size */
2077
    skip_bits(&s->gb, 1);
2078

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

    
2123
    /* we set mpeg2 parameters so that it emulates mpeg1 */
2124
    s->progressive_sequence = 1;
2125
    s->progressive_frame = 1;
2126
    s->picture_structure = PICT_FRAME;
2127
    s->frame_pred_frame_dct = 1;
2128
    s->mpeg2 = 0;
2129
    avctx->sub_id = 1; /* indicates mpeg1 */
2130
    return 0;
2131
}
2132

    
2133
static void mpeg_decode_user_data(AVCodecContext *avctx, 
2134
                                  const uint8_t *buf, int buf_size)
2135
{
2136
    const uint8_t *p;
2137
    int len, flags;
2138
    p = buf;
2139
    len = buf_size;
2140

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

    
2162
/* handle buffering and image synchronisation */
2163
static int mpeg_decode_frame(AVCodecContext *avctx, 
2164
                             void *data, int *data_size,
2165
                             uint8_t *buf, int buf_size)
2166
{
2167
    Mpeg1Context *s = avctx->priv_data;
2168
    uint8_t *buf_end, *buf_ptr, *buf_start;
2169
    int len, start_code_found, ret, code, start_code, input_size;
2170
    AVFrame *picture = data;
2171
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2172
            
2173
    dprintf("fill_buffer\n");
2174

    
2175
    *data_size = 0;
2176

    
2177
    /* special case for last picture */
2178
    if (buf_size == 0) {
2179
        if (s2->picture_number > 0) {
2180
            *picture= *(AVFrame*)&s2->next_picture;
2181

    
2182
            *data_size = sizeof(AVFrame);
2183
        }
2184
        return 0;
2185
    }
2186

    
2187
    buf_ptr = buf;
2188
    buf_end = buf + buf_size;
2189

    
2190
#if 0    
2191
    if (s->repeat_field % 2 == 1) { 
2192
        s->repeat_field++;
2193
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2194
        //        s2->picture_number, s->repeat_field);
2195
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2196
            *data_size = sizeof(AVPicture);
2197
            goto the_end;
2198
        }
2199
    }
2200
#endif
2201
    while (buf_ptr < buf_end) {
2202
        buf_start = buf_ptr;
2203
        /* find start next code */
2204
        code = find_start_code(&buf_ptr, buf_end, &s->header_state);
2205
        if (code >= 0) {
2206
            start_code_found = 1;
2207
        } else {
2208
            start_code_found = 0;
2209
        }
2210
        /* copy to buffer */
2211
        len = buf_ptr - buf_start;
2212
        if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
2213
            /* data too big : flush */
2214
            s->buf_ptr = s->buffer;
2215
            if (start_code_found)
2216
                s->start_code = code;
2217
        } else {
2218
            memcpy(s->buf_ptr, buf_start, len);
2219
            s->buf_ptr += len;
2220
            if(   (!(s2->flags&CODEC_FLAG_TRUNCATED)) && (!start_code_found) 
2221
               && s->buf_ptr+4<s->buffer+s->buffer_size){
2222
                start_code_found= 1;
2223
                code= 0x1FF;
2224
                s->header_state=0xFF;
2225
                s->buf_ptr[0]=0;
2226
                s->buf_ptr[1]=0;
2227
                s->buf_ptr[2]=1;
2228
                s->buf_ptr[3]=0xFF;
2229
                s->buf_ptr+=4;
2230
            }
2231
            if (start_code_found) {
2232
                /* prepare data for next start code */
2233
                input_size = s->buf_ptr - s->buffer;
2234
                start_code = s->start_code;
2235
                s->buf_ptr = s->buffer;
2236
                s->start_code = code;
2237
                switch(start_code) {
2238
                case SEQ_START_CODE:
2239
                    mpeg1_decode_sequence(avctx, s->buffer, 
2240
                                          input_size);
2241
                    break;
2242
                            
2243
                case PICTURE_START_CODE:
2244
                    /* we have a complete image : we try to decompress it */
2245
                    mpeg1_decode_picture(avctx, 
2246
                                         s->buffer, input_size);
2247
                    break;
2248
                case EXT_START_CODE:
2249
                    mpeg_decode_extension(avctx,
2250
                                          s->buffer, input_size);
2251
                    break;
2252
                case USER_START_CODE:
2253
                    mpeg_decode_user_data(avctx, 
2254
                                          s->buffer, input_size);
2255
                    break;
2256
                default:
2257
                    if (start_code >= SLICE_MIN_START_CODE &&
2258
                        start_code <= SLICE_MAX_START_CODE) {
2259
                        
2260
                        /* skip b frames if we dont have reference frames */
2261
                        if(s2->last_picture_ptr==NULL && s2->pict_type==B_TYPE) break;
2262
                        /* skip b frames if we are in a hurry */
2263
                        if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
2264
                        /* skip everything if we are in a hurry>=5 */
2265
                        if(avctx->hurry_up>=5) break;
2266

    
2267
                        ret = mpeg_decode_slice(avctx, picture,
2268
                                                start_code, s->buffer, input_size);
2269

    
2270
                        if (ret == DECODE_SLICE_EOP) {
2271
                            *data_size = sizeof(AVPicture);
2272
                            goto the_end;
2273
                        }else if(ret < 0){
2274
                            if(ret == DECODE_SLICE_ERROR)
2275
                                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);
2276
                                
2277
                            fprintf(stderr,"Error while decoding slice\n");
2278
                            if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
2279
                        }
2280
                    }
2281
                    break;
2282
                }
2283
            }
2284
        }
2285
    }
2286
 the_end:
2287
    return buf_ptr - buf;
2288
}
2289

    
2290
static int mpeg_decode_end(AVCodecContext *avctx)
2291
{
2292
    Mpeg1Context *s = avctx->priv_data;
2293

    
2294
    if (s->mpeg_enc_ctx_allocated)
2295
        MPV_common_end(&s->mpeg_enc_ctx);
2296
    return 0;
2297
}
2298

    
2299
AVCodec mpeg_decoder = {
2300
    "mpegvideo",
2301
    CODEC_TYPE_VIDEO,
2302
    CODEC_ID_MPEG1VIDEO,
2303
    sizeof(Mpeg1Context),
2304
    mpeg_decode_init,
2305
    NULL,
2306
    mpeg_decode_end,
2307
    mpeg_decode_frame,
2308
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2309
};