Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ 25450bb2

History | View | Annotate | Download (87.3 KB)

1
/*
2
 * MPEG-1/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 libavcodec/mpeg12.c
25
 * MPEG-1/2 decoder
26
 */
27

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

    
34
#include "mpeg12.h"
35
#include "mpeg12data.h"
36
#include "mpeg12decdata.h"
37
#include "bytestream.h"
38
#include "vdpau_internal.h"
39
#include "xvmc_internal.h"
40

    
41
//#undef NDEBUG
42
//#include <assert.h>
43

    
44

    
45
#define MV_VLC_BITS 9
46
#define MBINCR_VLC_BITS 9
47
#define MB_PAT_VLC_BITS 9
48
#define MB_PTYPE_VLC_BITS 6
49
#define MB_BTYPE_VLC_BITS 6
50

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

    
69
static const enum PixelFormat pixfmt_xvmc_mpg2_420[] = {
70
                                           PIX_FMT_XVMC_MPEG2_IDCT,
71
                                           PIX_FMT_XVMC_MPEG2_MC,
72
                                           PIX_FMT_NONE};
73

    
74
uint8_t ff_mpeg12_static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3];
75

    
76

    
77
#define INIT_2D_VLC_RL(rl, static_size)\
78
{\
79
    static RL_VLC_ELEM rl_vlc_table[static_size];\
80
    INIT_VLC_STATIC(&rl.vlc, TEX_VLC_BITS, rl.n + 2,\
81
             &rl.table_vlc[0][1], 4, 2,\
82
             &rl.table_vlc[0][0], 4, 2, static_size);\
83
\
84
    rl.rl_vlc[0]= rl_vlc_table;\
85
    init_2d_vlc_rl(&rl);\
86
}
87

    
88
static void init_2d_vlc_rl(RLTable *rl)
89
{
90
    int i;
91

    
92
    for(i=0; i<rl->vlc.table_size; i++){
93
        int code= rl->vlc.table[i][0];
94
        int len = rl->vlc.table[i][1];
95
        int level, run;
96

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

    
121
void ff_mpeg12_common_init(MpegEncContext *s)
122
{
123

    
124
    s->y_dc_scale_table=
125
    s->c_dc_scale_table= mpeg2_dc_scale_table[s->intra_dc_precision];
126

    
127
}
128

    
129
void ff_mpeg1_clean_buffers(MpegEncContext *s){
130
    s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
131
    s->last_dc[1] = s->last_dc[0];
132
    s->last_dc[2] = s->last_dc[0];
133
    memset(s->last_mv, 0, sizeof(s->last_mv));
134
}
135

    
136

    
137
/******************************************/
138
/* decoding */
139

    
140
static VLC mv_vlc;
141
static VLC mbincr_vlc;
142
static VLC mb_ptype_vlc;
143
static VLC mb_btype_vlc;
144
static VLC mb_pat_vlc;
145

    
146
av_cold void ff_mpeg12_init_vlcs(void)
147
{
148
    static int done = 0;
149

    
150
    if (!done) {
151
        done = 1;
152

    
153
        INIT_VLC_STATIC(&dc_lum_vlc, DC_VLC_BITS, 12,
154
                 ff_mpeg12_vlc_dc_lum_bits, 1, 1,
155
                 ff_mpeg12_vlc_dc_lum_code, 2, 2, 512);
156
        INIT_VLC_STATIC(&dc_chroma_vlc,  DC_VLC_BITS, 12,
157
                 ff_mpeg12_vlc_dc_chroma_bits, 1, 1,
158
                 ff_mpeg12_vlc_dc_chroma_code, 2, 2, 514);
159
        INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 17,
160
                 &ff_mpeg12_mbMotionVectorTable[0][1], 2, 1,
161
                 &ff_mpeg12_mbMotionVectorTable[0][0], 2, 1, 518);
162
        INIT_VLC_STATIC(&mbincr_vlc, MBINCR_VLC_BITS, 36,
163
                 &ff_mpeg12_mbAddrIncrTable[0][1], 2, 1,
164
                 &ff_mpeg12_mbAddrIncrTable[0][0], 2, 1, 538);
165
        INIT_VLC_STATIC(&mb_pat_vlc, MB_PAT_VLC_BITS, 64,
166
                 &ff_mpeg12_mbPatTable[0][1], 2, 1,
167
                 &ff_mpeg12_mbPatTable[0][0], 2, 1, 512);
168

    
169
        INIT_VLC_STATIC(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7,
170
                 &table_mb_ptype[0][1], 2, 1,
171
                 &table_mb_ptype[0][0], 2, 1, 64);
172
        INIT_VLC_STATIC(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11,
173
                 &table_mb_btype[0][1], 2, 1,
174
                 &table_mb_btype[0][0], 2, 1, 64);
175
        init_rl(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]);
176
        init_rl(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]);
177

    
178
        INIT_2D_VLC_RL(ff_rl_mpeg1, 680);
179
        INIT_2D_VLC_RL(ff_rl_mpeg2, 674);
180
    }
181
}
182

    
183
static inline int get_dmv(MpegEncContext *s)
184
{
185
    if(get_bits1(&s->gb))
186
        return 1 - (get_bits1(&s->gb) << 1);
187
    else
188
        return 0;
189
}
190

    
191
static inline int get_qscale(MpegEncContext *s)
192
{
193
    int qscale = get_bits(&s->gb, 5);
194
    if (s->q_scale_type) {
195
        return non_linear_qscale[qscale];
196
    } else {
197
        return qscale << 1;
198
    }
199
}
200

    
201
/* motion type (for MPEG-2) */
202
#define MT_FIELD 1
203
#define MT_FRAME 2
204
#define MT_16X8  2
205
#define MT_DMV   3
206

    
207
static int mpeg_decode_mb(MpegEncContext *s,
208
                          DCTELEM block[12][64])
209
{
210
    int i, j, k, cbp, val, mb_type, motion_type;
211
    const int mb_block_count = 4 + (1<< s->chroma_format);
212

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

    
215
    assert(s->mb_skipped==0);
216

    
217
    if (s->mb_skip_run-- != 0) {
218
        if (s->pict_type == FF_P_TYPE) {
219
            s->mb_skipped = 1;
220
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
221
        } else {
222
            int mb_type;
223

    
224
            if(s->mb_x)
225
                mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1];
226
            else
227
                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
228
            if(IS_INTRA(mb_type))
229
                return -1;
230

    
231
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]=
232
                mb_type | MB_TYPE_SKIP;
233
//            assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
234

    
235
            if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0)
236
                s->mb_skipped = 1;
237
        }
238

    
239
        return 0;
240
    }
241

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

    
277
        if(!s->chroma_y_shift){
278
            s->dsp.clear_blocks(s->block[6]);
279
        }
280

    
281
        /* compute DCT type */
282
        if (s->picture_structure == PICT_FRAME && //FIXME add an interlaced_dct coded var?
283
            !s->frame_pred_frame_dct) {
284
            s->interlaced_dct = get_bits1(&s->gb);
285
        }
286

    
287
        if (IS_QUANT(mb_type))
288
            s->qscale = get_qscale(s);
289

    
290
        if (s->concealment_motion_vectors) {
291
            /* just parse them */
292
            if (s->picture_structure != PICT_FRAME)
293
                skip_bits1(&s->gb); /* field select */
294

    
295
            s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
296
                mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
297
            s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
298
                mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
299

    
300
            skip_bits1(&s->gb); /* marker */
301
        }else
302
            memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
303
        s->mb_intra = 1;
304
        //if 1, we memcpy blocks in xvmcvideo
305
        if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1){
306
            ff_xvmc_pack_pblocks(s,-1);//inter are always full blocks
307
            if(s->swap_uv){
308
                exchange_uv(s);
309
            }
310
        }
311

    
312
        if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
313
            if(s->flags2 & CODEC_FLAG2_FAST){
314
                for(i=0;i<6;i++) {
315
                    mpeg2_fast_decode_block_intra(s, *s->pblocks[i], i);
316
                }
317
            }else{
318
                for(i=0;i<mb_block_count;i++) {
319
                    if (mpeg2_decode_block_intra(s, *s->pblocks[i], i) < 0)
320
                        return -1;
321
                }
322
            }
323
        } else {
324
            for(i=0;i<6;i++) {
325
                if (mpeg1_decode_block_intra(s, *s->pblocks[i], i) < 0)
326
                    return -1;
327
            }
328
        }
329
    } else {
330
        if (mb_type & MB_TYPE_ZERO_MV){
331
            assert(mb_type & MB_TYPE_CBP);
332

    
333
            s->mv_dir = MV_DIR_FORWARD;
334
            if(s->picture_structure == PICT_FRAME){
335
                if(!s->frame_pred_frame_dct)
336
                    s->interlaced_dct = get_bits1(&s->gb);
337
                s->mv_type = MV_TYPE_16X16;
338
            }else{
339
                s->mv_type = MV_TYPE_FIELD;
340
                mb_type |= MB_TYPE_INTERLACED;
341
                s->field_select[0][0]= s->picture_structure - 1;
342
            }
343

    
344
            if (IS_QUANT(mb_type))
345
                s->qscale = get_qscale(s);
346

    
347
            s->last_mv[0][0][0] = 0;
348
            s->last_mv[0][0][1] = 0;
349
            s->last_mv[0][1][0] = 0;
350
            s->last_mv[0][1][1] = 0;
351
            s->mv[0][0][0] = 0;
352
            s->mv[0][0][1] = 0;
353
        }else{
354
            assert(mb_type & MB_TYPE_L0L1);
355
//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
356
            /* get additional motion vector type */
357
            if (s->frame_pred_frame_dct)
358
                motion_type = MT_FRAME;
359
            else{
360
                motion_type = get_bits(&s->gb, 2);
361
                if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
362
                    s->interlaced_dct = get_bits1(&s->gb);
363
            }
364

    
365
            if (IS_QUANT(mb_type))
366
                s->qscale = get_qscale(s);
367

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

    
460

    
461
                        s->last_mv[i][0][1] = my<<1;
462
                        s->last_mv[i][1][1] = my<<1;
463

    
464
                        s->mv[i][0][0] = mx;
465
                        s->mv[i][0][1] = my;
466
                        s->mv[i][1][0] = mx;//not used
467
                        s->mv[i][1][1] = my;//not used
468

    
469
                        if (s->picture_structure == PICT_FRAME) {
470
                            mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
471

    
472
                            //m = 1 + 2 * s->top_field_first;
473
                            m = s->top_field_first ? 1 : 3;
474

    
475
                            /* top -> top pred */
476
                            s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
477
                            s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
478
                            m = 4 - m;
479
                            s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
480
                            s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
481
                        } else {
482
                            mb_type |= MB_TYPE_16x16;
483

    
484
                            s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
485
                            s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
486
                            if(s->picture_structure == PICT_TOP_FIELD)
487
                                s->mv[i][2][1]--;
488
                            else
489
                                s->mv[i][2][1]++;
490
                        }
491
                    }
492
                }
