Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ 04b502fa

History | View | Annotate | Download (82 KB)

1
/*
2
 * MPEG1/2 decoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22

    
23
/**
24
 * @file mpeg12.c
25
 * MPEG1/2 decoder
26
 */
27

    
28
//#define DEBUG
29
#include "avcodec.h"
30
#include "dsputil.h"
31
#include "mpegvideo.h"
32

    
33
#include "mpeg12.h"
34
#include "mpeg12data.h"
35
#include "mpeg12decdata.h"
36
#include "bytestream.h"
37

    
38
//#undef NDEBUG
39
//#include <assert.h>
40

    
41

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

    
50
static inline int mpeg1_decode_block_inter(MpegEncContext *s,
51
                              DCTELEM *block,
52
                              int n);
53
static inline int mpeg1_decode_block_intra(MpegEncContext *s,
54
                              DCTELEM *block,
55
                              int n);
56
static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n);
57
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
58
                                        DCTELEM *block,
59
                                        int n);
60
static inline int mpeg2_decode_block_intra(MpegEncContext *s,
61
                                    DCTELEM *block,
62
                                    int n);
63
static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, DCTELEM *block, int n);
64
static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, DCTELEM *block, int n);
65
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
66
static void exchange_uv(MpegEncContext *s);
67

    
68
extern int XVMC_field_start(MpegEncContext *s, AVCodecContext *avctx);
69
extern int XVMC_field_end(MpegEncContext *s);
70
extern void XVMC_pack_pblocks(MpegEncContext *s,int cbp);
71
extern void XVMC_init_block(MpegEncContext *s);//set s->block
72

    
73
static const enum PixelFormat pixfmt_yuv_420[]= {PIX_FMT_YUV420P,-1};
74
static const enum PixelFormat pixfmt_yuv_422[]= {PIX_FMT_YUV422P,-1};
75
static const enum PixelFormat pixfmt_yuv_444[]= {PIX_FMT_YUV444P,-1};
76
static const enum PixelFormat pixfmt_xvmc_mpg2_420[] = {
77
                                           PIX_FMT_XVMC_MPEG2_IDCT,
78
                                           PIX_FMT_XVMC_MPEG2_MC,
79
                                           -1};
80

    
81
uint8_t ff_mpeg12_static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3];
82

    
83
static void init_2d_vlc_rl(RLTable *rl, int use_static)
84
{
85
    int i;
86

    
87
    init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2,
88
             &rl->table_vlc[0][1], 4, 2,
89
             &rl->table_vlc[0][0], 4, 2, use_static);
90

    
91
    if(use_static)
92
        rl->rl_vlc[0]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
93
    else
94
        rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
95

    
96
    for(i=0; i<rl->vlc.table_size; i++){
97
        int code= rl->vlc.table[i][0];
98
        int len = rl->vlc.table[i][1];
99
        int level, run;
100

    
101
        if(len==0){ // illegal code
102
            run= 65;
103
            level= MAX_LEVEL;
104
        }else if(len<0){ //more bits needed
105
            run= 0;
106
            level= code;
107
        }else{
108
            if(code==rl->n){ //esc
109
                run= 65;
110
                level= 0;
111
            }else if(code==rl->n+1){ //eob
112
                run= 0;
113
                level= 127;
114
            }else{
115
                run=   rl->table_run  [code] + 1;
116
                level= rl->table_level[code];
117
            }
118
        }
119
        rl->rl_vlc[0][i].len= len;
120
        rl->rl_vlc[0][i].level= level;
121
        rl->rl_vlc[0][i].run= run;
122
    }
123
}
124

    
125
void ff_mpeg12_common_init(MpegEncContext *s)
126
{
127

    
128
    s->y_dc_scale_table=
129
    s->c_dc_scale_table= mpeg2_dc_scale_table[s->intra_dc_precision];
130

    
131
}
132

    
133
void ff_mpeg1_clean_buffers(MpegEncContext *s){
134
    s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
135
    s->last_dc[1] = s->last_dc[0];
136
    s->last_dc[2] = s->last_dc[0];
137
    memset(s->last_mv, 0, sizeof(s->last_mv));
138
}
139

    
140

    
141
/******************************************/
142
/* decoding */
143

    
144
static VLC dc_lum_vlc;
145
static VLC dc_chroma_vlc;
146
static VLC mv_vlc;
147
static VLC mbincr_vlc;
148
static VLC mb_ptype_vlc;
149
static VLC mb_btype_vlc;
150
static VLC mb_pat_vlc;
151

    
152
static void init_vlcs(void)
153
{
154
    static int done = 0;
155

    
156
    if (!done) {
157
        done = 1;
158

    
159
        init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12,
160
                 ff_mpeg12_vlc_dc_lum_bits, 1, 1,
161
                 ff_mpeg12_vlc_dc_lum_code, 2, 2, 1);
162
        init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12,
163
                 ff_mpeg12_vlc_dc_chroma_bits, 1, 1,
164
                 ff_mpeg12_vlc_dc_chroma_code, 2, 2, 1);
165
        init_vlc(&mv_vlc, MV_VLC_BITS, 17,
166
                 &ff_mpeg12_mbMotionVectorTable[0][1], 2, 1,
167
                 &ff_mpeg12_mbMotionVectorTable[0][0], 2, 1, 1);
168
        init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36,
169
                 &ff_mpeg12_mbAddrIncrTable[0][1], 2, 1,
170
                 &ff_mpeg12_mbAddrIncrTable[0][0], 2, 1, 1);
171
        init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 64,
172
                 &ff_mpeg12_mbPatTable[0][1], 2, 1,
173
                 &ff_mpeg12_mbPatTable[0][0], 2, 1, 1);
174

    
175
        init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7,
176
                 &table_mb_ptype[0][1], 2, 1,
177
                 &table_mb_ptype[0][0], 2, 1, 1);
178
        init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11,
179
                 &table_mb_btype[0][1], 2, 1,
180
                 &table_mb_btype[0][0], 2, 1, 1);
181
        init_rl(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]);
182
        init_rl(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]);
183

    
184
        init_2d_vlc_rl(&ff_rl_mpeg1, 1);
185
        init_2d_vlc_rl(&ff_rl_mpeg2, 1);
186
    }
187
}
188

    
189
static inline int get_dmv(MpegEncContext *s)
190
{
191
    if(get_bits1(&s->gb))
192
        return 1 - (get_bits1(&s->gb) << 1);
193
    else
194
        return 0;
195
}
196

    
197
static inline int get_qscale(MpegEncContext *s)
198
{
199
    int qscale = get_bits(&s->gb, 5);
200
    if (s->q_scale_type) {
201
        return non_linear_qscale[qscale];
202
    } else {
203
        return qscale << 1;
204
    }
205
}
206

    
207
/* motion type (for mpeg2) */
208
#define MT_FIELD 1
209
#define MT_FRAME 2
210
#define MT_16X8  2
211
#define MT_DMV   3
212

    
213
static int mpeg_decode_mb(MpegEncContext *s,
214
                          DCTELEM block[12][64])
215
{
216
    int i, j, k, cbp, val, mb_type, motion_type;
217
    const int mb_block_count = 4 + (1<< s->chroma_format);
218

    
219
    dprintf(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
220

    
221
    assert(s->mb_skipped==0);
222

    
223
    if (s->mb_skip_run-- != 0) {
224
        if (s->pict_type == P_TYPE) {
225
            s->mb_skipped = 1;
226
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
227
        } else {
228
            int mb_type;
229

    
230
            if(s->mb_x)
231
                mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1];
232
            else
233
                mb_type= s->current_picture.mb_type[ s->mb_width + (s->mb_y-1)*s->mb_stride - 1]; // FIXME not sure if this is allowed in mpeg at all,
234
            if(IS_INTRA(mb_type))
235
                return -1;
236

    
237
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]=
238
                mb_type | MB_TYPE_SKIP;
239
//            assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
240

    
241
            if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0)
242
                s->mb_skipped = 1;
243
        }
244

    
245
        return 0;
246
    }
247

    
248
    switch(s->pict_type) {
249
    default:
250
    case I_TYPE:
251
        if (get_bits1(&s->gb) == 0) {
252
            if (get_bits1(&s->gb) == 0){
253
                av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
254
                return -1;
255
            }
256
            mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
257
        } else {
258
            mb_type = MB_TYPE_INTRA;
259
        }
260
        break;
261
    case P_TYPE:
262
        mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
263
        if (mb_type < 0){
264
            av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
265
            return -1;
266
        }
267
        mb_type = ptype2mb_type[ mb_type ];
268
        break;
269
    case B_TYPE:
270
        mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
271
        if (mb_type < 0){
272
            av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
273
            return -1;
274
        }
275
        mb_type = btype2mb_type[ mb_type ];
276
        break;
277
    }
278
    dprintf(s->avctx, "mb_type=%x\n", mb_type);
279
//    motion_type = 0; /* avoid warning */
280
    if (IS_INTRA(mb_type)) {
281
        s->dsp.clear_blocks(s->block[0]);
282

    
283
        if(!s->chroma_y_shift){
284
            s->dsp.clear_blocks(s->block[6]);
285
        }
286

    
287
        /* compute dct type */
288
        if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
289
            !s->frame_pred_frame_dct) {
290
            s->interlaced_dct = get_bits1(&s->gb);
291
        }
292

    
293
        if (IS_QUANT(mb_type))
294
            s->qscale = get_qscale(s);
295

    
296
        if (s->concealment_motion_vectors) {
297
            /* just parse them */
298
            if (s->picture_structure != PICT_FRAME)
299
                skip_bits1(&s->gb); /* field select */
300

    
301
            s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
302
                mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
303
            s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
304
                mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
305

    
306
            skip_bits1(&s->gb); /* marker */
307
        }else
308
            memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
309
        s->mb_intra = 1;
310
#ifdef HAVE_XVMC
311
        //one 1 we memcpy blocks in xvmcvideo
312
        if(s->avctx->xvmc_acceleration > 1){
313
            XVMC_pack_pblocks(s,-1);//inter are always full blocks
314
            if(s->swap_uv){
315
                exchange_uv(s);
316
            }
317
        }
318
#endif
319

    
320
        if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
321
            if(s->flags2 & CODEC_FLAG2_FAST){
322
                for(i=0;i<6;i++) {
323
                    mpeg2_fast_decode_block_intra(s, s->pblocks[i], i);
324
                }
325
            }else{
326
                for(i=0;i<mb_block_count;i++) {
327
                    if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0)
328
                        return -1;
329
                }
330
            }
331
        } else {
332
            for(i=0;i<6;i++) {
333
                if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 0)
334
                    return -1;
335
            }
336
        }