493
                break;
494
            default:
495
                av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
496
                return -1;
497
            }
498
        }
499

    
500
        s->mb_intra = 0;
501
        if (HAS_CBP(mb_type)) {
502
            s->dsp.clear_blocks(s->block[0]);
503

    
504
            cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
505
            if(mb_block_count > 6){
506
                 cbp<<= mb_block_count-6;
507
                 cbp |= get_bits(&s->gb, mb_block_count-6);
508
                 s->dsp.clear_blocks(s->block[6]);
509
            }
510
            if (cbp <= 0){
511
                av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
512
                return -1;
513
            }
514

    
515
            //if 1, we memcpy blocks in xvmcvideo
516
            if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1){
517
                ff_xvmc_pack_pblocks(s,cbp);
518
                if(s->swap_uv){
519
                    exchange_uv(s);
520
                }
521
            }
522

    
523
            if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
524
                if(s->flags2 & CODEC_FLAG2_FAST){
525
                    for(i=0;i<6;i++) {
526
                        if(cbp & 32) {
527
                            mpeg2_fast_decode_block_non_intra(s, *s->pblocks[i], i);
528
                        } else {
529
                            s->block_last_index[i] = -1;
530
                        }
531
                        cbp+=cbp;
532
                    }
533
                }else{
534
                    cbp<<= 12-mb_block_count;
535

    
536
                    for(i=0;i<mb_block_count;i++) {
537
                        if ( cbp & (1<<11) ) {
538
                            if (mpeg2_decode_block_non_intra(s, *s->pblocks[i], i) < 0)
539
                                return -1;
540
                        } else {
541
                            s->block_last_index[i] = -1;
542
                        }
543
                        cbp+=cbp;
544
                    }
545
                }
546
            } else {
547
                if(s->flags2 & CODEC_FLAG2_FAST){
548
                    for(i=0;i<6;i++) {
549
                        if (cbp & 32) {
550
                            mpeg1_fast_decode_block_inter(s, *s->pblocks[i], i);
551
                        } else {
552
                            s->block_last_index[i] = -1;
553
                        }
554
                        cbp+=cbp;
555
                    }
556
                }else{
557
                    for(i=0;i<6;i++) {
558
                        if (cbp & 32) {
559
                            if (mpeg1_decode_block_inter(s, *s->pblocks[i], i) < 0)
560
                                return -1;
561
                        } else {
562
                            s->block_last_index[i] = -1;
563
                        }
564
                        cbp+=cbp;
565
                    }
566
                }
567
            }
568
        }else{
569
            for(i=0;i<12;i++)
570
                s->block_last_index[i] = -1;
571
        }
572
    }
573

    
574
    s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
575

    
576
    return 0;
577
}
578

    
579
/* as H.263, but only 17 codes */
580
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
581
{
582
    int code, sign, val, l, shift;
583

    
584
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
585
    if (code == 0) {
586
        return pred;
587
    }
588
    if (code < 0) {
589
        return 0xffff;
590
    }
591

    
592
    sign = get_bits1(&s->gb);
593
    shift = fcode - 1;
594
    val = code;
595
    if (shift) {
596
        val = (val - 1) << shift;
597
        val |= get_bits(&s->gb, shift);
598
        val++;
599
    }
600
    if (sign)
601
        val = -val;
602
    val += pred;
603

    
604
    /* modulo decoding */
605
    l= INT_BIT - 5 - shift;
606
    val = (val<<l)>>l;
607
    return val;
608
}
609

    
610
static inline int mpeg1_decode_block_intra(MpegEncContext *s,
611
                               DCTELEM *block,
612
                               int n)
613
{
614
    int level, dc, diff, i, j, run;
615
    int component;
616
    RLTable *rl = &ff_rl_mpeg1;
617
    uint8_t * const scantable= s->intra_scantable.permutated;
618
    const uint16_t *quant_matrix= s->intra_matrix;
619
    const int qscale= s->qscale;
620

    
621
    /* DC coefficient */
622
    component = (n <= 3 ? 0 : n - 4 + 1);
623
    diff = decode_dc(&s->gb, component);
624
    if (diff >= 0xffff)
625
        return -1;
626
    dc = s->last_dc[component];
627
    dc += diff;
628
    s->last_dc[component] = dc;
629
    block[0] = dc*quant_matrix[0];
630
    dprintf(s->avctx, "dc=%d diff=%d\n", dc, diff);
631
    i = 0;
632
    {
633
        OPEN_READER(re, &s->gb);
634
        /* now quantify & encode AC coefficients */
635
        for(;;) {
636
            UPDATE_CACHE(re, &s->gb);
637
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
638

    
639
            if(level == 127){
640
                break;
641
            } else if(level != 0) {
642
                i += run;
643
                j = scantable[i];
644
                level= (level*qscale*quant_matrix[j])>>4;
645
                level= (level-1)|1;
646
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
647
                LAST_SKIP_BITS(re, &s->gb, 1);
648
            } else {
649
                /* escape */
650
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
651
                UPDATE_CACHE(re, &s->gb);
652
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
653
                if (level == -128) {
654
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
655
                } else if (level == 0) {
656
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
657
                }
658
                i += run;
659
                j = scantable[i];
660
                if(level<0){
661
                    level= -level;
662
                    level= (level*qscale*quant_matrix[j])>>4;
663
                    level= (level-1)|1;
664
                    level= -level;
665
                }else{
666
                    level= (level*qscale*quant_matrix[j])>>4;
667
                    level= (level-1)|1;
668
                }
669
            }
670
            if (i > 63){
671
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
672
                return -1;
673
            }
674

    
675
            block[j] = level;
676
        }
677
        CLOSE_READER(re, &s->gb);
678
    }
679
    s->block_last_index[n] = i;
680
   return 0;
681
}
682

    
683
int ff_mpeg1_decode_block_intra(MpegEncContext *s,
684
                                DCTELEM *block,
685
                                int n)
686
{
687
    return mpeg1_decode_block_intra(s, block, n);
688
}
689

    
690
static inline int mpeg1_decode_block_inter(MpegEncContext *s,
691
                               DCTELEM *block,
692
                               int n)
693
{
694
    int level, i, j, run;
695
    RLTable *rl = &ff_rl_mpeg1;
696
    uint8_t * const scantable= s->intra_scantable.permutated;
697
    const uint16_t *quant_matrix= s->inter_matrix;
698
    const int qscale= s->qscale;
699

    
700
    {
701
        OPEN_READER(re, &s->gb);
702
        i = -1;
703
        // special case for first coefficient, no need to add second VLC table
704
        UPDATE_CACHE(re, &s->gb);
705
        if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
706
            level= (3*qscale*quant_matrix[0])>>5;
707
            level= (level-1)|1;
708
            if(GET_CACHE(re, &s->gb)&0x40000000)
709
                level= -level;
710
            block[0] = level;
711
            i++;
712
            SKIP_BITS(re, &s->gb, 2);
713
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
714
                goto end;
715
        }
716
#if MIN_CACHE_BITS < 19
717
        UPDATE_CACHE(re, &s->gb);
718
#endif
719
        /* now quantify & encode AC coefficients */
720
        for(;;) {
721
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
722

    
723
            if(level != 0) {
724
                i += run;
725
                j = scantable[i];
726
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
727
                level= (level-1)|1;
728
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
729
                SKIP_BITS(re, &s->gb, 1);
730
            } else {
731
                /* escape */
732
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
733
                UPDATE_CACHE(re, &s->gb);
734
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
735
                if (level == -128) {
736
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
737
                } else if (level == 0) {
738
                    level = SHOW_UBITS(re, &s->gb, 8)      ; SKIP_BITS(re, &s->gb, 8);
739
                }
740
                i += run;
741
                j = scantable[i];
742
                if(level<0){
743
                    level= -level;
744
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
745
                    level= (level-1)|1;
746
                    level= -level;
747
                }else{
748
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
749
                    level= (level-1)|1;
750
                }
751
            }
752
            if (i > 63){
753
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
754
                return -1;
755
            }
756

    
757
            block[j] = level;
758
#if MIN_CACHE_BITS < 19
759
            UPDATE_CACHE(re, &s->gb);
760
#endif
761
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
762
                break;
763
#if MIN_CACHE_BITS >= 19
764
            UPDATE_CACHE(re, &s->gb);
765
#endif
766
        }
767
end:
768
        LAST_SKIP_BITS(re, &s->gb, 2);
769
        CLOSE_READER(re, &s->gb);
770
    }
771
    s->block_last_index[n] = i;
772
    return 0;
773
}
774

    
775
static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n)
776
{
777
    int level, i, j, run;
778
    RLTable *rl = &ff_rl_mpeg1;
779
    uint8_t * const scantable= s->intra_scantable.permutated;
780
    const int qscale= s->qscale;
781

    
782
    {
783
        OPEN_READER(re, &s->gb);
784
        i = -1;
785
        // special case for first coefficient, no need to add second VLC table
786
        UPDATE_CACHE(re, &s->gb);
787
        if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
788
            level= (3*qscale)>>1;
789
            level= (level-1)|1;
790
            if(GET_CACHE(re, &s->gb)&0x40000000)
791
                level= -level;
792
            block[0] = level;
793
            i++;
794
            SKIP_BITS(re, &s->gb, 2);
795
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
796
                goto end;
797
        }
798
#if MIN_CACHE_BITS < 19
799
        UPDATE_CACHE(re, &s->gb);
800
#endif
801

    
802
        /* now quantify & encode AC coefficients */
803
        for(;;) {
804
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
805

    
806
            if(level != 0) {
807
                i += run;
808
                j = scantable[i];
809
                level= ((level*2+1)*qscale)>>1;
810
                level= (level-1)|1;
811
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
812
                SKIP_BITS(re, &s->gb, 1);
813
            } else {
814
                /* escape */
815
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
816
                UPDATE_CACHE(re, &s->gb);
817
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
818
                if (level == -128) {
819
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
820
                } else if (level == 0) {
821
                    level = SHOW_UBITS(re, &s->gb, 8)      ; SKIP_BITS(re, &s->gb, 8);
822
                }
823
                i += run;
824
                j = scantable[i];
825
                if(level<0){
826
                    level= -level;
827
                    level= ((level*2+1)*qscale)>>1;
828
                    level= (level-1)|1;
829
                    level= -level;
830
                }else{
831
                    level= ((level*2+1)*qscale)>>1;
832
                    level= (level-1)|1;
833
                }
834
            }
835

    
836
            block[j] = level;
837
#if MIN_CACHE_BITS < 19
838
            UPDATE_CACHE(re, &s->gb);
839
#endif
840
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
841
                break;
842
#if MIN_CACHE_BITS >= 19
843
            UPDATE_CACHE(re, &s->gb);
844
#endif
845
        }
846
end:
847
        LAST_SKIP_BITS(re, &s->gb, 2);
848
        CLOSE_READER(re, &s->gb);
849
    }
850
    s->block_last_index[n] = i;
851
    return 0;
852
}
853

    
854

    
855
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
856
                               DCTELEM *block,
857
                               int n)
858
{
859
    int level, i, j, run;
860
    RLTable *rl = &ff_rl_mpeg1;
861
    uint8_t * const scantable= s->intra_scantable.permutated;
862
    const uint16_t *quant_matrix;
863
    const int qscale= s->qscale;
864
    int mismatch;
865

    
866
    mismatch = 1;
867

    
868
    {
869
        OPEN_READER(re, &s->gb);
870
        i = -1;
871
        if (n < 4)
872
            quant_matrix = s->inter_matrix;
873
        else
874
            quant_matrix = s->chroma_inter_matrix;
875

    
876
        // special case for first coefficient, no need to add second VLC table
877
        UPDATE_CACHE(re, &s->gb);
878
        if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
879
            level= (3*qscale*quant_matrix[0])>>5;
880
            if(GET_CACHE(re, &s->gb)&0x40000000)
881
                level= -level;
882
            block[0] = level;
883
            mismatch ^= level;
884
            i++;
885
            SKIP_BITS(re, &s->gb, 2);
886
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
887
                goto end;
888
        }
889
#if MIN_CACHE_BITS < 19
890
        UPDATE_CACHE(re, &s->gb);
891
#endif
892

    
893
        /* now quantify & encode AC coefficients */
894
        for(;;) {
895
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
896

    
897
            if(level != 0) {
898
                i += run;
899
                j = scantable[i];
900
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
901
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
902
                SKIP_BITS(re, &s->gb, 1);
903
            } else {
904
                /* escape */
905
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
906
                UPDATE_CACHE(re, &s->gb);
907
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
908

    
909
                i += run;
910
                j = scantable[i];
911
                if(level<0){
912
                    level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
913
                    level= -level;
914
                }else{
915
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
916
                }
917
            }
918
            if (i > 63){
919
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
920
                return -1;
921
            }
922

    
923
            mismatch ^= level;
924
            block[j] = level;
925
#if MIN_CACHE_BITS < 19
926
            UPDATE_CACHE(re, &s->gb);
927
#endif
928
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
929
                break;
930
#if MIN_CACHE_BITS >= 19
931
            UPDATE_CACHE(re, &s->gb);
932
#endif
933
        }
934
end:
935
        LAST_SKIP_BITS(re, &s->gb, 2);
936
        CLOSE_READER(re, &s->gb);
937
    }
938
    block[63] ^= (mismatch & 1);
939

    
940
    s->block_last_index[n] = i;
941
    return 0;
942
}
943

    
944
static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
945
                               DCTELEM *block,
946
                               int n)
947
{
948
    int level, i, j, run;
949
    RLTable *rl = &ff_rl_mpeg1;
950
    uint8_t * const scantable= s->intra_scantable.permutated;
951
    const int qscale= s->qscale;
952
    OPEN_READER(re, &s->gb);
953
    i = -1;
954

    
955
    // special case for first coefficient, no need to add second VLC table
956
    UPDATE_CACHE(re, &s->gb);
957
    if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
958
        level= (3*qscale)>>1;
959
        if(GET_CACHE(re, &s->gb)&0x40000000)
960
            level= -level;
961
        block[0] = level;
962
        i++;
963
        SKIP_BITS(re, &s->gb, 2);
964
        if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
965
            goto end;
966
    }
967
#if MIN_CACHE_BITS < 19
968
    UPDATE_CACHE(re, &s->gb);
969
#endif
970

    
971
    /* now quantify & encode AC coefficients */
972
    for(;;) {
973
        GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
974

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

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

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

    
1014

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

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

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

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

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

    
1091
    s->block_last_index[n] = i;
1092
    return 0;
1093
}
1094

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

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

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

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

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

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

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

    
1176
} Mpeg1Context;
1177

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

    
1184
    /* we need some permutation to store matrices,
1185
     * until MPV_common_init() sets the real permutation. */
1186
    for(i=0;i<64;i++)
1187
       s2->dsp.idct_permutation[i]=i;
1188

    
1189
    MPV_decode_defaults(s2);
1190

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

    
1197
    s->mpeg_enc_ctx_allocated = 0;
1198
    s->mpeg_enc_ctx.picture_number = 0;
1199
    s->repeat_field = 0;
1200
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1201
    avctx->color_range= AVCOL_RANGE_MPEG;
1202
    if (avctx->codec->id == CODEC_ID_MPEG1VIDEO)
1203
        avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1204
    else
1205
        avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
1206
    return 0;
1207
}
1208

    
1209
static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
1210
                                     const uint8_t *new_perm){
1211
    uint16_t temp_matrix[64];
1212
    int i;
1213

    
1214
    memcpy(temp_matrix,matrix,64*sizeof(uint16_t));
1215

    
1216
    for(i=0;i<64;i++){
1217
        matrix[new_perm[i]] = temp_matrix[old_perm[i]];
1218
    }
1219
}
1220

    
1221
static enum PixelFormat mpeg_get_pixelformat(AVCodecContext *avctx){
1222
    Mpeg1Context *s1 = avctx->priv_data;
1223
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1224

    
1225
    if(avctx->xvmc_acceleration)
1226
        return avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
1227
    else if(avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){
1228
        if(avctx->codec_id == CODEC_ID_MPEG1VIDEO)
1229
            return PIX_FMT_VDPAU_MPEG1;
1230
        else
1231
            return PIX_FMT_VDPAU_MPEG2;
1232
    }else{
1233
        if(s->chroma_format <  2)
1234
            return avctx->get_format(avctx,ff_hwaccel_pixfmt_list_420);
1235
        else if(s->chroma_format == 2)
1236
            return PIX_FMT_YUV422P;
1237
        else
1238
            return PIX_FMT_YUV444P;
1239
    }
1240
}
1241

    
1242
/* Call this function when we know all parameters.
1243
 * It may be called in different places for MPEG-1 and MPEG-2. */