337
    } else {
338
        if (mb_type & MB_TYPE_ZERO_MV){
339
            assert(mb_type & MB_TYPE_CBP);
340

    
341
            s->mv_dir = MV_DIR_FORWARD;
342
            if(s->picture_structure == PICT_FRAME){
343
                if(!s->frame_pred_frame_dct)
344
                    s->interlaced_dct = get_bits1(&s->gb);
345
                s->mv_type = MV_TYPE_16X16;
346
            }else{
347
                s->mv_type = MV_TYPE_FIELD;
348
                mb_type |= MB_TYPE_INTERLACED;
349
                s->field_select[0][0]= s->picture_structure - 1;
350
            }
351

    
352
            if (IS_QUANT(mb_type))
353
                s->qscale = get_qscale(s);
354

    
355
            s->last_mv[0][0][0] = 0;
356
            s->last_mv[0][0][1] = 0;
357
            s->last_mv[0][1][0] = 0;
358
            s->last_mv[0][1][1] = 0;
359
            s->mv[0][0][0] = 0;
360
            s->mv[0][0][1] = 0;
361
        }else{
362
            assert(mb_type & MB_TYPE_L0L1);
363
//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
364
            /* get additional motion vector type */
365
            if (s->frame_pred_frame_dct)
366
                motion_type = MT_FRAME;
367
            else{
368
                motion_type = get_bits(&s->gb, 2);
369
                if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
370
                    s->interlaced_dct = get_bits1(&s->gb);
371
            }
372

    
373
            if (IS_QUANT(mb_type))
374
                s->qscale = get_qscale(s);
375

    
376
            /* motion vectors */
377
            s->mv_dir = 0;
378
            dprintf(s->avctx, "motion_type=%d\n", motion_type);
379
            switch(motion_type) {
380
            case MT_FRAME: /* or MT_16X8 */
381
                if (s->picture_structure == PICT_FRAME) {
382
                    mb_type |= MB_TYPE_16x16;
383
                    s->mv_type = MV_TYPE_16X16;
384
                    for(i=0;i<2;i++) {
385
                        if (USES_LIST(mb_type, i)) {
386
                            s->mv_dir |= (MV_DIR_FORWARD >> i);
387
                            /* MT_FRAME */
388
                            s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] =
389
                                mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
390
                            s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] =
391
                                mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
392
                            /* full_pel: only for mpeg1 */
393
                            if (s->full_pel[i]){
394
                                s->mv[i][0][0] <<= 1;
395
                                s->mv[i][0][1] <<= 1;
396
                            }
397
                        }
398
                    }
399
                } else {
400
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
401
                    s->mv_type = MV_TYPE_16X8;
402
                    for(i=0;i<2;i++) {
403
                        if (USES_LIST(mb_type, i)) {
404
                            s->mv_dir |= (MV_DIR_FORWARD >> i);
405
                            /* MT_16X8 */
406
                            for(j=0;j<2;j++) {
407
                                s->field_select[i][j] = get_bits1(&s->gb);
408
                                for(k=0;k<2;k++) {
409
                                    val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
410
                                                             s->last_mv[i][j][k]);
411
                                    s->last_mv[i][j][k] = val;
412
                                    s->mv[i][j][k] = val;
413
                                }
414
                            }
415
                        }
416
                    }
417
                }
418
                break;
419
            case MT_FIELD:
420
                s->mv_type = MV_TYPE_FIELD;
421
                if (s->picture_structure == PICT_FRAME) {
422
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
423
                    for(i=0;i<2;i++) {
424
                        if (USES_LIST(mb_type, i)) {
425
                            s->mv_dir |= (MV_DIR_FORWARD >> i);
426
                            for(j=0;j<2;j++) {
427
                                s->field_select[i][j] = get_bits1(&s->gb);
428
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
429
                                                         s->last_mv[i][j][0]);
430
                                s->last_mv[i][j][0] = val;
431
                                s->mv[i][j][0] = val;
432
                                dprintf(s->avctx, "fmx=%d\n", val);
433
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
434
                                                         s->last_mv[i][j][1] >> 1);
435
                                s->last_mv[i][j][1] = val << 1;
436
                                s->mv[i][j][1] = val;
437
                                dprintf(s->avctx, "fmy=%d\n", val);
438
                            }
439
                        }
440
                    }
441
                } else {
442
                    mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
443
                    for(i=0;i<2;i++) {
444
                        if (USES_LIST(mb_type, i)) {
445
                            s->mv_dir |= (MV_DIR_FORWARD >> i);
446
                            s->field_select[i][0] = get_bits1(&s->gb);
447
                            for(k=0;k<2;k++) {
448
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
449
                                                         s->last_mv[i][0][k]);
450
                                s->last_mv[i][0][k] = val;
451
                                s->last_mv[i][1][k] = val;
452
                                s->mv[i][0][k] = val;
453
                            }
454
                        }
455
                    }
456
                }
457
                break;
458
            case MT_DMV:
459
                s->mv_type = MV_TYPE_DMV;
460
                for(i=0;i<2;i++) {
461
                    if (USES_LIST(mb_type, i)) {
462
                        int dmx, dmy, mx, my, m;
463
                        s->mv_dir |= (MV_DIR_FORWARD >> i);
464
                        mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
465
                                                s->last_mv[i][0][0]);
466
                        s->last_mv[i][0][0] = mx;
467
                        s->last_mv[i][1][0] = mx;
468
                        dmx = get_dmv(s);
469
                        my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
470
                                                s->last_mv[i][0][1] >> 1);
471
                        dmy = get_dmv(s);
472

    
473

    
474
                        s->last_mv[i][0][1] = my<<1;
475
                        s->last_mv[i][1][1] = my<<1;
476

    
477
                        s->mv[i][0][0] = mx;
478
                        s->mv[i][0][1] = my;
479
                        s->mv[i][1][0] = mx;//not used
480
                        s->mv[i][1][1] = my;//not used
481

    
482
                        if (s->picture_structure == PICT_FRAME) {
483
                            mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
484

    
485
                            //m = 1 + 2 * s->top_field_first;
486
                            m = s->top_field_first ? 1 : 3;
487

    
488
                            /* top -> top pred */
489
                            s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
490
                            s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
491
                            m = 4 - m;
492
                            s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
493
                            s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
494
                        } else {
495
                            mb_type |= MB_TYPE_16x16;
496

    
497
                            s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
498
                            s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
499
                            if(s->picture_structure == PICT_TOP_FIELD)
500
                                s->mv[i][2][1]--;
501
                            else
502
                                s->mv[i][2][1]++;
503
                        }
504
                    }
505
                }
506
                break;
507
            default:
508
                av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
509
                return -1;
510
            }
511
        }
512

    
513
        s->mb_intra = 0;
514
        if (HAS_CBP(mb_type)) {
515
            s->dsp.clear_blocks(s->block[0]);
516

    
517
            cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
518
            if(mb_block_count > 6){
519
                 cbp<<= mb_block_count-6;
520
                 cbp |= get_bits(&s->gb, mb_block_count-6);
521
                 s->dsp.clear_blocks(s->block[6]);
522
            }
523
            if (cbp <= 0){
524
                av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
525
                return -1;
526
            }
527

    
528
#ifdef HAVE_XVMC
529
            //on 1 we memcpy blocks in xvmcvideo
530
            if(s->avctx->xvmc_acceleration > 1){
531
                XVMC_pack_pblocks(s,cbp);
532
                if(s->swap_uv){
533
                    exchange_uv(s);
534
                }
535
            }
536
#endif
537

    
538
            if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
539
                if(s->flags2 & CODEC_FLAG2_FAST){
540
                    for(i=0;i<6;i++) {
541
                        if(cbp & 32) {
542
                            mpeg2_fast_decode_block_non_intra(s, s->pblocks[i], i);
543
                        } else {
544
                            s->block_last_index[i] = -1;
545
                        }
546
                        cbp+=cbp;
547
                    }
548
                }else{
549
                    cbp<<= 12-mb_block_count;
550

    
551
                    for(i=0;i<mb_block_count;i++) {
552
                        if ( cbp & (1<<11) ) {
553
                            if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
554
                                return -1;
555
                        } else {
556
                            s->block_last_index[i] = -1;
557
                        }
558
                        cbp+=cbp;
559
                    }
560
                }
561
            } else {
562
                if(s->flags2 & CODEC_FLAG2_FAST){
563
                    for(i=0;i<6;i++) {
564
                        if (cbp & 32) {
565
                            mpeg1_fast_decode_block_inter(s, s->pblocks[i], i);
566
                        } else {
567
                            s->block_last_index[i] = -1;
568
                        }
569
                        cbp+=cbp;
570
                    }
571
                }else{
572
                    for(i=0;i<6;i++) {
573
                        if (cbp & 32) {
574
                            if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 0)
575
                                return -1;
576
                        } else {
577
                            s->block_last_index[i] = -1;
578
                        }
579
                        cbp+=cbp;
580
                    }
581
                }
582
            }
583
        }else{
584
            for(i=0;i<12;i++)
585
                s->block_last_index[i] = -1;
586
        }
587
    }
588

    
589
    s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
590

    
591
    return 0;
592
}
593

    
594
/* as h263, but only 17 codes */
595
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
596
{
597
    int code, sign, val, l, shift;
598

    
599
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
600
    if (code == 0) {
601
        return pred;
602
    }
603
    if (code < 0) {
604
        return 0xffff;
605
    }
606

    
607
    sign = get_bits1(&s->gb);
608
    shift = fcode - 1;
609
    val = code;
610
    if (shift) {
611
        val = (val - 1) << shift;
612
        val |= get_bits(&s->gb, shift);
613
        val++;
614
    }
615
    if (sign)
616
        val = -val;
617
    val += pred;
618

    
619
    /* modulo decoding */
620
    l= INT_BIT - 5 - shift;
621
    val = (val<<l)>>l;
622
    return val;
623
}
624

    
625
static inline int decode_dc(GetBitContext *gb, int component)
626
{
627
    int code, diff;
628

    
629
    if (component == 0) {
630
        code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
631
    } else {
632
        code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
633
    }
634
    if (code < 0){
635
        av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
636
        return 0xffff;
637
    }
638
    if (code == 0) {
639
        diff = 0;
640
    } else {
641
        diff = get_xbits(gb, code);
642
    }
643
    return diff;
644
}
645

    
646
static inline int mpeg1_decode_block_intra(MpegEncContext *s,
647
                               DCTELEM *block,
648
                               int n)
649
{
650
    int level, dc, diff, i, j, run;
651
    int component;
652
    RLTable *rl = &ff_rl_mpeg1;
653
    uint8_t * const scantable= s->intra_scantable.permutated;
654
    const uint16_t *quant_matrix= s->intra_matrix;
655
    const int qscale= s->qscale;
656

    
657
    /* DC coef */
658
    component = (n <= 3 ? 0 : n - 4 + 1);
659
    diff = decode_dc(&s->gb, component);
660
    if (diff >= 0xffff)
661
        return -1;
662
    dc = s->last_dc[component];
663
    dc += diff;
664
    s->last_dc[component] = dc;
665
    block[0] = dc<<3;
666
    dprintf(s->avctx, "dc=%d diff=%d\n", dc, diff);
667
    i = 0;
668
    {
669
        OPEN_READER(re, &s->gb);
670
        /* now quantify & encode AC coefs */
671
        for(;;) {
672
            UPDATE_CACHE(re, &s->gb);
673
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
674

    
675
            if(level == 127){
676
                break;
677
            } else if(level != 0) {
678
                i += run;
679
                j = scantable[i];
680
                level= (level*qscale*quant_matrix[j])>>4;
681
                level= (level-1)|1;
682
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
683
                LAST_SKIP_BITS(re, &s->gb, 1);
684
            } else {
685
                /* escape */
686
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
687
                UPDATE_CACHE(re, &s->gb);
688
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
689
                if (level == -128) {
690
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
691
                } else if (level == 0) {
692
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
693
                }
694
                i += run;
695
                j = scantable[i];
696
                if(level<0){
697
                    level= -level;
698
                    level= (level*qscale*quant_matrix[j])>>4;
699
                    level= (level-1)|1;
700
                    level= -level;
701
                }else{
702
                    level= (level*qscale*quant_matrix[j])>>4;
703
                    level= (level-1)|1;
704
                }
705
            }
706
            if (i > 63){
707
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
708
                return -1;
709
            }
710

    
711
            block[j] = level;
712
        }
713
        CLOSE_READER(re, &s->gb);
714
    }
715
    s->block_last_index[n] = i;
716
   return 0;
717
}
718

    
719
static inline int mpeg1_decode_block_inter(MpegEncContext *s,
720
                               DCTELEM *block,
721
                               int n)
722
{
723
    int level, i, j, run;
724
    RLTable *rl = &ff_rl_mpeg1;
725
    uint8_t * const scantable= s->intra_scantable.permutated;
726
    const uint16_t *quant_matrix= s->inter_matrix;
727
    const int qscale= s->qscale;
728

    
729
    {
730
        OPEN_READER(re, &s->gb);
731
        i = -1;
732
        /* special case for the first coef. no need to add a second vlc table */
733
        UPDATE_CACHE(re, &s->gb);
734
        if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
735
            level= (3*qscale*quant_matrix[0])>>5;
736
            level= (level-1)|1;
737
            if(GET_CACHE(re, &s->gb)&0x40000000)
738
                level= -level;
739
            block[0] = level;
740
            i++;
741
            SKIP_BITS(re, &s->gb, 2);
742
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
743
                goto end;
744
        }
745

    
746
        /* now quantify & encode AC coefs */
747
        for(;;) {
748
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
749

    
750
            if(level != 0) {
751
                i += run;
752
                j = scantable[i];
753
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
754
                level= (level-1)|1;
755
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
756
                SKIP_BITS(re, &s->gb, 1);
757
            } else {
758
                /* escape */
759
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
760
                UPDATE_CACHE(re, &s->gb);
761
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
762
                if (level == -128) {
763
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
764
                } else if (level == 0) {
765
                    level = SHOW_UBITS(re, &s->gb, 8)      ; SKIP_BITS(re, &s->gb, 8);
766
                }
767
                i += run;
768
                j = scantable[i];
769
                if(level<0){
770
                    level= -level;
771
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
772
                    level= (level-1)|1;
773
                    level= -level;
774
                }else{
775
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
776
                    level= (level-1)|1;
777
                }
778
            }
779
            if (i > 63){
780
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
781
                return -1;
782
            }
783

    
784
            block[j] = level;
785
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
786
                break;
787
            UPDATE_CACHE(re, &s->gb);
788
        }
789
end:
790
        LAST_SKIP_BITS(re, &s->gb, 2);
791
        CLOSE_READER(re, &s->gb);
792
    }
793
    s->block_last_index[n] = i;
794
    return 0;
795
}
796

    
797
static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n)
798
{
799
    int level, i, j, run;
800
    RLTable *rl = &ff_rl_mpeg1;
801
    uint8_t * const scantable= s->intra_scantable.permutated;
802
    const int qscale= s->qscale;
803

    
804
    {
805
        OPEN_READER(re, &s->gb);
806
        i = -1;
807
        /* special case for the first coef. no need to add a second vlc table */
808
        UPDATE_CACHE(re, &s->gb);
809
        if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
810
            level= (3*qscale)>>1;
811
            level= (level-1)|1;
812
            if(GET_CACHE(re, &s->gb)&0x40000000)
813
                level= -level;
814
            block[0] = level;
815
            i++;
816
            SKIP_BITS(re, &s->gb, 2);
817
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
818
                goto end;
819
        }
820

    
821
        /* now quantify & encode AC coefs */
822
        for(;;) {
823
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
824

    
825
            if(level != 0) {
826
                i += run;
827
                j = scantable[i];
828
                level= ((level*2+1)*qscale)>>1;
829
                level= (level-1)|1;
830
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
831
                SKIP_BITS(re, &s->gb, 1);
832
            } else {
833
                /* escape */
834
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
835
                UPDATE_CACHE(re, &s->gb);
836
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
837
                if (level == -128) {
838
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
839
                } else if (level == 0) {
840
                    level = SHOW_UBITS(re, &s->gb, 8)      ; SKIP_BITS(re, &s->gb, 8);
841
                }
842
                i += run;
843
                j = scantable[i];
844
                if(level<0){
845
                    level= -level;
846
                    level= ((level*2+1)*qscale)>>1;
847
                    level= (level-1)|1;
848
                    level= -level;
849
                }else{
850
                    level= ((level*2+1)*qscale)>>1;
851
                    level= (level-1)|1;
852
                }
853
            }
854

    
855
            block[j] = level;
856
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
857
                break;
858
            UPDATE_CACHE(re, &s->gb);
859
        }
860
end:
861
        LAST_SKIP_BITS(re, &s->gb, 2);
862
        CLOSE_READER(re, &s->gb);
863
    }
864
    s->block_last_index[n] = i;
865
    return 0;
866
}
867

    
868

    
869
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
870
                               DCTELEM *block,
871
                               int n)
872
{
873
    int level, i, j, run;
874
    RLTable *rl = &ff_rl_mpeg1;
875
    uint8_t * const scantable= s->intra_scantable.permutated;
876
    const uint16_t *quant_matrix;
877
    const int qscale= s->qscale;
878
    int mismatch;
879

    
880
    mismatch = 1;
881

    
882
    {
883
        OPEN_READER(re, &s->gb);
884
        i = -1;
885
        if (n < 4)
886
            quant_matrix = s->inter_matrix;
887
        else
888
            quant_matrix = s->chroma_inter_matrix;
889

    
890
        /* special case for the first coef. no need to add a second vlc table */
891
        UPDATE_CACHE(re, &s->gb);
892
        if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
893
            level= (3*qscale*quant_matrix[0])>>5;
894
            if(GET_CACHE(re, &s->gb)&0x40000000)
895
                level= -level;
896
            block[0] = level;
897
            mismatch ^= level;
898
            i++;
899
            SKIP_BITS(re, &s->gb, 2);
900
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
901
                goto end;
902
        }
903

    
904
        /* now quantify & encode AC coefs */
905
        for(;;) {
906
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
907

    
908
            if(level != 0) {
909
                i += run;
910
                j = scantable[i];
911
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
912
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
913
                SKIP_BITS(re, &s->gb, 1);
914
            } else {
915
                /* escape */
916
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
917
                UPDATE_CACHE(re, &s->gb);
918
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
919

    
920
                i += run;
921
                j = scantable[i];
922
                if(level<0){
923
                    level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
924
                    level= -level;
925
                }else{
926
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
927
                }
928
            }
929
            if (i > 63){
930
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
931
                return -1;
932
            }
933

    
934
            mismatch ^= level;
935
            block[j] = level;
936
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
937
                break;
938
            UPDATE_CACHE(re, &s->gb);
939
        }
940
end:
941
        LAST_SKIP_BITS(re, &s->gb, 2);
942
        CLOSE_READER(re, &s->gb);
943
    }
944
    block[63] ^= (mismatch & 1);
945

    
946
    s->block_last_index[n] = i;
947
    return 0;
948
}
949

    
950
static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
951
                               DCTELEM *block,
952
                               int n)
953
{
954
    int level, i, j, run;
955
    RLTable *rl = &ff_rl_mpeg1;
956
    uint8_t * const scantable= s->intra_scantable.permutated;
957
    const int qscale= s->qscale;
958
    OPEN_READER(re, &s->gb);
959
    i = -1;
960

    
961
    /* special case for the first coef. no need to add a second vlc table */
962
    UPDATE_CACHE(re, &s->gb);
963
    if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
964
        level= (3*qscale)>>1;
965
        if(GET_CACHE(re, &s->gb)&0x40000000)
966
            level= -level;
967
        block[0] = level;
968
        i++;
969
        SKIP_BITS(re, &s->gb, 2);
970
        if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
971
            goto end;
972
    }
973

    
974
    /* now quantify & encode AC coefs */
975
    for(;;) {
976
        GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
977

    
978
        if(level != 0) {
979
            i += run;
980
            j = scantable[i];
981
            level= ((level*2+1)*qscale)>>1;
982
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
983
            SKIP_BITS(re, &s->gb, 1);
984
        } else {
985
            /* escape */
986
            run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
987
            UPDATE_CACHE(re, &s->gb);
988
            level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
989

    
990
            i += run;
991
            j = scantable[i];
992
            if(level<0){
993
                level= ((-level*2+1)*qscale)>>1;
994
                level= -level;
995
            }else{
996
                level= ((level*2+1)*qscale)>>1;
997
            }
998
        }
999

    
1000
        block[j] = level;
1001
        if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1002
            break;
1003
        UPDATE_CACHE(re, &s->gb);
1004
    }
1005
end:
1006
    LAST_SKIP_BITS(re, &s->gb, 2);
1007
    CLOSE_READER(re, &s->gb);
1008
    s->block_last_index[n] = i;
1009
    return 0;
1010
}
1011

    
1012

    
1013
static inline int mpeg2_decode_block_intra(MpegEncContext *s,
1014
                               DCTELEM *block,
1015
                               int n)