1244
static int mpeg_decode_postinit(AVCodecContext *avctx){
1245
    Mpeg1Context *s1 = avctx->priv_data;
1246
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1247
    uint8_t old_permutation[64];
1248

    
1249
    if (
1250
        (s1->mpeg_enc_ctx_allocated == 0)||
1251
        avctx->coded_width  != s->width ||
1252
        avctx->coded_height != s->height||
1253
        s1->save_width != s->width ||
1254
        s1->save_height != s->height ||
1255
        s1->save_aspect_info != s->aspect_ratio_info||
1256
        s1->save_progressive_seq != s->progressive_sequence ||
1257
        0)
1258
    {
1259

    
1260
        if (s1->mpeg_enc_ctx_allocated) {
1261
            ParseContext pc= s->parse_context;
1262
            s->parse_context.buffer=0;
1263
            MPV_common_end(s);
1264
            s->parse_context= pc;
1265
        }
1266

    
1267
        if( (s->width == 0 )||(s->height == 0))
1268
            return -2;
1269

    
1270
        avcodec_set_dimensions(avctx, s->width, s->height);
1271
        avctx->bit_rate = s->bit_rate;
1272
        s1->save_aspect_info = s->aspect_ratio_info;
1273
        s1->save_width = s->width;
1274
        s1->save_height = s->height;
1275
        s1->save_progressive_seq = s->progressive_sequence;
1276

    
1277
        /* low_delay may be forced, in this case we will have B-frames
1278
         * that behave like P-frames. */
1279
        avctx->has_b_frames = !(s->low_delay);
1280

    
1281
        assert((avctx->sub_id==1) == (avctx->codec_id==CODEC_ID_MPEG1VIDEO));
1282
        if(avctx->codec_id==CODEC_ID_MPEG1VIDEO){
1283
            //MPEG-1 fps
1284
            avctx->time_base.den= ff_frame_rate_tab[s->frame_rate_index].num;
1285
            avctx->time_base.num= ff_frame_rate_tab[s->frame_rate_index].den;
1286
            //MPEG-1 aspect
1287
            avctx->sample_aspect_ratio= av_d2q(
1288
                    1.0/ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1289
            avctx->ticks_per_frame=1;
1290
        }else{//MPEG-2
1291
        //MPEG-2 fps
1292
            av_reduce(
1293
                &s->avctx->time_base.den,
1294
                &s->avctx->time_base.num,
1295
                ff_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num*2,
1296
                ff_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1297
                1<<30);
1298
            avctx->ticks_per_frame=2;
1299
        //MPEG-2 aspect
1300
            if(s->aspect_ratio_info > 1){
1301
                //we ignore the spec here as reality does not match the spec, see for example
1302
                // res_change_ffmpeg_aspect.ts and sequence-display-aspect.mpg
1303
                if( (s1->pan_scan.width == 0 )||(s1->pan_scan.height == 0) || 1){
1304
                    s->avctx->sample_aspect_ratio=
1305
                        av_div_q(
1306
                         ff_mpeg2_aspect[s->aspect_ratio_info],
1307
                         (AVRational){s->width, s->height}
1308
                         );
1309
                }else{
1310
                    s->avctx->sample_aspect_ratio=
1311
                        av_div_q(
1312
                         ff_mpeg2_aspect[s->aspect_ratio_info],
1313
                         (AVRational){s1->pan_scan.width, s1->pan_scan.height}
1314
                        );
1315
                }
1316
            }else{
1317
                s->avctx->sample_aspect_ratio=
1318
                    ff_mpeg2_aspect[s->aspect_ratio_info];
1319
            }
1320
        }//MPEG-2
1321

    
1322
        avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1323
        avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
1324
        //until then pix_fmt may be changed right after codec init
1325
        if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT ||
1326
            avctx->hwaccel ||
1327
            s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU )
1328
            if( avctx->idct_algo == FF_IDCT_AUTO )
1329
                avctx->idct_algo = FF_IDCT_SIMPLE;
1330

    
1331
        /* Quantization matrices may need reordering
1332
         * if DCT permutation is changed. */
1333
        memcpy(old_permutation,s->dsp.idct_permutation,64*sizeof(uint8_t));
1334

    
1335
        if (MPV_common_init(s) < 0)
1336
            return -2;
1337

    
1338
        quant_matrix_rebuild(s->intra_matrix,       old_permutation,s->dsp.idct_permutation);
1339
        quant_matrix_rebuild(s->inter_matrix,       old_permutation,s->dsp.idct_permutation);
1340
        quant_matrix_rebuild(s->chroma_intra_matrix,old_permutation,s->dsp.idct_permutation);
1341
        quant_matrix_rebuild(s->chroma_inter_matrix,old_permutation,s->dsp.idct_permutation);
1342

    
1343
        s1->mpeg_enc_ctx_allocated = 1;
1344
    }
1345
    return 0;
1346
}
1347

    
1348
static int mpeg1_decode_picture(AVCodecContext *avctx,
1349
                                const uint8_t *buf, int buf_size)
1350
{
1351
    Mpeg1Context *s1 = avctx->priv_data;
1352
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1353
    int ref, f_code, vbv_delay;
1354

    
1355
    if(mpeg_decode_postinit(s->avctx) < 0)
1356
       return -2;
1357

    
1358
    init_get_bits(&s->gb, buf, buf_size*8);
1359

    
1360
    ref = get_bits(&s->gb, 10); /* temporal ref */
1361
    s->pict_type = get_bits(&s->gb, 3);
1362
    if(s->pict_type == 0 || s->pict_type > 3)
1363
        return -1;
1364

    
1365
    vbv_delay= get_bits(&s->gb, 16);
1366
    if (s->pict_type == FF_P_TYPE || s->pict_type == FF_B_TYPE) {
1367
        s->full_pel[0] = get_bits1(&s->gb);
1368
        f_code = get_bits(&s->gb, 3);
1369
        if (f_code == 0 && avctx->error_recognition >= FF_ER_COMPLIANT)
1370
            return -1;
1371
        s->mpeg_f_code[0][0] = f_code;
1372
        s->mpeg_f_code[0][1] = f_code;
1373
    }
1374
    if (s->pict_type == FF_B_TYPE) {
1375
        s->full_pel[1] = get_bits1(&s->gb);
1376
        f_code = get_bits(&s->gb, 3);
1377
        if (f_code == 0 && avctx->error_recognition >= FF_ER_COMPLIANT)
1378
            return -1;
1379
        s->mpeg_f_code[1][0] = f_code;
1380
        s->mpeg_f_code[1][1] = f_code;
1381
    }
1382
    s->current_picture.pict_type= s->pict_type;
1383
    s->current_picture.key_frame= s->pict_type == FF_I_TYPE;
1384

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

    
1388
    s->y_dc_scale = 8;
1389
    s->c_dc_scale = 8;
1390
    s->first_slice = 1;
1391
    return 0;
1392
}
1393

    
1394
static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1395
{
1396
    MpegEncContext *s= &s1->mpeg_enc_ctx;
1397
    int horiz_size_ext, vert_size_ext;
1398
    int bit_rate_ext;
1399

    
1400
    skip_bits(&s->gb, 1); /* profile and level esc*/
1401
    s->avctx->profile= get_bits(&s->gb, 3);
1402
    s->avctx->level= get_bits(&s->gb, 4);
1403
    s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1404
    s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1405
    horiz_size_ext = get_bits(&s->gb, 2);
1406
    vert_size_ext = get_bits(&s->gb, 2);
1407
    s->width |= (horiz_size_ext << 12);
1408
    s->height |= (vert_size_ext << 12);
1409
    bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1410
    s->bit_rate += (bit_rate_ext << 18) * 400;
1411
    skip_bits1(&s->gb); /* marker */
1412
    s->avctx->rc_buffer_size += get_bits(&s->gb, 8)*1024*16<<10;
1413

    
1414
    s->low_delay = get_bits1(&s->gb);
1415
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
1416

    
1417
    s1->frame_rate_ext.num = get_bits(&s->gb, 2)+1;
1418
    s1->frame_rate_ext.den = get_bits(&s->gb, 5)+1;
1419

    
1420
    dprintf(s->avctx, "sequence extension\n");
1421
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
1422
    s->avctx->sub_id = 2; /* indicates MPEG-2 found */
1423

    
1424
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1425
        av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d vbv buffer: %d, bitrate:%d\n",
1426
               s->avctx->profile, s->avctx->level, s->avctx->rc_buffer_size, s->bit_rate);
1427

    
1428
}
1429

    
1430
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1431
{
1432
    MpegEncContext *s= &s1->mpeg_enc_ctx;
1433
    int color_description, w, h;
1434

    
1435
    skip_bits(&s->gb, 3); /* video format */
1436
    color_description= get_bits1(&s->gb);
1437
    if(color_description){
1438
        s->avctx->color_primaries= get_bits(&s->gb, 8);
1439
        s->avctx->color_trc      = get_bits(&s->gb, 8);
1440
        s->avctx->colorspace     = get_bits(&s->gb, 8);
1441
    }
1442
    w= get_bits(&s->gb, 14);
1443
    skip_bits(&s->gb, 1); //marker
1444
    h= get_bits(&s->gb, 14);
1445
    skip_bits(&s->gb, 1); //marker
1446

    
1447
    s1->pan_scan.width= 16*w;
1448
    s1->pan_scan.height=16*h;
1449

    
1450
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1451
        av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1452
}
1453

    
1454
static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1455
{
1456
    MpegEncContext *s= &s1->mpeg_enc_ctx;
1457
    int i,nofco;
1458

    
1459
    nofco = 1;
1460
    if(s->progressive_sequence){
1461
        if(s->repeat_first_field){
1462
            nofco++;
1463
            if(s->top_field_first)
1464
                nofco++;
1465
        }
1466
    }else{
1467
        if(s->picture_structure == PICT_FRAME){
1468
            nofco++;
1469
            if(s->repeat_first_field)
1470
                nofco++;
1471
        }
1472
    }
1473
    for(i=0; i<nofco; i++){
1474
        s1->pan_scan.position[i][0]= get_sbits(&s->gb, 16);
1475
        skip_bits(&s->gb, 1); //marker
1476
        s1->pan_scan.position[i][1]= get_sbits(&s->gb, 16);
1477
        skip_bits(&s->gb, 1); //marker
1478
    }
1479

    
1480
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1481
        av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n",
1482
            s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1483
            s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1484
            s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]
1485
        );
1486
}
1487

    
1488
static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], uint16_t matrix1[64], int intra){
1489
    int i;
1490

    
1491
    for(i=0; i<64; i++) {
1492
        int j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1493
        int v = get_bits(&s->gb, 8);
1494
        if(v==0){
1495
            av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1496
            return -1;
1497
        }
1498
        if(intra && i==0 && v!=8){
1499
            av_log(s->avctx, AV_LOG_ERROR, "intra matrix invalid, ignoring\n");
1500
            v= 8; // needed by pink.mpg / issue1046
1501
        }
1502
        matrix0[j] = v;
1503
        if(matrix1)
1504
            matrix1[j] = v;
1505
    }
1506
    return 0;
1507
}
1508

    
1509
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1510
{
1511
    dprintf(s->avctx, "matrix extension\n");
1512

    
1513
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1514
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1515
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, NULL           , 1);
1516
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, NULL           , 0);
1517
}
1518

    
1519
static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1520
{
1521
    MpegEncContext *s= &s1->mpeg_enc_ctx;
1522

    
1523
    s->full_pel[0] = s->full_pel[1] = 0;
1524
    s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1525
    s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1526
    s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1527
    s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1528
    if(!s->pict_type && s1->mpeg_enc_ctx_allocated){
1529
        av_log(s->avctx, AV_LOG_ERROR, "Missing picture start code, guessing missing values\n");
1530
        if(s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1]==15){
1531
            if(s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1532
                s->pict_type= FF_I_TYPE;
1533
            else
1534
                s->pict_type= FF_P_TYPE;
1535
        }else
1536
            s->pict_type= FF_B_TYPE;
1537
        s->current_picture.pict_type= s->pict_type;
1538
        s->current_picture.key_frame= s->pict_type == FF_I_TYPE;
1539
        s->first_slice= 1;
1540
    }
1541
    s->intra_dc_precision = get_bits(&s->gb, 2);
1542
    s->picture_structure = get_bits(&s->gb, 2);
1543
    s->top_field_first = get_bits1(&s->gb);
1544
    s->frame_pred_frame_dct = get_bits1(&s->gb);
1545
    s->concealment_motion_vectors = get_bits1(&s->gb);
1546
    s->q_scale_type = get_bits1(&s->gb);
1547
    s->intra_vlc_format = get_bits1(&s->gb);
1548
    s->alternate_scan = get_bits1(&s->gb);
1549
    s->repeat_first_field = get_bits1(&s->gb);
1550
    s->chroma_420_type = get_bits1(&s->gb);
1551
    s->progressive_frame = get_bits1(&s->gb);
1552

    
1553
    if(s->picture_structure == PICT_FRAME){
1554
        s->first_field=0;
1555
        s->v_edge_pos= 16*s->mb_height;
1556
    }else{
1557
        s->first_field ^= 1;
1558
        s->v_edge_pos=  8*s->mb_height;
1559
        memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
1560
    }
1561

    
1562
    if(s->alternate_scan){
1563
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
1564
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
1565
    }else{
1566
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
1567
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
1568
    }
1569

    
1570
    /* composite display not parsed */
1571
    dprintf(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1572
    dprintf(s->avctx, "picture_structure=%d\n", s->picture_structure);
1573
    dprintf(s->avctx, "top field first=%d\n", s->top_field_first);
1574
    dprintf(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1575
    dprintf(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1576
    dprintf(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1577
    dprintf(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1578
    dprintf(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1579
    dprintf(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1580
}
1581

    
1582
static void mpeg_decode_extension(AVCodecContext *avctx,
1583
                                  const uint8_t *buf, int buf_size)
1584
{
1585
    Mpeg1Context *s1 = avctx->priv_data;
1586
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1587
    int ext_type;
1588

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

    
1591
    ext_type = get_bits(&s->gb, 4);
1592
    switch(ext_type) {
1593
    case 0x1:
1594
        mpeg_decode_sequence_extension(s1);
1595
        break;
1596
    case 0x2:
1597
        mpeg_decode_sequence_display_extension(s1);
1598
        break;
1599
    case 0x3:
1600
        mpeg_decode_quant_matrix_extension(s);
1601
        break;
1602
    case 0x7:
1603
        mpeg_decode_picture_display_extension(s1);
1604
        break;
1605
    case 0x8:
1606
        mpeg_decode_picture_coding_extension(s1);
1607
        break;
1608
    }
1609
}
1610

    
1611
static void exchange_uv(MpegEncContext *s){
1612
    DCTELEM (*tmp)[64];
1613

    
1614
    tmp           = s->pblocks[4];
1615
    s->pblocks[4] = s->pblocks[5];
1616
    s->pblocks[5] = tmp;
1617
}
1618

    
1619
static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size){
1620
    AVCodecContext *avctx= s->avctx;
1621
    Mpeg1Context *s1 = (Mpeg1Context*)s;
1622

    
1623
    /* start frame decoding */
1624
    if(s->first_field || s->picture_structure==PICT_FRAME){
1625
        if(MPV_frame_start(s, avctx) < 0)
1626
            return -1;
1627

    
1628
        ff_er_frame_start(s);
1629

    
1630
        /* first check if we must repeat the frame */
1631
        s->current_picture_ptr->repeat_pict = 0;
1632
        if (s->repeat_first_field) {
1633
            if (s->progressive_sequence) {
1634
                if (s->top_field_first)
1635
                    s->current_picture_ptr->repeat_pict = 4;
1636
                else
1637
                    s->current_picture_ptr->repeat_pict = 2;
1638
            } else if (s->progressive_frame) {
1639
                s->current_picture_ptr->repeat_pict = 1;
1640
            }
1641
        }
1642

    
1643
        *s->current_picture_ptr->pan_scan= s1->pan_scan;
1644
    }else{ //second field
1645
            int i;
1646

    
1647
            if(!s->current_picture_ptr){
1648
                av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1649
                return -1;
1650
            }
1651

    
1652
            for(i=0; i<4; i++){
1653
                s->current_picture.data[i] = s->current_picture_ptr->data[i];
1654
                if(s->picture_structure == PICT_BOTTOM_FIELD){
1655
                    s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
1656
                }
1657
            }
1658
    }
1659

    
1660
    if (avctx->hwaccel) {
1661
        if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
1662
            return -1;
1663
    }
1664

    
1665
// MPV_frame_start will call this function too,
1666
// but we need to call it on every field
1667
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1668
        if(ff_xvmc_field_start(s,avctx) < 0)
1669
            return -1;
1670

    
1671
    return 0;
1672
}
1673

    
1674
#define DECODE_SLICE_ERROR -1
1675
#define DECODE_SLICE_OK 0
1676

    
1677
/**
1678
 * decodes a slice. MpegEncContext.mb_y must be set to the MB row from the startcode
1679
 * @return DECODE_SLICE_ERROR if the slice is damaged<br>
1680
 *         DECODE_SLICE_OK if this slice is ok<br>
1681
 */
1682
static int mpeg_decode_slice(Mpeg1Context *s1, int mb_y,
1683
                             const uint8_t **buf, int buf_size)
1684
{
1685
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1686
    AVCodecContext *avctx= s->avctx;
1687
    const int field_pic= s->picture_structure != PICT_FRAME;
1688
    const int lowres= s->avctx->lowres;
1689

    
1690
    s->resync_mb_x=
1691
    s->resync_mb_y= -1;
1692

    
1693
    if (mb_y<<field_pic >= s->mb_height){
1694
        av_log(s->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s->mb_height);
1695
        return -1;
1696
    }
1697

    
1698
    init_get_bits(&s->gb, *buf, buf_size*8);
1699

    
1700
    ff_mpeg1_clean_buffers(s);
1701
    s->interlaced_dct = 0;
1702

    
1703
    s->qscale = get_qscale(s);
1704

    
1705
    if(s->qscale == 0){
1706
        av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1707
        return -1;
1708
    }
1709

    
1710
    /* extra slice info */
1711
    while (get_bits1(&s->gb) != 0) {
1712
        skip_bits(&s->gb, 8);
1713
    }
1714

    
1715
    s->mb_x=0;
1716

    
1717
    for(;;) {
1718
        int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1719
        if (code < 0){
1720
            av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1721
            return -1;
1722
        }
1723
        if (code >= 33) {
1724
            if (code == 33) {
1725
                s->mb_x += 33;
1726
            }
1727
            /* otherwise, stuffing, nothing to do */
1728
        } else {
1729
            s->mb_x += code;
1730
            break;
1731
        }
1732
    }
1733
    if(s->mb_x >= (unsigned)s->mb_width){
1734
        av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1735
        return -1;
1736
    }
1737

    
1738
    if (avctx->hwaccel) {
1739
        const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1740
        int start_code = -1;
1741
        buf_end = ff_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1742
        if (buf_end < *buf + buf_size)
1743
            buf_end -= 4;
1744
        s->mb_y = mb_y;
1745
        if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1746
            return DECODE_SLICE_ERROR;
1747
        *buf = buf_end;
1748
        return DECODE_SLICE_OK;
1749
    }
1750

    
1751
    s->resync_mb_x= s->mb_x;
1752
    s->resync_mb_y= s->mb_y= mb_y;
1753
    s->mb_skip_run= 0;
1754
    ff_init_block_index(s);
1755

    
1756
    if (s->mb_y==0 && s->mb_x==0 && (s->first_field || s->picture_structure==PICT_FRAME)) {
1757
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1758
             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",
1759
                 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],
1760
                 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")),
1761
                 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"",
1762
                 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1763
                 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1764
        }
1765
    }
1766

    
1767
    for(;;) {
1768
        //If 1, we memcpy blocks in xvmcvideo.
1769
        if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1)
1770
            ff_xvmc_init_block(s);//set s->block
1771

    
1772
        if(mpeg_decode_mb(s, s->block) < 0)
1773
            return -1;
1774

    
1775
        if(s->current_picture.motion_val[0] && !s->encoding){ //note motion_val is normally NULL unless we want to extract the MVs
1776
            const int wrap = field_pic ? 2*s->b8_stride : s->b8_stride;
1777
            int xy = s->mb_x*2 + s->mb_y*2*wrap;
1778
            int motion_x, motion_y, dir, i;
1779
            if(field_pic && !s->first_field)
1780
                xy += wrap/2;
1781

    
1782
            for(i=0; i<2; i++){
1783
                for(dir=0; dir<2; dir++){
1784
                    if (s->mb_intra || (dir==1 && s->pict_type != FF_B_TYPE)) {
1785
                        motion_x = motion_y = 0;
1786
                    }else if (s->mv_type == MV_TYPE_16X16 || (s->mv_type == MV_TYPE_FIELD && field_pic)){
1787
                        motion_x = s->mv[dir][0][0];
1788
                        motion_y = s->mv[dir][0][1];
1789
                    } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ {
1790
                        motion_x = s->mv[dir][i][0];
1791
                        motion_y = s->mv[dir][i][1];
1792
                    }
1793

    
1794
                    s->current_picture.motion_val[dir][xy    ][0] = motion_x;
1795
                    s->current_picture.motion_val[dir][xy    ][1] = motion_y;
1796
                    s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1797
                    s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1798
                    s->current_picture.ref_index [dir][xy    ]=
1799
                    s->current_picture.ref_index [dir][xy + 1]= s->field_select[dir][i];
1800
                    assert(s->field_select[dir][i]==0 || s->field_select[dir][i]==1);
1801
                }
1802
                xy += wrap;
1803
            }
1804
        }
1805

    
1806
        s->dest[0] += 16 >> lowres;
1807
        s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1808
        s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1809

    
1810
        MPV_decode_mb(s, s->block);
1811

    
1812
        if (++s->mb_x >= s->mb_width) {
1813
            const int mb_size= 16>>s->avctx->lowres;
1814

    
1815
            ff_draw_horiz_band(s, mb_size*s->mb_y, mb_size);
1816

    
1817
            s->mb_x = 0;
1818
            s->mb_y++;
1819

    
1820
            if(s->mb_y<<field_pic >= s->mb_height){
1821
                int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1822
                int is_d10= s->chroma_format==2 && s->pict_type==FF_I_TYPE && avctx->profile==0 && avctx->level==5
1823
                            && s->intra_dc_precision == 2 && s->q_scale_type == 1 && s->alternate_scan == 0
1824
                            && s->progressive_frame == 0 /* vbv_delay == 0xBBB || 0xE10*/;
1825

    
1826
                if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10)
1827
                   || (avctx->error_recognition >= FF_ER_AGGRESSIVE && left>8)){
1828
                    av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n", left, show_bits(&s->gb, FFMIN(left, 23)));
1829
                    return -1;
1830
                }else
1831
                    goto eos;
1832
            }
1833

    
1834
            ff_init_block_index(s);
1835
        }
1836

    
1837
        /* skip mb handling */
1838
        if (s->mb_skip_run == -1) {
1839
            /* read increment again */
1840
            s->mb_skip_run = 0;
1841
            for(;;) {
1842
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1843
                if (code < 0){
1844
                    av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1845
                    return -1;
1846
                }
1847
                if (code >= 33) {
1848
                    if (code == 33) {
1849
                        s->mb_skip_run += 33;
1850
                    }else if(code == 35){
1851
                        if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
1852
                            av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1853
                            return -1;
1854
                        }
1855
                        goto eos; /* end of slice */
1856
                    }
1857
                    /* otherwise, stuffing, nothing to do */
1858
                } else {
1859
                    s->mb_skip_run += code;
1860
                    break;
1861
                }
1862
            }
1863
            if(s->mb_skip_run){
1864
                int i;
1865
                if(s->pict_type == FF_I_TYPE){
1866
                    av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1867
                    return -1;
1868
                }
1869

    
1870
                /* skip mb */
1871
                s->mb_intra = 0;
1872
                for(i=0;i<12;i++)
1873
                    s->block_last_index[i] = -1;
1874
                if(s->picture_structure == PICT_FRAME)
1875
                    s->mv_type = MV_TYPE_16X16;
1876
                else
1877
                    s->mv_type = MV_TYPE_FIELD;
1878
                if (s->pict_type == FF_P_TYPE) {
1879
                    /* if P type, zero motion vector is implied */
1880
                    s->mv_dir = MV_DIR_FORWARD;
1881
                    s->mv[0][0][0] = s->mv[0][0][1] = 0;
1882
                    s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1883
                    s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1884
                    s->field_select[0][0]= s->picture_structure - 1;
1885
                } else {
1886
                    /* if B type, reuse previous vectors and directions */
1887
                    s->mv[0][0][0] = s->last_mv[0][0][0];
1888
                    s->mv[0][0][1] = s->last_mv[0][0][1];
1889
                    s->mv[1][0][0] = s->last_mv[1][0][0];
1890
                    s->mv[1][0][1] = s->last_mv[1][0][1];
1891
                }
1892
            }
1893
        }
1894
    }
1895
eos: // end of slice
1896
    *buf += (get_bits_count(&s->gb)-1)/8;
1897
//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
1898
    return 0;
1899
}
1900

    
1901
static int slice_decode_thread(AVCodecContext *c, void *arg){
1902
    MpegEncContext *s= *(void**)arg;
1903
    const uint8_t *buf= s->gb.buffer;
1904
    int mb_y= s->start_mb_y;
1905

    
1906
    s->error_count= 3*(s->end_mb_y - s->start_mb_y)*s->mb_width;
1907

    
1908
    for(;;){
1909
        uint32_t start_code;
1910
        int ret;
1911

    
1912
        ret= mpeg_decode_slice((Mpeg1Context*)s, mb_y, &buf, s->gb.buffer_end - buf);
1913
        emms_c();
1914
//av_log(c, AV_LOG_DEBUG, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
1915
//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);
1916
        if(ret < 0){
1917
            if(s->resync_mb_x>=0 && s->resync_mb_y>=0)
1918
                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);
1919
        }else{
1920
            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);
1921
        }