1016
{
1017
    int level, dc, diff, i, j, run;
1018
    int component;
1019
    RLTable *rl;
1020
    uint8_t * const scantable= s->intra_scantable.permutated;
1021
    const uint16_t *quant_matrix;
1022
    const int qscale= s->qscale;
1023
    int mismatch;
1024

    
1025
    /* DC coef */
1026
    if (n < 4){
1027
        quant_matrix = s->intra_matrix;
1028
        component = 0;
1029
    }else{
1030
        quant_matrix = s->chroma_intra_matrix;
1031
        component = (n&1) + 1;
1032
    }
1033
    diff = decode_dc(&s->gb, component);
1034
    if (diff >= 0xffff)
1035
        return -1;
1036
    dc = s->last_dc[component];
1037
    dc += diff;
1038
    s->last_dc[component] = dc;
1039
    block[0] = dc << (3 - s->intra_dc_precision);
1040
    dprintf(s->avctx, "dc=%d\n", block[0]);
1041
    mismatch = block[0] ^ 1;
1042
    i = 0;
1043
    if (s->intra_vlc_format)
1044
        rl = &ff_rl_mpeg2;
1045
    else
1046
        rl = &ff_rl_mpeg1;
1047

    
1048
    {
1049
        OPEN_READER(re, &s->gb);
1050
        /* now quantify & encode AC coefs */
1051
        for(;;) {
1052
            UPDATE_CACHE(re, &s->gb);
1053
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1054

    
1055
            if(level == 127){
1056
                break;
1057
            } else if(level != 0) {
1058
                i += run;
1059
                j = scantable[i];
1060
                level= (level*qscale*quant_matrix[j])>>4;
1061
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1062
                LAST_SKIP_BITS(re, &s->gb, 1);
1063
            } else {
1064
                /* escape */
1065
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1066
                UPDATE_CACHE(re, &s->gb);
1067
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1068
                i += run;
1069
                j = scantable[i];
1070
                if(level<0){
1071
                    level= (-level*qscale*quant_matrix[j])>>4;
1072
                    level= -level;
1073
                }else{
1074
                    level= (level*qscale*quant_matrix[j])>>4;
1075
                }
1076
            }
1077
            if (i > 63){
1078
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1079
                return -1;
1080
            }
1081

    
1082
            mismatch^= level;
1083
            block[j] = level;
1084
        }
1085
        CLOSE_READER(re, &s->gb);
1086
    }
1087
    block[63]^= mismatch&1;
1088

    
1089
    s->block_last_index[n] = i;
1090
    return 0;
1091
}
1092

    
1093
static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
1094
                               DCTELEM *block,
1095
                               int n)
1096
{
1097
    int level, dc, diff, j, run;
1098
    int component;
1099
    RLTable *rl;
1100
    uint8_t * scantable= s->intra_scantable.permutated;
1101
    const uint16_t *quant_matrix;
1102
    const int qscale= s->qscale;
1103

    
1104
    /* DC coef */
1105
    if (n < 4){
1106
        quant_matrix = s->intra_matrix;
1107
        component = 0;
1108
    }else{
1109
        quant_matrix = s->chroma_intra_matrix;
1110
        component = (n&1) + 1;
1111
    }
1112
    diff = decode_dc(&s->gb, component);
1113
    if (diff >= 0xffff)
1114
        return -1;
1115
    dc = s->last_dc[component];
1116
    dc += diff;
1117
    s->last_dc[component] = dc;
1118
    block[0] = dc << (3 - s->intra_dc_precision);
1119
    if (s->intra_vlc_format)
1120
        rl = &ff_rl_mpeg2;
1121
    else
1122
        rl = &ff_rl_mpeg1;
1123

    
1124
    {
1125
        OPEN_READER(re, &s->gb);
1126
        /* now quantify & encode AC coefs */
1127
        for(;;) {
1128
            UPDATE_CACHE(re, &s->gb);
1129
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1130

    
1131
            if(level == 127){
1132
                break;
1133
            } else if(level != 0) {
1134
                scantable += run;
1135
                j = *scantable;
1136
                level= (level*qscale*quant_matrix[j])>>4;
1137
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1138
                LAST_SKIP_BITS(re, &s->gb, 1);
1139
            } else {
1140
                /* escape */
1141
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1142
                UPDATE_CACHE(re, &s->gb);
1143
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1144
                scantable += run;
1145
                j = *scantable;
1146
                if(level<0){
1147
                    level= (-level*qscale*quant_matrix[j])>>4;
1148
                    level= -level;
1149
                }else{
1150
                    level= (level*qscale*quant_matrix[j])>>4;
1151
                }
1152
            }
1153

    
1154
            block[j] = level;
1155
        }
1156
        CLOSE_READER(re, &s->gb);
1157
    }
1158

    
1159
    s->block_last_index[n] = scantable - s->intra_scantable.permutated;
1160
    return 0;
1161
}
1162

    
1163
typedef struct Mpeg1Context {
1164
    MpegEncContext mpeg_enc_ctx;
1165
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1166
    int repeat_field; /* true if we must repeat the field */
1167
    AVPanScan pan_scan; /** some temporary storage for the panscan */
1168
    int slice_count;
1169
    int swap_uv;//indicate VCR2
1170
    int save_aspect_info;
1171
    int save_width, save_height;
1172
    AVRational frame_rate_ext;       ///< MPEG-2 specific framerate modificator
1173

    
1174
} Mpeg1Context;
1175

    
1176
static int mpeg_decode_init(AVCodecContext *avctx)
1177
{
1178
    Mpeg1Context *s = avctx->priv_data;
1179
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
1180
    int i;
1181

    
1182
    //we need some parmutation to store
1183
    //matrixes, until MPV_common_init()
1184
    //set the real permutatuon
1185
    for(i=0;i<64;i++)
1186
       s2->dsp.idct_permutation[i]=i;
1187

    
1188
    MPV_decode_defaults(s2);
1189

    
1190
    s->mpeg_enc_ctx.avctx= avctx;
1191
    s->mpeg_enc_ctx.flags= avctx->flags;
1192
    s->mpeg_enc_ctx.flags2= avctx->flags2;
1193
    ff_mpeg12_common_init(&s->mpeg_enc_ctx);
1194
    init_vlcs();
1195

    
1196
    s->mpeg_enc_ctx_allocated = 0;
1197
    s->mpeg_enc_ctx.picture_number = 0;
1198
    s->repeat_field = 0;
1199
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1200
    return 0;
1201
}
1202

    
1203
static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
1204
                                     const uint8_t *new_perm){
1205
    uint16_t temp_matrix[64];
1206
    int i;
1207

    
1208
    memcpy(temp_matrix,matrix,64*sizeof(uint16_t));
1209

    
1210
    for(i=0;i<64;i++){
1211
        matrix[new_perm[i]] = temp_matrix[old_perm[i]];
1212
    }
1213
}
1214

    
1215
//Call this function when we know all parameters
1216
//it may be called in different places for mpeg1 and mpeg2
1217
static int mpeg_decode_postinit(AVCodecContext *avctx){
1218
    Mpeg1Context *s1 = avctx->priv_data;
1219
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1220
    uint8_t old_permutation[64];
1221

    
1222
    if (
1223
        (s1->mpeg_enc_ctx_allocated == 0)||
1224
        avctx->coded_width  != s->width ||
1225
        avctx->coded_height != s->height||
1226
        s1->save_width != s->width ||
1227
        s1->save_height != s->height ||
1228
        s1->save_aspect_info != s->aspect_ratio_info||
1229
        0)
1230
    {
1231

    
1232
        if (s1->mpeg_enc_ctx_allocated) {
1233
            ParseContext pc= s->parse_context;
1234
            s->parse_context.buffer=0;
1235
            MPV_common_end(s);
1236
            s->parse_context= pc;
1237
        }
1238

    
1239
        if( (s->width == 0 )||(s->height == 0))
1240
            return -2;
1241

    
1242
        avcodec_set_dimensions(avctx, s->width, s->height);
1243
        avctx->bit_rate = s->bit_rate;
1244
        s1->save_aspect_info = s->aspect_ratio_info;
1245
        s1->save_width = s->width;
1246
        s1->save_height = s->height;
1247

    
1248
     //low_delay may be forced, in this case we will have B frames
1249
     //that behave like P frames
1250
        avctx->has_b_frames = !(s->low_delay);
1251

    
1252
        if(avctx->sub_id==1){//s->codec_id==avctx->codec_id==CODEC_ID
1253
            //mpeg1 fps
1254
            avctx->time_base.den= ff_frame_rate_tab[s->frame_rate_index].num;
1255
            avctx->time_base.num= ff_frame_rate_tab[s->frame_rate_index].den;
1256
            //mpeg1 aspect
1257
            avctx->sample_aspect_ratio= av_d2q(
1258
                    1.0/ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1259

    
1260
        }else{//mpeg2
1261
        //mpeg2 fps
1262
            av_reduce(
1263
                &s->avctx->time_base.den,
1264
                &s->avctx->time_base.num,
1265
                ff_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
1266
                ff_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1267
                1<<30);
1268
        //mpeg2 aspect
1269
            if(s->aspect_ratio_info > 1){
1270
                if( (s1->pan_scan.width == 0 )||(s1->pan_scan.height == 0) ){
1271
                    s->avctx->sample_aspect_ratio=
1272
                        av_div_q(
1273
                         ff_mpeg2_aspect[s->aspect_ratio_info],
1274
                         (AVRational){s->width, s->height}
1275
                         );
1276
                }else{
1277
                    s->avctx->sample_aspect_ratio=
1278
                        av_div_q(
1279
                         ff_mpeg2_aspect[s->aspect_ratio_info],
1280
                         (AVRational){s1->pan_scan.width, s1->pan_scan.height}
1281
                        );
1282
                }
1283
            }else{
1284
                s->avctx->sample_aspect_ratio=
1285
                    ff_mpeg2_aspect[s->aspect_ratio_info];
1286
            }
1287
        }//mpeg2
1288

    
1289
        if(avctx->xvmc_acceleration){
1290
            avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
1291
        }else{
1292
            if(s->chroma_format <  2){
1293
                avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420);
1294
            }else
1295
            if(s->chroma_format == 2){
1296
                avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_422);
1297
            }else
1298
            if(s->chroma_format >  2){
1299
                avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_444);
1300
            }
1301
        }
1302
        //until then pix_fmt may be changed right after codec init
1303
        if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
1304
            if( avctx->idct_algo == FF_IDCT_AUTO )
1305
                avctx->idct_algo = FF_IDCT_SIMPLE;
1306

    
1307
        //quantization matrixes may need reordering
1308
        //if dct permutation is changed