1922

    
1923
        if(s->mb_y == s->end_mb_y)
1924
            return 0;
1925

    
1926
        start_code= -1;
1927
        buf = ff_find_start_code(buf, s->gb.buffer_end, &start_code);
1928
        mb_y= start_code - SLICE_MIN_START_CODE;
1929
        if(mb_y < 0 || mb_y >= s->end_mb_y)
1930
            return -1;
1931
    }
1932

    
1933
    return 0; //not reached
1934
}
1935

    
1936
/**
1937
 * Handles slice ends.
1938
 * @return 1 if it seems to be the last slice
1939
 */
1940
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
1941
{
1942
    Mpeg1Context *s1 = avctx->priv_data;
1943
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1944

    
1945
    if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
1946
        return 0;
1947

    
1948
    if (s->avctx->hwaccel) {
1949
        if (s->avctx->hwaccel->end_frame(s->avctx) < 0)
1950
            av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n");
1951
    }
1952

    
1953
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1954
        ff_xvmc_field_end(s);
1955

    
1956
    /* end of slice reached */
1957
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
1958
        /* end of image */
1959

    
1960
        s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
1961

    
1962
        ff_er_frame_end(s);
1963

    
1964
        MPV_frame_end(s);
1965

    
1966
        if (s->pict_type == FF_B_TYPE || s->low_delay) {
1967
            *pict= *(AVFrame*)s->current_picture_ptr;
1968
            ff_print_debug_info(s, pict);
1969
        } else {
1970
            s->picture_number++;
1971
            /* latency of 1 frame for I- and P-frames */
1972
            /* XXX: use another variable than picture_number */
1973
            if (s->last_picture_ptr != NULL) {
1974
                *pict= *(AVFrame*)s->last_picture_ptr;
1975
                 ff_print_debug_info(s, pict);
1976
            }
1977
        }
1978

    
1979
        return 1;
1980
    } else {
1981
        return 0;
1982
    }
1983
}
1984

    
1985
static int mpeg1_decode_sequence(AVCodecContext *avctx,
1986
                                 const uint8_t *buf, int buf_size)
1987
{
1988
    Mpeg1Context *s1 = avctx->priv_data;
1989
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1990
    int width,height;
1991
    int i, v, j;
1992

    
1993
    init_get_bits(&s->gb, buf, buf_size*8);
1994

    
1995
    width = get_bits(&s->gb, 12);
1996
    height = get_bits(&s->gb, 12);
1997
    if (width <= 0 || height <= 0)
1998
        return -1;
1999
    s->aspect_ratio_info= get_bits(&s->gb, 4);
2000
    if (s->aspect_ratio_info == 0) {
2001
        av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2002
        if (avctx->error_recognition >= FF_ER_COMPLIANT)
2003
            return -1;
2004
    }
2005
    s->frame_rate_index = get_bits(&s->gb, 4);
2006
    if (s->frame_rate_index == 0 || s->frame_rate_index > 13)
2007
        return -1;
2008
    s->bit_rate = get_bits(&s->gb, 18) * 400;
2009
    if (get_bits1(&s->gb) == 0) /* marker */
2010
        return -1;
2011
    s->width = width;
2012
    s->height = height;
2013

    
2014
    s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16;
2015
    skip_bits(&s->gb, 1);
2016

    
2017
    /* get matrix */
2018
    if (get_bits1(&s->gb)) {
2019
        load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
2020
    } else {
2021
        for(i=0;i<64;i++) {
2022
            j = s->dsp.idct_permutation[i];
2023
            v = ff_mpeg1_default_intra_matrix[i];
2024
            s->intra_matrix[j] = v;
2025
            s->chroma_intra_matrix[j] = v;
2026
        }
2027
    }
2028
    if (get_bits1(&s->gb)) {
2029
        load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
2030
    } else {
2031
        for(i=0;i<64;i++) {
2032
            int j= s->dsp.idct_permutation[i];
2033
            v = ff_mpeg1_default_non_intra_matrix[i];
2034
            s->inter_matrix[j] = v;
2035
            s->chroma_inter_matrix[j] = v;
2036
        }
2037
    }
2038

    
2039
    if(show_bits(&s->gb, 23) != 0){
2040
        av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2041
        return -1;
2042
    }
2043

    
2044
    /* we set MPEG-2 parameters so that it emulates MPEG-1 */
2045
    s->progressive_sequence = 1;
2046
    s->progressive_frame = 1;
2047
    s->picture_structure = PICT_FRAME;
2048
    s->frame_pred_frame_dct = 1;
2049
    s->chroma_format = 1;
2050
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO;
2051
    avctx->sub_id = 1; /* indicates MPEG-1 */
2052
    s->out_format = FMT_MPEG1;
2053
    s->swap_uv = 0;//AFAIK VCR2 does not have SEQ_HEADER
2054
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
2055

    
2056
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2057
        av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n",
2058
               s->avctx->rc_buffer_size, s->bit_rate);
2059

    
2060
    return 0;
2061
}
2062

    
2063
static int vcr2_init_sequence(AVCodecContext *avctx)
2064
{
2065
    Mpeg1Context *s1 = avctx->priv_data;
2066
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2067
    int i, v;
2068

    
2069
    /* start new MPEG-1 context decoding */
2070
    s->out_format = FMT_MPEG1;
2071
    if (s1->mpeg_enc_ctx_allocated) {
2072
        MPV_common_end(s);
2073
    }
2074
    s->width  = avctx->coded_width;
2075
    s->height = avctx->coded_height;
2076
    avctx->has_b_frames= 0; //true?
2077
    s->low_delay= 1;
2078

    
2079
    avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2080
    avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
2081

    
2082
    if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT || avctx->hwaccel ||
2083
        s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU )
2084
        if( avctx->idct_algo == FF_IDCT_AUTO )
2085
            avctx->idct_algo = FF_IDCT_SIMPLE;
2086

    
2087
    if (MPV_common_init(s) < 0)
2088
        return -1;
2089
    exchange_uv(s);//common init reset pblocks, so we swap them here
2090
    s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB
2091
    s1->mpeg_enc_ctx_allocated = 1;
2092

    
2093
    for(i=0;i<64;i++) {
2094
        int j= s->dsp.idct_permutation[i];
2095
        v = ff_mpeg1_default_intra_matrix[i];
2096
        s->intra_matrix[j] = v;
2097
        s->chroma_intra_matrix[j] = v;
2098

    
2099
        v = ff_mpeg1_default_non_intra_matrix[i];
2100
        s->inter_matrix[j] = v;
2101
        s->chroma_inter_matrix[j] = v;
2102
    }
2103

    
2104
    s->progressive_sequence = 1;
2105
    s->progressive_frame = 1;
2106
    s->picture_structure = PICT_FRAME;
2107
    s->frame_pred_frame_dct = 1;
2108
    s->chroma_format = 1;
2109
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2110
    avctx->sub_id = 2; /* indicates MPEG-2 */
2111
    return 0;
2112
}
2113

    
2114

    
2115
static void mpeg_decode_user_data(AVCodecContext *avctx,
2116
                                  const uint8_t *buf, int buf_size)
2117
{
2118
    const uint8_t *p;
2119
    int len, flags;
2120
    p = buf;
2121
    len = buf_size;
2122

    
2123
    /* we parse the DTG active format information */
2124
    if (len >= 5 &&
2125
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2126
        flags = p[4];
2127
        p += 5;
2128
        len -= 5;
2129
        if (flags & 0x80) {
2130
            /* skip event id */
2131
            if (len < 2)
2132
                return;
2133
            p += 2;
2134
            len -= 2;
2135
        }
2136
        if (flags & 0x40) {
2137
            if (len < 1)
2138
                return;
2139
            avctx->dtg_active_format = p[0] & 0x0f;
2140
        }
2141
    }
2142
}
2143

    
2144
static void mpeg_decode_gop(AVCodecContext *avctx,
2145
                            const uint8_t *buf, int buf_size){
2146
    Mpeg1Context *s1 = avctx->priv_data;
2147
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2148

    
2149
    int drop_frame_flag;
2150
    int time_code_hours, time_code_minutes;
2151
    int time_code_seconds, time_code_pictures;
2152
    int broken_link;
2153

    
2154
    init_get_bits(&s->gb, buf, buf_size*8);
2155

    
2156
    drop_frame_flag = get_bits1(&s->gb);
2157

    
2158
    time_code_hours=get_bits(&s->gb,5);
2159
    time_code_minutes = get_bits(&s->gb,6);
2160
    skip_bits1(&s->gb);//marker bit
2161
    time_code_seconds = get_bits(&s->gb,6);
2162
    time_code_pictures = get_bits(&s->gb,6);
2163

    
2164
    s->closed_gop = get_bits1(&s->gb);
2165
    /*broken_link indicate that after editing the
2166
      reference frames of the first B-Frames after GOP I-Frame
2167
      are missing (open gop)*/
2168
    broken_link = get_bits1(&s->gb);
2169

    
2170
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2171
        av_log(s->avctx, AV_LOG_DEBUG, "GOP (%2d:%02d:%02d.[%02d]) closed_gop=%d broken_link=%d\n",
2172
            time_code_hours, time_code_minutes, time_code_seconds,
2173
            time_code_pictures, s->closed_gop, broken_link);
2174
}
2175
/**
2176
 * Finds the end of the current frame in the bitstream.
2177
 * @return the position of the first byte of the next frame, or -1
2178
 */
2179
int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size, AVCodecParserContext *s)
2180
{
2181
    int i;
2182
    uint32_t state= pc->state;
2183

    
2184
    /* EOF considered as end of frame */
2185
    if (buf_size == 0)
2186
        return 0;
2187

    
2188
/*
2189
 0  frame start         -> 1/4
2190
 1  first_SEQEXT        -> 0/2
2191
 2  first field start   -> 3/0
2192
 3  second_SEQEXT       -> 2/0
2193
 4  searching end
2194
*/
2195

    
2196
    for(i=0; i<buf_size; i++){
2197
        assert(pc->frame_start_found>=0 && pc->frame_start_found<=4);
2198
        if(pc->frame_start_found&1){
2199
            if(state == EXT_START_CODE && (buf[i]&0xF0) != 0x80)
2200
                pc->frame_start_found--;
2201
            else if(state == EXT_START_CODE+2){
2202
                if((buf[i]&3) == 3) pc->frame_start_found= 0;
2203
                else                pc->frame_start_found= (pc->frame_start_found+1)&3;
2204
            }
2205
            state++;
2206
        }else{
2207
            i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1;
2208
            if(pc->frame_start_found==0 && state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2209
                i++;
2210
                pc->frame_start_found=4;
2211
            }
2212
            if(state == SEQ_END_CODE){
2213
                pc->state=-1;
2214
                return i+1;
2215
            }
2216
            if(pc->frame_start_found==2 && state == SEQ_START_CODE)
2217
                pc->frame_start_found= 0;
2218
            if(pc->frame_start_found<4 && state == EXT_START_CODE)
2219
                pc->frame_start_found++;
2220
            if(pc->frame_start_found == 4 && (state&0xFFFFFF00) == 0x100){
2221
                if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2222
                    pc->frame_start_found=0;
2223
                    pc->state=-1;
2224
                    return i-3;
2225
                }
2226
            }
2227
            if(s && state == PICTURE_START_CODE){
2228
                ff_fetch_timestamp(s, i-3, 1);
2229
            }
2230
        }
2231
    }
2232
    pc->state= state;
2233
    return END_NOT_FOUND;
2234
}
2235

    
2236
static int decode_chunks(AVCodecContext *avctx,
2237
                             AVFrame *picture, int *data_size,
2238
                             const uint8_t *buf, int buf_size);
2239

    
2240
/* handle buffering and image synchronisation */
2241
static int mpeg_decode_frame(AVCodecContext *avctx,
2242
                             void *data, int *data_size,
2243
                             AVPacket *avpkt)
2244
{
2245
    const uint8_t *buf = avpkt->data;
2246
    int buf_size = avpkt->size;
2247
    Mpeg1Context *s = avctx->priv_data;
2248
    AVFrame *picture = data;
2249
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2250
    dprintf(avctx, "fill_buffer\n");
2251

    
2252
    if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2253
        /* special case for last picture */
2254
        if (s2->low_delay==0 && s2->next_picture_ptr) {
2255
            *picture= *(AVFrame*)s2->next_picture_ptr;
2256
            s2->next_picture_ptr= NULL;
2257

    
2258
            *data_size = sizeof(AVFrame);
2259
        }
2260
        return buf_size;
2261
    }
2262

    
2263
    if(s2->flags&CODEC_FLAG_TRUNCATED){
2264
        int next= ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size, NULL);
2265

    
2266
        if( ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
2267
            return buf_size;
2268
    }
2269

    
2270
#if 0
2271
    if (s->repeat_field % 2 == 1) {
2272
        s->repeat_field++;
2273
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2274
        //        s2->picture_number, s->repeat_field);
2275
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2276
            *data_size = sizeof(AVPicture);
2277
            goto the_end;
2278
        }
2279
    }
2280
#endif
2281

    
2282
    if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == AV_RL32("VCR2"))
2283
        vcr2_init_sequence(avctx);
2284

    
2285
    s->slice_count= 0;
2286

    
2287
    if(avctx->extradata && !avctx->frame_number)
2288
        decode_chunks(avctx, picture, data_size, avctx->extradata, avctx->extradata_size);
2289

    
2290
    return decode_chunks(avctx, picture, data_size, buf, buf_size);
2291
}
2292

    
2293
static int decode_chunks(AVCodecContext *avctx,
2294
                             AVFrame *picture, int *data_size,
2295
                             const uint8_t *buf, int buf_size)