1309
        memcpy(old_permutation,s->dsp.idct_permutation,64*sizeof(uint8_t));
1310

    
1311
        if (MPV_common_init(s) < 0)
1312
            return -2;
1313

    
1314
        quant_matrix_rebuild(s->intra_matrix,       old_permutation,s->dsp.idct_permutation);
1315
        quant_matrix_rebuild(s->inter_matrix,       old_permutation,s->dsp.idct_permutation);
1316
        quant_matrix_rebuild(s->chroma_intra_matrix,old_permutation,s->dsp.idct_permutation);
1317
        quant_matrix_rebuild(s->chroma_inter_matrix,old_permutation,s->dsp.idct_permutation);
1318

    
1319
        s1->mpeg_enc_ctx_allocated = 1;
1320
    }
1321
    return 0;
1322
}
1323

    
1324
static int mpeg1_decode_picture(AVCodecContext *avctx,
1325
                                const uint8_t *buf, int buf_size)
1326
{
1327
    Mpeg1Context *s1 = avctx->priv_data;
1328
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1329
    int ref, f_code, vbv_delay;
1330

    
1331
    if(mpeg_decode_postinit(s->avctx) < 0)
1332
       return -2;
1333

    
1334
    init_get_bits(&s->gb, buf, buf_size*8);
1335

    
1336
    ref = get_bits(&s->gb, 10); /* temporal ref */
1337
    s->pict_type = get_bits(&s->gb, 3);
1338
    if(s->pict_type == 0 || s->pict_type > 3)
1339
        return -1;
1340

    
1341
    vbv_delay= get_bits(&s->gb, 16);
1342
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
1343
        s->full_pel[0] = get_bits1(&s->gb);
1344
        f_code = get_bits(&s->gb, 3);
1345
        if (f_code == 0 && avctx->error_resilience >= FF_ER_COMPLIANT)
1346
            return -1;
1347
        s->mpeg_f_code[0][0] = f_code;
1348
        s->mpeg_f_code[0][1] = f_code;
1349
    }
1350
    if (s->pict_type == B_TYPE) {
1351
        s->full_pel[1] = get_bits1(&s->gb);
1352
        f_code = get_bits(&s->gb, 3);
1353
        if (f_code == 0 && avctx->error_resilience >= FF_ER_COMPLIANT)
1354
            return -1;
1355
        s->mpeg_f_code[1][0] = f_code;
1356
        s->mpeg_f_code[1][1] = f_code;
1357
    }
1358
    s->current_picture.pict_type= s->pict_type;
1359
    s->current_picture.key_frame= s->pict_type == I_TYPE;
1360

    
1361
    if(avctx->debug & FF_DEBUG_PICT_INFO)
1362
        av_log(avctx, AV_LOG_DEBUG, "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1363

    
1364
    s->y_dc_scale = 8;
1365
    s->c_dc_scale = 8;
1366
    s->first_slice = 1;
1367
    return 0;
1368
}
1369

    
1370
static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1371
{
1372
    MpegEncContext *s= &s1->mpeg_enc_ctx;
1373
    int horiz_size_ext, vert_size_ext;
1374
    int bit_rate_ext;
1375

    
1376
    skip_bits(&s->gb, 1); /* profil and level esc*/
1377
    s->avctx->profile= get_bits(&s->gb, 3);
1378
    s->avctx->level= get_bits(&s->gb, 4);
1379
    s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1380
    s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1381
    horiz_size_ext = get_bits(&s->gb, 2);
1382
    vert_size_ext = get_bits(&s->gb, 2);
1383
    s->width |= (horiz_size_ext << 12);
1384
    s->height |= (vert_size_ext << 12);
1385
    bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1386
    s->bit_rate += (bit_rate_ext << 18) * 400;
1387
    skip_bits1(&s->gb); /* marker */
1388
    s->avctx->rc_buffer_size += get_bits(&s->gb, 8)*1024*16<<10;
1389

    
1390
    s->low_delay = get_bits1(&s->gb);
1391
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
1392

    
1393
    s1->frame_rate_ext.num = get_bits(&s->gb, 2)+1;
1394
    s1->frame_rate_ext.den = get_bits(&s->gb, 5)+1;
1395

    
1396
    dprintf(s->avctx, "sequence extension\n");
1397
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
1398
    s->avctx->sub_id = 2; /* indicates mpeg2 found */
1399

    
1400
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1401
        av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d vbv buffer: %d, bitrate:%d\n",
1402
               s->avctx->profile, s->avctx->level, s->avctx->rc_buffer_size, s->bit_rate);
1403

    
1404
}
1405

    
1406
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1407
{
1408
    MpegEncContext *s= &s1->mpeg_enc_ctx;
1409
    int color_description, w, h;
1410

    
1411
    skip_bits(&s->gb, 3); /* video format */
1412
    color_description= get_bits1(&s->gb);
1413
    if(color_description){
1414
        skip_bits(&s->gb, 8); /* color primaries */
1415
        skip_bits(&s->gb, 8); /* transfer_characteristics */
1416
        skip_bits(&s->gb, 8); /* matrix_coefficients */
1417
    }
1418
    w= get_bits(&s->gb, 14);
1419
    skip_bits(&s->gb, 1); //marker
1420
    h= get_bits(&s->gb, 14);
1421
    skip_bits(&s->gb, 1); //marker
1422

    
1423
    s1->pan_scan.width= 16*w;
1424
    s1->pan_scan.height=16*h;
1425

    
1426
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1427
        av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1428
}
1429

    
1430
static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1431
{
1432
    MpegEncContext *s= &s1->mpeg_enc_ctx;
1433
    int i,nofco;
1434

    
1435
    nofco = 1;
1436
    if(s->progressive_sequence){
1437
        if(s->repeat_first_field){
1438
            nofco++;
1439
            if(s->top_field_first)
1440
                nofco++;
1441
        }
1442
    }else{
1443
        if(s->picture_structure == PICT_FRAME){
1444
            nofco++;
1445
            if(s->repeat_first_field)
1446
                nofco++;
1447
        }
1448
    }
1449
    for(i=0; i<nofco; i++){
1450
        s1->pan_scan.position[i][0]= get_sbits(&s->gb, 16);
1451
        skip_bits(&s->gb, 1); //marker
1452
        s1->pan_scan.position[i][1]= get_sbits(&s->gb, 16);
1453
        skip_bits(&s->gb, 1); //marker
1454
    }
1455

    
1456
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1457
        av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n",
1458
            s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1459
            s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1460
            s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]
1461
        );
1462
}
1463

    
1464
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1465
{
1466
    int i, v, j;
1467

    
1468
    dprintf(s->avctx, "matrix extension\n");
1469

    
1470
    if (get_bits1(&s->gb)) {
1471
        for(i=0;i<64;i++) {
1472
            v = get_bits(&s->gb, 8);
1473
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1474
            s->intra_matrix[j] = v;
1475
            s->chroma_intra_matrix[j] = v;
1476
        }
1477
    }
1478
    if (get_bits1(&s->gb)) {
1479
        for(i=0;i<64;i++) {
1480
            v = get_bits(&s->gb, 8);
1481
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1482
            s->inter_matrix[j] = v;
1483
            s->chroma_inter_matrix[j] = v;
1484
        }
1485
    }
1486
    if (get_bits1(&s->gb)) {
1487
        for(i=0;i<64;i++) {
1488
            v = get_bits(&s->gb, 8);
1489
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1490
            s->chroma_intra_matrix[j] = v;
1491
        }
1492
    }
1493
    if (get_bits1(&s->gb)) {
1494
        for(i=0;i<64;i++) {
1495
            v = get_bits(&s->gb, 8);
1496
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1497
            s->chroma_inter_matrix[j] = v;
1498
        }
1499
    }
1500
}
1501

    
1502
static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
1503
{
1504
    s->full_pel[0] = s->full_pel[1] = 0;
1505
    s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1506
    s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1507
    s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1508
    s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1509
    s->intra_dc_precision = get_bits(&s->gb, 2);
1510
    s->picture_structure = get_bits(&s->gb, 2);
1511
    s->top_field_first = get_bits1(&s->gb);
1512
    s->frame_pred_frame_dct = get_bits1(&s->gb);
1513
    s->concealment_motion_vectors = get_bits1(&s->gb);
1514
    s->q_scale_type = get_bits1(&s->gb);
1515
    s->intra_vlc_format = get_bits1(&s->gb);
1516
    s->alternate_scan = get_bits1(&s->gb);
1517
    s->repeat_first_field = get_bits1(&s->gb);
1518
    s->chroma_420_type = get_bits1(&s->gb);
1519
    s->progressive_frame = get_bits1(&s->gb);
1520

    
1521
    if(s->picture_structure == PICT_FRAME){
1522
        s->first_field=0;
1523
        s->v_edge_pos= 16*s->mb_height;
1524
    }else{
1525
        s->first_field ^= 1;
1526
        s->v_edge_pos=  8*s->mb_height;
1527
        memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
1528
    }
1529

    
1530
    if(s->alternate_scan){
1531
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
1532
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
1533
    }else{
1534
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
1535
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
1536
    }
1537

    
1538
    /* composite display not parsed */
1539
    dprintf(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1540
    dprintf(s->avctx, "picture_structure=%d\n", s->picture_structure);
1541
    dprintf(s->avctx, "top field first=%d\n", s->top_field_first);
1542
    dprintf(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1543
    dprintf(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1544
    dprintf(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1545
    dprintf(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1546
    dprintf(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1547
    dprintf(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1548
}
1549

    
1550
static void mpeg_decode_extension(AVCodecContext *avctx,
1551
                                  const uint8_t *buf, int buf_size)
1552
{
1553
    Mpeg1Context *s1 = avctx->priv_data;
1554
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1555
    int ext_type;
1556

    
1557
    init_get_bits(&s->gb, buf, buf_size*8);
1558

    
1559
    ext_type = get_bits(&s->gb, 4);
1560
    switch(ext_type) {
1561
    case 0x1:
1562
        mpeg_decode_sequence_extension(s1);
1563
        break;
1564
    case 0x2:
1565
        mpeg_decode_sequence_display_extension(s1);
1566
        break;
1567
    case 0x3:
1568
        mpeg_decode_quant_matrix_extension(s);
1569
        break;
1570
    case 0x7:
1571
        mpeg_decode_picture_display_extension(s1);
1572
        break;
1573
    case 0x8:
1574
        mpeg_decode_picture_coding_extension(s);
1575
        break;
1576
    }
1577
}
1578

    
1579
static void exchange_uv(MpegEncContext *s){
1580
    short * tmp = s->pblocks[4];
1581
    s->pblocks[4] = s->pblocks[5];
1582
    s->pblocks[5] = tmp;
1583
}
1584

    
1585
static int mpeg_field_start(MpegEncContext *s){
1586
    AVCodecContext *avctx= s->avctx;
1587
    Mpeg1Context *s1 = (Mpeg1Context*)s;
1588

    
1589
    /* start frame decoding */
1590
    if(s->first_field || s->picture_structure==PICT_FRAME){
1591
        if(MPV_frame_start(s, avctx) < 0)
1592
            return -1;
1593

    
1594
        ff_er_frame_start(s);
1595

    
1596
        /* first check if we must repeat the frame */
1597
        s->current_picture_ptr->repeat_pict = 0;
1598
        if (s->repeat_first_field) {
1599
            if (s->progressive_sequence) {
1600
                if (s->top_field_first)
1601
                    s->current_picture_ptr->repeat_pict = 4;
1602
                else
1603
                    s->current_picture_ptr->repeat_pict = 2;
1604
            } else if (s->progressive_frame) {
1605
                s->current_picture_ptr->repeat_pict = 1;
1606
            }
1607
        }
1608

    
1609
        *s->current_picture_ptr->pan_scan= s1->pan_scan;
1610
    }else{ //second field
1611
            int i;
1612

    
1613
            if(!s->current_picture_ptr){
1614
                av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1615
                return -1;
1616
            }
1617

    
1618
            for(i=0; i<4; i++){
1619
                s->current_picture.data[i] = s->current_picture_ptr->data[i];
1620
                if(s->picture_structure == PICT_BOTTOM_FIELD){
1621
                    s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
1622
                }
1623
            }
1624
    }
1625
#ifdef HAVE_XVMC
1626
// MPV_frame_start will call this function too,
1627
// but we need to call it on every field
1628
    if(s->avctx->xvmc_acceleration)
1629
         XVMC_field_start(s,avctx);
1630
#endif
1631

    
1632
    return 0;
1633
}
1634

    
1635
#define DECODE_SLICE_ERROR -1
1636
#define DECODE_SLICE_OK 0
1637

    
1638
/**
1639
 * decodes a slice. MpegEncContext.mb_y must be set to the MB row from the startcode
1640
 * @return DECODE_SLICE_ERROR if the slice is damaged<br>
1641
 *         DECODE_SLICE_OK if this slice is ok<br>
1642
 */
1643
static int mpeg_decode_slice(Mpeg1Context *s1, int mb_y,
1644
                             const uint8_t **buf, int buf_size)
1645
{
1646
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1647
    AVCodecContext *avctx= s->avctx;
1648
    const int field_pic= s->picture_structure != PICT_FRAME;
1649
    const int lowres= s->avctx->lowres;
1650

    
1651
    s->resync_mb_x=
1652
    s->resync_mb_y= -1;
1653

    
1654
    if (mb_y<<field_pic >= s->mb_height){
1655
        av_log(s->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s->mb_height);
1656
        return -1;
1657
    }
1658

    
1659
    init_get_bits(&s->gb, *buf, buf_size*8);
1660

    
1661
    ff_mpeg1_clean_buffers(s);
1662
    s->interlaced_dct = 0;
1663

    
1664
    s->qscale = get_qscale(s);
1665

    
1666
    if(s->qscale == 0){
1667
        av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1668
        return -1;
1669
    }
1670

    
1671
    /* extra slice info */
1672
    while (get_bits1(&s->gb) != 0) {
1673
        skip_bits(&s->gb, 8);
1674
    }
1675

    
1676
    s->mb_x=0;
1677

    
1678
    for(;;) {
1679
        int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1680
        if (code < 0){
1681
            av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1682
            return -1;
1683
        }
1684
        if (code >= 33) {
1685
            if (code == 33) {
1686
                s->mb_x += 33;
1687
            }
1688
            /* otherwise, stuffing, nothing to do */
1689
        } else {
1690
            s->mb_x += code;
1691
            break;
1692
        }
1693
    }
1694
    if(s->mb_x >= (unsigned)s->mb_width){
1695
        av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1696
        return -1;
1697
    }
1698

    
1699
    s->resync_mb_x= s->mb_x;
1700
    s->resync_mb_y= s->mb_y= mb_y;
1701
    s->mb_skip_run= 0;
1702
    ff_init_block_index(s);
1703

    
1704
    if (s->mb_y==0 && s->mb_x==0 && (s->first_field || s->picture_structure==PICT_FRAME)) {
1705
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1706
             av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%2d%2d%2d%2d %s %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n",
1707
                 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],
1708
                 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
1709
                 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"",
1710
                 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1711
                 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1712
        }
1713
    }
1714

    
1715
    for(;;) {
1716
#ifdef HAVE_XVMC
1717
        //one 1 we memcpy blocks in xvmcvideo
1718
        if(s->avctx->xvmc_acceleration > 1)
1719
            XVMC_init_block(s);//set s->block
1720
#endif
1721

    
1722
        if(mpeg_decode_mb(s, s->block) < 0)
1723
            return -1;
1724

    
1725
        if(s->current_picture.motion_val[0] && !s->encoding){ //note motion_val is normally NULL unless we want to extract the MVs
1726
            const int wrap = field_pic ? 2*s->b8_stride : s->b8_stride;
1727
            int xy = s->mb_x*2 + s->mb_y*2*wrap;
1728
            int motion_x, motion_y, dir, i;
1729
            if(field_pic && !s->first_field)
1730
                xy += wrap/2;
1731

    
1732
            for(i=0; i<2; i++){
1733
                for(dir=0; dir<2; dir++){
1734
                    if (s->mb_intra || (dir==1 && s->pict_type != B_TYPE)) {
1735
                        motion_x = motion_y = 0;
1736
                    }else if (s->mv_type == MV_TYPE_16X16 || (s->mv_type == MV_TYPE_FIELD && field_pic)){
1737
                        motion_x = s->mv[dir][0][0];
1738
                        motion_y = s->mv[dir][0][1];
1739
                    } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ {
1740
                        motion_x = s->mv[dir][i][0];
1741
                        motion_y = s->mv[dir][i][1];
1742
                    }
1743

    
1744
                    s->current_picture.motion_val[dir][xy    ][0] = motion_x;
1745
                    s->current_picture.motion_val[dir][xy    ][1] = motion_y;
1746
                    s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1747
                    s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1748
                    s->current_picture.ref_index [dir][xy    ]=
1749
                    s->current_picture.ref_index [dir][xy + 1]= s->field_select[dir][i];
1750
                    assert(s->field_select[dir][i]==0 || s->field_select[dir][i]==1);
1751
                }
1752
                xy += wrap;
1753
            }
1754
        }
1755

    
1756
        s->dest[0] += 16 >> lowres;
1757
        s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1758
        s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1759

    
1760
        MPV_decode_mb(s, s->block);
1761

    
1762
        if (++s->mb_x >= s->mb_width) {
1763
            const int mb_size= 16>>s->avctx->lowres;
1764

    
1765
            ff_draw_horiz_band(s, mb_size*s->mb_y, mb_size);
1766

    
1767
            s->mb_x = 0;
1768
            s->mb_y++;
1769

    
1770
            if(s->mb_y<<field_pic >= s->mb_height){
1771
                int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1772
                int is_d10= s->chroma_format==2 && s->pict_type==I_TYPE && avctx->profile==0 && avctx->level==5
1773
                            && s->intra_dc_precision == 2 && s->q_scale_type == 1 && s->alternate_scan == 0
1774
                            && s->progressive_frame == 0 /* vbv_delay == 0xBBB || 0xE10*/;
1775

    
1776
                if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10)
1777
                   || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
1778
                    av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n", left, show_bits(&s->gb, FFMIN(left, 23)));
1779
                    return -1;
1780
                }else
1781
                    goto eos;
1782
            }
1783

    
1784
            ff_init_block_index(s);
1785
        }
1786

    
1787
        /* skip mb handling */
1788
        if (s->mb_skip_run == -1) {
1789
            /* read again increment */
1790
            s->mb_skip_run = 0;
1791
            for(;;) {
1792
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1793
                if (code < 0){
1794
                    av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1795
                    return -1;
1796
                }
1797
                if (code >= 33) {
1798
                    if (code == 33) {
1799
                        s->mb_skip_run += 33;
1800
                    }else if(code == 35){
1801
                        if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
1802
                            av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1803
                            return -1;
1804
                        }
1805
                        goto eos; /* end of slice */
1806
                    }
1807
                    /* otherwise, stuffing, nothing to do */
1808
                } else {
1809
                    s->mb_skip_run += code;
1810
                    break;
1811
                }
1812
            }
1813
            if(s->mb_skip_run){
1814
                int i;
1815
                if(s->pict_type == I_TYPE){
1816
                    av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1817
                    return -1;
1818
                }
1819

    
1820
                /* skip mb */
1821
                s->mb_intra = 0;
1822
                for(i=0;i<12;i++)
1823
                    s->block_last_index[i] = -1;
1824
                if(s->picture_structure == PICT_FRAME)
1825
                    s->mv_type = MV_TYPE_16X16;
1826
                else
1827
                    s->mv_type = MV_TYPE_FIELD;
1828
                if (s->pict_type == P_TYPE) {
1829
                    /* if P type, zero motion vector is implied */
1830
                    s->mv_dir = MV_DIR_FORWARD;
1831
                    s->mv[0][0][0] = s->mv[0][0][1] = 0;
1832
                    s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1833
                    s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1834
                    s->field_select[0][0]= s->picture_structure - 1;
1835
                } else {
1836
                    /* if B type, reuse previous vectors and directions */
1837
                    s->mv[0][0][0] = s->last_mv[0][0][0];
1838
                    s->mv[0][0][1] = s->last_mv[0][0][1];
1839
                    s->mv[1][0][0] = s->last_mv[1][0][0];
1840
                    s->mv[1][0][1] = s->last_mv[1][0][1];
1841
                }
1842
            }
1843
        }
1844
    }
1845
eos: // end of slice
1846
    *buf += get_bits_count(&s->gb)/8 - 1;
1847
//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
1848
    return 0;
1849
}
1850

    
1851
static int slice_decode_thread(AVCodecContext *c, void *arg){
1852
    MpegEncContext *s= arg;
1853
    const uint8_t *buf= s->gb.buffer;
1854
    int mb_y= s->start_mb_y;
1855

    
1856
    s->error_count= 3*(s->end_mb_y - s->start_mb_y)*s->mb_width;
1857

    
1858
    for(;;){
1859
        uint32_t start_code;
1860
        int ret;
1861

    
1862
        ret= mpeg_decode_slice((Mpeg1Context*)s, mb_y, &buf, s->gb.buffer_end - buf);
1863
        emms_c();
1864
//av_log(c, AV_LOG_DEBUG, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
1865
//ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, s->start_mb_y, s->end_mb_y, s->error_count);
1866
        if(ret < 0){
1867
            if(s->resync_mb_x>=0 && s->resync_mb_y>=0)
1868
                ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, AC_ERROR|DC_ERROR|MV_ERROR);
1869
        }else{
1870
            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);
1871
        }
1872

    
1873
        if(s->mb_y == s->end_mb_y)
1874
            return 0;
1875

    
1876
        start_code= -1;
1877
        buf = ff_find_start_code(buf, s->gb.buffer_end, &start_code);
1878
        mb_y= start_code - SLICE_MIN_START_CODE;
1879
        if(mb_y < 0 || mb_y >= s->end_mb_y)
1880
            return -1;
1881
    }
1882

    
1883
    return 0; //not reached
1884
}
1885

    
1886
/**
1887
 * handles slice ends.
1888
 * @return 1 if it seems to be the last slice of
1889
 */