2296
{
2297
    Mpeg1Context *s = avctx->priv_data;
2298
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2299
    const uint8_t *buf_ptr = buf;
2300
    const uint8_t *buf_end = buf + buf_size;
2301
    int ret, input_size;
2302

    
2303
    for(;;) {
2304
        /* find next start code */
2305
        uint32_t start_code = -1;
2306
        buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code);
2307
        if (start_code > 0x1ff){
2308
            if(s2->pict_type != FF_B_TYPE || avctx->skip_frame <= AVDISCARD_DEFAULT){
2309
                if(avctx->thread_count > 1){
2310
                    int i;
2311

    
2312
                    avctx->execute(avctx, slice_decode_thread,  (void**)&(s2->thread_context[0]), NULL, s->slice_count, sizeof(void*));
2313
                    for(i=0; i<s->slice_count; i++)
2314
                        s2->error_count += s2->thread_context[i]->error_count;
2315
                }
2316

    
2317
                if (CONFIG_MPEG_VDPAU_DECODER && avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2318
                    ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2319

    
2320
                if (slice_end(avctx, picture)) {
2321
                    if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
2322
                        *data_size = sizeof(AVPicture);
2323
                }
2324
            }
2325
            s2->pict_type= 0;
2326
            return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2327
        }
2328

    
2329
        input_size = buf_end - buf_ptr;
2330

    
2331
        if(avctx->debug & FF_DEBUG_STARTCODE){
2332
            av_log(avctx, AV_LOG_DEBUG, "%3X at %td left %d\n", start_code, buf_ptr-buf, input_size);
2333
        }
2334

    
2335
        /* prepare data for next start code */
2336
        switch(start_code) {
2337
        case SEQ_START_CODE:
2338
            mpeg1_decode_sequence(avctx, buf_ptr,
2339
                                    input_size);
2340
            break;
2341

    
2342
        case PICTURE_START_CODE:
2343
            /* we have a complete image: we try to decompress it */
2344
            if(mpeg1_decode_picture(avctx,
2345
                                    buf_ptr, input_size) < 0)
2346
                s2->pict_type=0;
2347
            break;
2348
        case EXT_START_CODE:
2349
            mpeg_decode_extension(avctx,
2350
                                    buf_ptr, input_size);
2351
            break;
2352
        case USER_START_CODE:
2353
            mpeg_decode_user_data(avctx,
2354
                                    buf_ptr, input_size);
2355
            break;
2356
        case GOP_START_CODE:
2357
            s2->first_field=0;
2358
            mpeg_decode_gop(avctx,
2359
                                    buf_ptr, input_size);
2360
            break;
2361
        default:
2362
            if (start_code >= SLICE_MIN_START_CODE &&
2363
                start_code <= SLICE_MAX_START_CODE) {
2364
                int mb_y= start_code - SLICE_MIN_START_CODE;
2365

    
2366
                if(s2->last_picture_ptr==NULL){
2367
                /* Skip B-frames if we do not have reference frames and gop is not closed */
2368
                    if(s2->pict_type==FF_B_TYPE){
2369
                        int i;
2370
                        if(!s2->closed_gop)
2371
                            break;
2372
                        /* Allocate a dummy frame */
2373
                        i= ff_find_unused_picture(s2, 0);
2374
                        s2->last_picture_ptr= &s2->picture[i];
2375
                        if(ff_alloc_picture(s2, s2->last_picture_ptr, 0) < 0)
2376
                            return -1;
2377
                    }
2378
                }
2379
                if(s2->next_picture_ptr==NULL){
2380
                /* Skip P-frames if we do not have a reference frame or we have an invalid header. */
2381
                    if(s2->pict_type==FF_P_TYPE && (s2->first_field || s2->picture_structure==PICT_FRAME)) break;
2382
                }
2383
                /* Skip B-frames if we are in a hurry. */
2384
                if(avctx->hurry_up && s2->pict_type==FF_B_TYPE) break;
2385
                if(  (avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type==FF_B_TYPE)
2386
                    ||(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type!=FF_I_TYPE)
2387
                    || avctx->skip_frame >= AVDISCARD_ALL)
2388
                    break;
2389
                /* Skip everything if we are in a hurry>=5. */
2390
                if(avctx->hurry_up>=5) break;
2391

    
2392
                if (!s->mpeg_enc_ctx_allocated) break;
2393

    
2394
                if(s2->codec_id == CODEC_ID_MPEG2VIDEO){
2395
                    if(mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom)
2396
                        break;
2397
                }
2398

    
2399
                if(!s2->pict_type){
2400
                    av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2401
                    break;
2402
                }
2403

    
2404
                if(s2->first_slice){
2405
                    s2->first_slice=0;
2406
                    if(mpeg_field_start(s2, buf, buf_size) < 0)
2407
                        return -1;
2408
                }
2409
                if(!s2->current_picture_ptr){
2410
                    av_log(avctx, AV_LOG_ERROR, "current_picture not initialized\n");
2411
                    return -1;
2412
                }
2413

    
2414
                if (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
2415
                    s->slice_count++;
2416
                    break;
2417
                }
2418

    
2419
                if(avctx->thread_count > 1){
2420
                    int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count;
2421
                    if(threshold <= mb_y){
2422
                        MpegEncContext *thread_context= s2->thread_context[s->slice_count];
2423

    
2424
                        thread_context->start_mb_y= mb_y;
2425
                        thread_context->end_mb_y  = s2->mb_height;
2426
                        if(s->slice_count){
2427
                            s2->thread_context[s->slice_count-1]->end_mb_y= mb_y;
2428
                            ff_update_duplicate_context(thread_context, s2);
2429
                        }
2430
                        init_get_bits(&thread_context->gb, buf_ptr, input_size*8);
2431
                        s->slice_count++;
2432
                    }
2433
                    buf_ptr += 2; //FIXME add minimum number of bytes per slice
2434
                }else{
2435
                    ret = mpeg_decode_slice(s, mb_y, &buf_ptr, input_size);
2436
                    emms_c();
2437

    
2438
                    if(ret < 0){
2439
                        if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2440
                            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);
2441
                    }else{
2442
                        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);
2443
                    }
2444
                }
2445
            }
2446
            break;
2447
        }
2448
    }
2449
}
2450

    
2451
static int mpeg_decode_end(AVCodecContext *avctx)
2452
{
2453
    Mpeg1Context *s = avctx->priv_data;
2454

    
2455
    if (s->mpeg_enc_ctx_allocated)
2456
        MPV_common_end(&s->mpeg_enc_ctx);
2457
    return 0;
2458
}
2459

    
2460
AVCodec mpeg1video_decoder = {
2461
    "mpeg1video",
2462
    CODEC_TYPE_VIDEO,
2463
    CODEC_ID_MPEG1VIDEO,
2464
    sizeof(Mpeg1Context),
2465
    mpeg_decode_init,
2466
    NULL,
2467
    mpeg_decode_end,
2468
    mpeg_decode_frame,
2469
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2470
    .flush= ff_mpeg_flush,
2471
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2472
};
2473

    
2474
AVCodec mpeg2video_decoder = {
2475
    "mpeg2video",
2476
    CODEC_TYPE_VIDEO,
2477
    CODEC_ID_MPEG2VIDEO,
2478
    sizeof(Mpeg1Context),
2479
    mpeg_decode_init,
2480
    NULL,
2481
    mpeg_decode_end,
2482
    mpeg_decode_frame,
2483
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2484
    .flush= ff_mpeg_flush,
2485
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2486
};
2487

    
2488
//legacy decoder
2489
AVCodec mpegvideo_decoder = {
2490
    "mpegvideo",
2491
    CODEC_TYPE_VIDEO,
2492
    CODEC_ID_MPEG2VIDEO,
2493
    sizeof(Mpeg1Context),
2494
    mpeg_decode_init,
2495
    NULL,
2496
    mpeg_decode_end,
2497
    mpeg_decode_frame,
2498
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2499
    .flush= ff_mpeg_flush,
2500
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2501
};
2502

    
2503
#if CONFIG_MPEG_XVMC_DECODER
2504
static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx){
2505
    if( avctx->thread_count > 1)
2506
        return -1;
2507
    if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
2508
        return -1;
2509
    if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){
2510
        dprintf(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2511
    }
2512
    mpeg_decode_init(avctx);
2513

    
2514
    avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
2515
    avctx->xvmc_acceleration = 2;//2 - the blocks are packed!
2516

    
2517
    return 0;
2518
}
2519

    
2520
AVCodec mpeg_xvmc_decoder = {
2521
    "mpegvideo_xvmc",
2522
    CODEC_TYPE_VIDEO,
2523
    CODEC_ID_MPEG2VIDEO_XVMC,
2524
    sizeof(Mpeg1Context),
2525
    mpeg_mc_decode_init,
2526
    NULL,
2527
    mpeg_decode_end,
2528
    mpeg_decode_frame,
2529
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
2530
    .flush= ff_mpeg_flush,
2531
    .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2532
};
2533

    
2534
#endif
2535

    
2536
#if CONFIG_MPEG_VDPAU_DECODER
2537
AVCodec mpeg_vdpau_decoder = {
2538
    "mpegvideo_vdpau",
2539
    CODEC_TYPE_VIDEO,
2540
    CODEC_ID_MPEG2VIDEO,
2541
    sizeof(Mpeg1Context),
2542
    mpeg_decode_init,
2543
    NULL,
2544
    mpeg_decode_end,
2545
    mpeg_decode_frame,
2546
    CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
2547
    .flush= ff_mpeg_flush,
2548
    .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
2549
};
2550
#endif
2551

    
2552
#if CONFIG_MPEG1_VDPAU_DECODER
2553
AVCodec mpeg1_vdpau_decoder = {
2554
    "mpeg1video_vdpau",
2555
    CODEC_TYPE_VIDEO,
2556
    CODEC_ID_MPEG1VIDEO,
2557
    sizeof(Mpeg1Context),
2558
    mpeg_decode_init,
2559
    NULL,
2560
    mpeg_decode_end,
2561
    mpeg_decode_frame,
2562
    CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
2563
    .flush= ff_mpeg_flush,
2564
    .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
2565
};
2566
#endif
2567