1890
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
1891
{
1892
    Mpeg1Context *s1 = avctx->priv_data;
1893
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1894

    
1895
    if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
1896
        return 0;
1897

    
1898
#ifdef HAVE_XVMC
1899
    if(s->avctx->xvmc_acceleration)
1900
        XVMC_field_end(s);
1901
#endif
1902
    /* end of slice reached */
1903
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
1904
        /* end of image */
1905

    
1906
        s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
1907

    
1908
        ff_er_frame_end(s);
1909

    
1910
        MPV_frame_end(s);
1911

    
1912
        if (s->pict_type == B_TYPE || s->low_delay) {
1913
            *pict= *(AVFrame*)s->current_picture_ptr;
1914
            ff_print_debug_info(s, pict);
1915
        } else {
1916
            s->picture_number++;
1917
            /* latency of 1 frame for I and P frames */
1918
            /* XXX: use another variable than picture_number */
1919
            if (s->last_picture_ptr != NULL) {
1920
                *pict= *(AVFrame*)s->last_picture_ptr;
1921
                 ff_print_debug_info(s, pict);
1922
            }
1923
        }
1924

    
1925
        return 1;
1926
    } else {
1927
        return 0;
1928
    }
1929
}
1930

    
1931
static int mpeg1_decode_sequence(AVCodecContext *avctx,
1932
                                 const uint8_t *buf, int buf_size)
1933
{
1934
    Mpeg1Context *s1 = avctx->priv_data;
1935
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1936
    int width,height;
1937
    int i, v, j;
1938

    
1939
    init_get_bits(&s->gb, buf, buf_size*8);
1940

    
1941
    width = get_bits(&s->gb, 12);
1942
    height = get_bits(&s->gb, 12);
1943
    if (width <= 0 || height <= 0 ||
1944
        (width % 2) != 0 || (height % 2) != 0)
1945
        return -1;
1946
    s->aspect_ratio_info= get_bits(&s->gb, 4);
1947
    if (s->aspect_ratio_info == 0)
1948
        return -1;
1949
    s->frame_rate_index = get_bits(&s->gb, 4);
1950
    if (s->frame_rate_index == 0 || s->frame_rate_index > 13)
1951
        return -1;
1952
    s->bit_rate = get_bits(&s->gb, 18) * 400;
1953
    if (get_bits1(&s->gb) == 0) /* marker */
1954
        return -1;
1955
    s->width = width;
1956
    s->height = height;
1957

    
1958
    s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16;
1959
    skip_bits(&s->gb, 1);
1960

    
1961
    /* get matrix */
1962
    if (get_bits1(&s->gb)) {
1963
        for(i=0;i<64;i++) {
1964
            v = get_bits(&s->gb, 8);
1965
            if(v==0){
1966
                av_log(s->avctx, AV_LOG_ERROR, "intra matrix damaged\n");
1967
                return -1;
1968
            }
1969
            j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1970
            s->intra_matrix[j] = v;
1971
            s->chroma_intra_matrix[j] = v;
1972
        }
1973
#ifdef DEBUG
1974
        dprintf(s->avctx, "intra matrix present\n");
1975
        for(i=0;i<64;i++)
1976
            dprintf(s->avctx, " %d", s->intra_matrix[s->dsp.idct_permutation[i]]);
1977
        dprintf(s->avctx, "\n");
1978
#endif
1979
    } else {
1980
        for(i=0;i<64;i++) {
1981
            j = s->dsp.idct_permutation[i];
1982
            v = ff_mpeg1_default_intra_matrix[i];
1983
            s->intra_matrix[j] = v;
1984
            s->chroma_intra_matrix[j] = v;
1985
        }
1986
    }
1987
    if (get_bits1(&s->gb)) {
1988
        for(i=0;i<64;i++) {
1989
            v = get_bits(&s->gb, 8);
1990
            if(v==0){
1991
                av_log(s->avctx, AV_LOG_ERROR, "inter matrix damaged\n");
1992
                return -1;
1993
            }
1994
            j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1995
            s->inter_matrix[j] = v;
1996
            s->chroma_inter_matrix[j] = v;
1997
        }
1998
#ifdef DEBUG
1999
        dprintf(s->avctx, "non intra matrix present\n");
2000
        for(i=0;i<64;i++)
2001
            dprintf(s->avctx, " %d", s->inter_matrix[s->dsp.idct_permutation[i]]);
2002
        dprintf(s->avctx, "\n");
2003
#endif
2004
    } else {
2005
        for(i=0;i<64;i++) {
2006
            int j= s->dsp.idct_permutation[i];
2007
            v = ff_mpeg1_default_non_intra_matrix[i];
2008
            s->inter_matrix[j] = v;
2009
            s->chroma_inter_matrix[j] = v;
2010
        }
2011
    }
2012

    
2013
    if(show_bits(&s->gb, 23) != 0){
2014
        av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2015
        return -1;
2016
    }
2017

    
2018
    /* we set mpeg2 parameters so that it emulates mpeg1 */
2019
    s->progressive_sequence = 1;
2020
    s->progressive_frame = 1;
2021
    s->picture_structure = PICT_FRAME;
2022
    s->frame_pred_frame_dct = 1;
2023
    s->chroma_format = 1;
2024
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO;
2025
    avctx->sub_id = 1; /* indicates mpeg1 */
2026
    s->out_format = FMT_MPEG1;
2027
    s->swap_uv = 0;//AFAIK VCR2 don't have SEQ_HEADER
2028
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
2029

    
2030
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2031
        av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n",
2032
               s->avctx->rc_buffer_size, s->bit_rate);
2033

    
2034
    return 0;
2035
}
2036

    
2037
static int vcr2_init_sequence(AVCodecContext *avctx)
2038
{
2039
    Mpeg1Context *s1 = avctx->priv_data;
2040
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2041
    int i, v;
2042

    
2043
    /* start new mpeg1 context decoding */
2044
    s->out_format = FMT_MPEG1;
2045
    if (s1->mpeg_enc_ctx_allocated) {
2046
        MPV_common_end(s);
2047
    }
2048
    s->width  = avctx->coded_width;
2049
    s->height = avctx->coded_height;
2050
    avctx->has_b_frames= 0; //true?
2051
    s->low_delay= 1;
2052

    
2053
    if(avctx->xvmc_acceleration){
2054
        avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
2055
    }else{
2056
        avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420);
2057
    }
2058

    
2059
    if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2060
        if( avctx->idct_algo == FF_IDCT_AUTO )
2061
            avctx->idct_algo = FF_IDCT_SIMPLE;
2062

    
2063
    if (MPV_common_init(s) < 0)
2064
        return -1;
2065
    exchange_uv(s);//common init reset pblocks, so we swap them here
2066
    s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB
2067
    s1->mpeg_enc_ctx_allocated = 1;
2068

    
2069
    for(i=0;i<64;i++) {
2070
        int j= s->dsp.idct_permutation[i];
2071
        v = ff_mpeg1_default_intra_matrix[i];
2072
        s->intra_matrix[j] = v;
2073
        s->chroma_intra_matrix[j] = v;
2074

    
2075
        v = ff_mpeg1_default_non_intra_matrix[i];
2076
        s->inter_matrix[j] = v;
2077
        s->chroma_inter_matrix[j] = v;
2078
    }
2079

    
2080
    s->progressive_sequence = 1;
2081
    s->progressive_frame = 1;
2082
    s->picture_structure = PICT_FRAME;
2083
    s->frame_pred_frame_dct = 1;
2084
    s->chroma_format = 1;
2085
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2086
    avctx->sub_id = 2; /* indicates mpeg2 */
2087
    return 0;
2088
}
2089

    
2090

    
2091
static void mpeg_decode_user_data(AVCodecContext *avctx,
2092
                                  const uint8_t *buf, int buf_size)
2093
{
2094
    const uint8_t *p;
2095
    int len, flags;
2096
    p = buf;
2097
    len = buf_size;
2098

    
2099
    /* we parse the DTG active format information */
2100
    if (len >= 5 &&
2101
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2102
        flags = p[4];
2103
        p += 5;
2104
        len -= 5;
2105
        if (flags & 0x80) {
2106
            /* skip event id */
2107
            if (len < 2)
2108
                return;
2109
            p += 2;
2110
            len -= 2;
2111
        }
2112
        if (flags & 0x40) {
2113
            if (len < 1)
2114
                return;
2115
            avctx->dtg_active_format = p[0] & 0x0f;
2116
        }
2117
    }
2118
}
2119

    
2120
static void mpeg_decode_gop(AVCodecContext *avctx,
2121
                            const uint8_t *buf, int buf_size){
2122
    Mpeg1Context *s1 = avctx->priv_data;
2123
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2124

    
2125
    int drop_frame_flag;
2126
    int time_code_hours, time_code_minutes;
2127
    int time_code_seconds, time_code_pictures;
2128
    int broken_link;
2129

    
2130
    init_get_bits(&s->gb, buf, buf_size*8);
2131

    
2132
    drop_frame_flag = get_bits1(&s->gb);
2133

    
2134
    time_code_hours=get_bits(&s->gb,5);
2135
    time_code_minutes = get_bits(&s->gb,6);
2136
    skip_bits1(&s->gb);//marker bit
2137
    time_code_seconds = get_bits(&s->gb,6);
2138
    time_code_pictures = get_bits(&s->gb,6);
2139

    
2140
    /*broken_link indicate that after editing the
2141
      reference frames of the first B-Frames after GOP I-Frame
2142
      are missing (open gop)*/
2143
    broken_link = get_bits1(&s->gb);
2144

    
2145
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2146
        av_log(s->avctx, AV_LOG_DEBUG, "GOP (%2d:%02d:%02d.[%02d]) broken_link=%d\n",
2147
            time_code_hours, time_code_minutes, time_code_seconds,
2148
            time_code_pictures, broken_link);
2149
}
2150
/**
2151
 * finds the end of the current frame in the bitstream.
2152
 * @return the position of the first byte of the next frame, or -1
2153
 */
2154
int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)
2155
{
2156
    int i;
2157
    uint32_t state= pc->state;
2158

    
2159
    i=0;
2160
    if(!pc->frame_start_found){
2161
        for(i=0; i<buf_size; i++){
2162
            i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1;
2163
            if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2164
                i++;
2165
                pc->frame_start_found=1;
2166
                break;
2167
            }
2168
        }
2169
    }
2170

    
2171
    if(pc->frame_start_found){
2172
        /* EOF considered as end of frame */
2173
        if (buf_size == 0)
2174
            return 0;
2175
        for(; i<buf_size; i++){
2176
            i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1;
2177
            if((state&0xFFFFFF00) == 0x100){
2178
                if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2179
                    pc->frame_start_found=0;
2180
                    pc->state=-1;
2181
                    return i-3;
2182
                }
2183
            }
2184
        }
2185
    }
2186
    pc->state= state;
2187
    return END_NOT_FOUND;
2188
}
2189

    
2190
/* handle buffering and image synchronisation */
2191
static int mpeg_decode_frame(AVCodecContext *avctx,
2192
                             void *data, int *data_size,
2193
                             uint8_t *buf, int buf_size)
2194
{
2195
    Mpeg1Context *s = avctx->priv_data;
2196
    const uint8_t *buf_end;
2197
    const uint8_t *buf_ptr;
2198
    uint32_t start_code;
2199
    int ret, input_size;
2200
    AVFrame *picture = data;
2201
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2202
    dprintf(avctx, "fill_buffer\n");
2203

    
2204
    if (buf_size == 0) {
2205
        /* special case for last picture */
2206
        if (s2->low_delay==0 && s2->next_picture_ptr) {
2207
            *picture= *(AVFrame*)s2->next_picture_ptr;
2208
            s2->next_picture_ptr= NULL;
2209

    
2210
            *data_size = sizeof(AVFrame);
2211
        }
2212
        return 0;
2213
    }
2214

    
2215
    if(s2->flags&CODEC_FLAG_TRUNCATED){
2216
        int next= ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size);
2217

    
2218
        if( ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
2219
            return buf_size;
2220
    }
2221

    
2222
    buf_ptr = buf;
2223
    buf_end = buf + buf_size;
2224

    
2225
#if 0
2226
    if (s->repeat_field % 2 == 1) {
2227
        s->repeat_field++;
2228
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2229
        //        s2->picture_number, s->repeat_field);
2230
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2231
            *data_size = sizeof(AVPicture);
2232
            goto the_end;
2233
        }
2234
    }
2235
#endif
2236

    
2237
    if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2"))
2238
        vcr2_init_sequence(avctx);
2239

    
2240
    s->slice_count= 0;
2241

    
2242
    for(;;) {
2243
        /* find start next code */
2244
        start_code = -1;
2245
        buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code);
2246
        if (start_code > 0x1ff){
2247
            if(s2->pict_type != B_TYPE || avctx->skip_frame <= AVDISCARD_DEFAULT){
2248
                if(avctx->thread_count > 1){
2249
                    int i;
2250

    
2251
                    avctx->execute(avctx, slice_decode_thread,  (void**)&(s2->thread_context[0]), NULL, s->slice_count);
2252
                    for(i=0; i<s->slice_count; i++)
2253
                        s2->error_count += s2->thread_context[i]->error_count;
2254
                }
2255
                if (slice_end(avctx, picture)) {
2256
                    if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
2257
                        *data_size = sizeof(AVPicture);
2258
                }
2259
            }
2260
            return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2261
        }
2262

    
2263
        input_size = buf_end - buf_ptr;
2264

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

    
2269
        /* prepare data for next start code */
2270
        switch(start_code) {
2271
        case SEQ_START_CODE:
2272
            mpeg1_decode_sequence(avctx, buf_ptr,
2273
                                    input_size);
2274
            break;
2275

    
2276
        case PICTURE_START_CODE:
2277
            /* we have a complete image : we try to decompress it */
2278
            mpeg1_decode_picture(avctx,
2279
                                    buf_ptr, input_size);
2280
            break;
2281
        case EXT_START_CODE:
2282
            mpeg_decode_extension(avctx,
2283
                                    buf_ptr, input_size);
2284
            break;
2285
        case USER_START_CODE:
2286
            mpeg_decode_user_data(avctx,
2287
                                    buf_ptr, input_size);
2288
            break;
2289
        case GOP_START_CODE:
2290
            s2->first_field=0;
2291
            mpeg_decode_gop(avctx,
2292
                                    buf_ptr, input_size);
2293
            break;
2294
        default:
2295
            if (start_code >= SLICE_MIN_START_CODE &&
2296
                start_code <= SLICE_MAX_START_CODE) {
2297
                int mb_y= start_code - SLICE_MIN_START_CODE;
2298

    
2299
                if(s2->last_picture_ptr==NULL){
2300
                /* Skip B-frames if we do not have reference frames. */
2301
                    if(s2->pict_type==B_TYPE) break;
2302
                /* Skip P-frames if we do not have reference frame no valid header. */
2303
//                    if(s2->pict_type==P_TYPE && s2->first_field && !s2->first_slice) break;
2304
                }
2305
                /* Skip B-frames if we are in a hurry. */
2306
                if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
2307
                if(  (avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type==B_TYPE)
2308
                    ||(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type!=I_TYPE)
2309
                    || avctx->skip_frame >= AVDISCARD_ALL)
2310
                    break;
2311
                /* Skip everything if we are in a hurry>=5. */
2312
                if(avctx->hurry_up>=5) break;
2313

    
2314
                if (!s->mpeg_enc_ctx_allocated) break;
2315

    
2316
                if(s2->codec_id == CODEC_ID_MPEG2VIDEO){
2317
                    if(mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom)
2318
                        break;
2319
                }
2320

    
2321
                if(s2->first_slice){
2322
                    s2->first_slice=0;
2323
                            if(mpeg_field_start(s2) < 0)
2324
                        return -1;
2325
                    }
2326
                if(!s2->current_picture_ptr){
2327
                    av_log(avctx, AV_LOG_ERROR, "current_picture not initialized\n");
2328
                    return -1;
2329
                }
2330

    
2331
                if(avctx->thread_count > 1){
2332
                    int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count;
2333
                    if(threshold <= mb_y){
2334
                        MpegEncContext *thread_context= s2->thread_context[s->slice_count];
2335

    
2336
                        thread_context->start_mb_y= mb_y;
2337
                        thread_context->end_mb_y  = s2->mb_height;
2338
                        if(s->slice_count){
2339
                            s2->thread_context[s->slice_count-1]->end_mb_y= mb_y;
2340
                            ff_update_duplicate_context(thread_context, s2);
2341
                        }
2342
                        init_get_bits(&thread_context->gb, buf_ptr, input_size*8);
2343
                        s->slice_count++;
2344
                    }
2345
                    buf_ptr += 2; //FIXME add minimum num of bytes per slice
2346
                }else{
2347
                    ret = mpeg_decode_slice(s, mb_y, &buf_ptr, input_size);
2348
                    emms_c();
2349

    
2350
                    if(ret < 0){
2351
                        if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2352
                            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);
2353
                    }else{
2354
                        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);
2355
                    }
2356
                }
2357
            }
2358
            break;
2359
        }
2360
    }
2361
}
2362

    
2363
static int mpeg_decode_end(AVCodecContext *avctx)
2364
{
2365
    Mpeg1Context *s = avctx->priv_data;
2366

    
2367
    if (s->mpeg_enc_ctx_allocated)
2368
        MPV_common_end(&s->mpeg_enc_ctx);
2369
    return 0;
2370
}
2371

    
2372
AVCodec mpeg1video_decoder = {
2373
    "mpeg1video",
2374
    CODEC_TYPE_VIDEO,
2375
    CODEC_ID_MPEG1VIDEO,
2376
    sizeof(Mpeg1Context),
2377
    mpeg_decode_init,
2378
    NULL,
2379
    mpeg_decode_end,
2380
    mpeg_decode_frame,
2381
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2382
    .flush= ff_mpeg_flush,
2383
};
2384

    
2385
AVCodec mpeg2video_decoder = {
2386
    "mpeg2video",
2387
    CODEC_TYPE_VIDEO,
2388
    CODEC_ID_MPEG2VIDEO,
2389
    sizeof(Mpeg1Context),
2390
    mpeg_decode_init,
2391
    NULL,
2392
    mpeg_decode_end,
2393
    mpeg_decode_frame,
2394
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2395
    .flush= ff_mpeg_flush,
2396
};
2397

    
2398
//legacy decoder
2399
AVCodec mpegvideo_decoder = {
2400
    "mpegvideo",
2401
    CODEC_TYPE_VIDEO,
2402
    CODEC_ID_MPEG2VIDEO,
2403
    sizeof(Mpeg1Context),
2404
    mpeg_decode_init,
2405
    NULL,
2406
    mpeg_decode_end,
2407
    mpeg_decode_frame,
2408
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2409
    .flush= ff_mpeg_flush,
2410
};
2411

    
2412
#ifdef HAVE_XVMC
2413
static int mpeg_mc_decode_init(AVCodecContext *avctx){
2414
    Mpeg1Context *s;
2415

    
2416
    if( avctx->thread_count > 1)
2417
        return -1;
2418
    if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
2419
        return -1;
2420
    if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){
2421
        dprintf(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2422
    }
2423
    mpeg_decode_init(avctx);
2424
    s = avctx->priv_data;
2425

    
2426
    avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
2427
    avctx->xvmc_acceleration = 2;//2 - the blocks are packed!
2428

    
2429
    return 0;
2430
}
2431

    
2432
AVCodec mpeg_xvmc_decoder = {
2433
    "mpegvideo_xvmc",
2434
    CODEC_TYPE_VIDEO,
2435
    CODEC_ID_MPEG2VIDEO_XVMC,
2436
    sizeof(Mpeg1Context),
2437
    mpeg_mc_decode_init,
2438
    NULL,
2439
    mpeg_decode_end,
2440
    mpeg_decode_frame,
2441
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
2442
    .flush= ff_mpeg_flush,
2443
};
2444

    
2445
#endif
2446

    
2447
/* this is ugly i know, but the alternative is too make
2448
   hundreds of vars global and prefix them with ff_mpeg1_
2449
   which is far uglier. */
2450
#include "mdec.c"