Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ bbf266fd

History | View | Annotate | Download (87.1 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
    init_get_bits(&s->gb, buf, buf_size*8);
1356

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

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

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

    
1385
    s->y_dc_scale = 8;
1386
    s->c_dc_scale = 8;
1387
    s->first_slice = 1;
1388
    return 0;
1389
}
1390

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

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

    
1411
    s->low_delay = get_bits1(&s->gb);
1412
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
1413

    
1414
    s1->frame_rate_ext.num = get_bits(&s->gb, 2)+1;
1415
    s1->frame_rate_ext.den = get_bits(&s->gb, 5)+1;
1416

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

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

    
1425
}
1426

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

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

    
1444
    s1->pan_scan.width= 16*w;
1445
    s1->pan_scan.height=16*h;
1446

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

    
1451
static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1452
{
1453
    MpegEncContext *s= &s1->mpeg_enc_ctx;
1454
    int i,nofco;
1455

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

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

    
1485
static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], uint16_t matrix1[64], int intra){
1486
    int i;
1487

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

    
1506
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1507
{
1508
    dprintf(s->avctx, "matrix extension\n");
1509

    
1510
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1511
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1512
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, NULL           , 1);
1513
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, NULL           , 0);
1514
}
1515

    
1516
static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1517
{
1518
    MpegEncContext *s= &s1->mpeg_enc_ctx;
1519

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

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

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

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

    
1579
static void exchange_uv(MpegEncContext *s){
1580
    DCTELEM (*tmp)[64];
1581

    
1582
    tmp           = s->pblocks[4];
1583
    s->pblocks[4] = s->pblocks[5];
1584
    s->pblocks[5] = tmp;
1585
}
1586

    
1587
static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size){
1588
    AVCodecContext *avctx= s->avctx;
1589
    Mpeg1Context *s1 = (Mpeg1Context*)s;
1590

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

    
1596
        ff_er_frame_start(s);
1597

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

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

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

    
1620
            for(i=0; i<4; i++){
1621
                s->current_picture.data[i] = s->current_picture_ptr->data[i];
1622
                if(s->picture_structure == PICT_BOTTOM_FIELD){
1623
                    s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
1624
                }
1625
            }
1626
    }
1627

    
1628
    if (avctx->hwaccel) {
1629
        if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
1630
            return -1;
1631
    }
1632

    
1633
// MPV_frame_start will call this function too,
1634
// but we need to call it on every field
1635
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1636
        if(ff_xvmc_field_start(s,avctx) < 0)
1637
            return -1;
1638

    
1639
    return 0;
1640
}
1641

    
1642
#define DECODE_SLICE_ERROR -1
1643
#define DECODE_SLICE_OK 0
1644

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

    
1658
    s->resync_mb_x=
1659
    s->resync_mb_y= -1;
1660

    
1661
    if (mb_y<<field_pic >= s->mb_height){
1662
        av_log(s->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s->mb_height);
1663
        return -1;
1664
    }
1665

    
1666
    init_get_bits(&s->gb, *buf, buf_size*8);
1667

    
1668
    ff_mpeg1_clean_buffers(s);
1669
    s->interlaced_dct = 0;
1670

    
1671
    s->qscale = get_qscale(s);
1672

    
1673
    if(s->qscale == 0){
1674
        av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1675
        return -1;
1676
    }
1677

    
1678
    /* extra slice info */
1679
    while (get_bits1(&s->gb) != 0) {
1680
        skip_bits(&s->gb, 8);
1681
    }
1682

    
1683
    s->mb_x=0;
1684

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

    
1706
    if (avctx->hwaccel) {
1707
        const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1708
        int start_code = -1;
1709
        buf_end = ff_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1710
        if (buf_end < *buf + buf_size)
1711
            buf_end -= 4;
1712
        s->mb_y = mb_y;
1713
        if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1714
            return DECODE_SLICE_ERROR;
1715
        *buf = buf_end;
1716
        return DECODE_SLICE_OK;
1717
    }
1718

    
1719
    s->resync_mb_x= s->mb_x;
1720
    s->resync_mb_y= s->mb_y= mb_y;
1721
    s->mb_skip_run= 0;
1722
    ff_init_block_index(s);
1723

    
1724
    if (s->mb_y==0 && s->mb_x==0 && (s->first_field || s->picture_structure==PICT_FRAME)) {
1725
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1726
             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",
1727
                 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],
1728
                 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")),
1729
                 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"",
1730
                 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1731
                 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1732
        }
1733
    }
1734

    
1735
    for(;;) {
1736
        //If 1, we memcpy blocks in xvmcvideo.
1737
        if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1)
1738
            ff_xvmc_init_block(s);//set s->block
1739

    
1740
        if(mpeg_decode_mb(s, s->block) < 0)
1741
            return -1;
1742

    
1743
        if(s->current_picture.motion_val[0] && !s->encoding){ //note motion_val is normally NULL unless we want to extract the MVs
1744
            const int wrap = field_pic ? 2*s->b8_stride : s->b8_stride;
1745
            int xy = s->mb_x*2 + s->mb_y*2*wrap;
1746
            int motion_x, motion_y, dir, i;
1747
            if(field_pic && !s->first_field)
1748
                xy += wrap/2;
1749

    
1750
            for(i=0; i<2; i++){
1751
                for(dir=0; dir<2; dir++){
1752
                    if (s->mb_intra || (dir==1 && s->pict_type != FF_B_TYPE)) {
1753
                        motion_x = motion_y = 0;
1754
                    }else if (s->mv_type == MV_TYPE_16X16 || (s->mv_type == MV_TYPE_FIELD && field_pic)){
1755
                        motion_x = s->mv[dir][0][0];
1756
                        motion_y = s->mv[dir][0][1];
1757
                    } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ {
1758
                        motion_x = s->mv[dir][i][0];
1759
                        motion_y = s->mv[dir][i][1];
1760
                    }
1761

    
1762
                    s->current_picture.motion_val[dir][xy    ][0] = motion_x;
1763
                    s->current_picture.motion_val[dir][xy    ][1] = motion_y;
1764
                    s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1765
                    s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1766
                    s->current_picture.ref_index [dir][xy    ]=
1767
                    s->current_picture.ref_index [dir][xy + 1]= s->field_select[dir][i];
1768
                    assert(s->field_select[dir][i]==0 || s->field_select[dir][i]==1);
1769
                }
1770
                xy += wrap;
1771
            }
1772
        }
1773

    
1774
        s->dest[0] += 16 >> lowres;
1775
        s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1776
        s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1777

    
1778
        MPV_decode_mb(s, s->block);
1779

    
1780
        if (++s->mb_x >= s->mb_width) {
1781
            const int mb_size= 16>>s->avctx->lowres;
1782

    
1783
            ff_draw_horiz_band(s, mb_size*s->mb_y, mb_size);
1784

    
1785
            s->mb_x = 0;
1786
            s->mb_y++;
1787

    
1788
            if(s->mb_y<<field_pic >= s->mb_height){
1789
                int left= get_bits_left(&s->gb);
1790
                int is_d10= s->chroma_format==2 && s->pict_type==FF_I_TYPE && avctx->profile==0 && avctx->level==5
1791
                            && s->intra_dc_precision == 2 && s->q_scale_type == 1 && s->alternate_scan == 0
1792
                            && s->progressive_frame == 0 /* vbv_delay == 0xBBB || 0xE10*/;
1793

    
1794
                if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10)
1795
                   || (avctx->error_recognition >= FF_ER_AGGRESSIVE && left>8)){
1796
                    av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n", left, show_bits(&s->gb, FFMIN(left, 23)));
1797
                    return -1;
1798
                }else
1799
                    goto eos;
1800
            }
1801

    
1802
            ff_init_block_index(s);
1803
        }
1804

    
1805
        /* skip mb handling */
1806
        if (s->mb_skip_run == -1) {
1807
            /* read increment again */
1808
            s->mb_skip_run = 0;
1809
            for(;;) {
1810
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1811
                if (code < 0){
1812
                    av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1813
                    return -1;
1814
                }
1815
                if (code >= 33) {
1816
                    if (code == 33) {
1817
                        s->mb_skip_run += 33;
1818
                    }else if(code == 35){
1819
                        if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
1820
                            av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1821
                            return -1;
1822
                        }
1823
                        goto eos; /* end of slice */
1824
                    }
1825
                    /* otherwise, stuffing, nothing to do */
1826
                } else {
1827
                    s->mb_skip_run += code;
1828
                    break;
1829
                }
1830
            }
1831
            if(s->mb_skip_run){
1832
                int i;
1833
                if(s->pict_type == FF_I_TYPE){
1834
                    av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1835
                    return -1;
1836
                }
1837

    
1838
                /* skip mb */
1839
                s->mb_intra = 0;
1840
                for(i=0;i<12;i++)
1841
                    s->block_last_index[i] = -1;
1842
                if(s->picture_structure == PICT_FRAME)
1843
                    s->mv_type = MV_TYPE_16X16;
1844
                else
1845
                    s->mv_type = MV_TYPE_FIELD;
1846
                if (s->pict_type == FF_P_TYPE) {
1847
                    /* if P type, zero motion vector is implied */
1848
                    s->mv_dir = MV_DIR_FORWARD;
1849
                    s->mv[0][0][0] = s->mv[0][0][1] = 0;
1850
                    s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1851
                    s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1852
                    s->field_select[0][0]= s->picture_structure - 1;
1853
                } else {
1854
                    /* if B type, reuse previous vectors and directions */
1855
                    s->mv[0][0][0] = s->last_mv[0][0][0];
1856
                    s->mv[0][0][1] = s->last_mv[0][0][1];
1857
                    s->mv[1][0][0] = s->last_mv[1][0][0];
1858
                    s->mv[1][0][1] = s->last_mv[1][0][1];
1859
                }
1860
            }
1861
        }
1862
    }
1863
eos: // end of slice
1864
    *buf += (get_bits_count(&s->gb)-1)/8;
1865
//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
1866
    return 0;
1867
}
1868

    
1869
static int slice_decode_thread(AVCodecContext *c, void *arg){
1870
    MpegEncContext *s= *(void**)arg;
1871
    const uint8_t *buf= s->gb.buffer;
1872
    int mb_y= s->start_mb_y;
1873

    
1874
    s->error_count= 3*(s->end_mb_y - s->start_mb_y)*s->mb_width;
1875

    
1876
    for(;;){
1877
        uint32_t start_code;
1878
        int ret;
1879

    
1880
        ret= mpeg_decode_slice((Mpeg1Context*)s, mb_y, &buf, s->gb.buffer_end - buf);
1881
        emms_c();
1882
//av_log(c, AV_LOG_DEBUG, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
1883
//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);
1884
        if(ret < 0){
1885
            if(s->resync_mb_x>=0 && s->resync_mb_y>=0)
1886
                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);
1887
        }else{
1888
            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);
1889
        }
1890

    
1891
        if(s->mb_y == s->end_mb_y)
1892
            return 0;
1893

    
1894
        start_code= -1;
1895
        buf = ff_find_start_code(buf, s->gb.buffer_end, &start_code);
1896
        mb_y= start_code - SLICE_MIN_START_CODE;
1897
        if(mb_y < 0 || mb_y >= s->end_mb_y)
1898
            return -1;
1899
    }
1900

    
1901
    return 0; //not reached
1902
}
1903

    
1904
/**
1905
 * Handles slice ends.
1906
 * @return 1 if it seems to be the last slice
1907
 */
1908
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
1909
{
1910
    Mpeg1Context *s1 = avctx->priv_data;
1911
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1912

    
1913
    if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
1914
        return 0;
1915

    
1916
    if (s->avctx->hwaccel) {
1917
        if (s->avctx->hwaccel->end_frame(s->avctx) < 0)
1918
            av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n");
1919
    }
1920

    
1921
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1922
        ff_xvmc_field_end(s);
1923

    
1924
    /* end of slice reached */
1925
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
1926
        /* end of image */
1927

    
1928
        s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
1929

    
1930
        ff_er_frame_end(s);
1931

    
1932
        MPV_frame_end(s);
1933

    
1934
        if (s->pict_type == FF_B_TYPE || s->low_delay) {
1935
            *pict= *(AVFrame*)s->current_picture_ptr;
1936
            ff_print_debug_info(s, pict);
1937
        } else {
1938
            s->picture_number++;
1939
            /* latency of 1 frame for I- and P-frames */
1940
            /* XXX: use another variable than picture_number */
1941
            if (s->last_picture_ptr != NULL) {
1942
                *pict= *(AVFrame*)s->last_picture_ptr;
1943
                 ff_print_debug_info(s, pict);
1944
            }
1945
        }
1946

    
1947
        return 1;
1948
    } else {
1949
        return 0;
1950
    }
1951
}
1952

    
1953
static int mpeg1_decode_sequence(AVCodecContext *avctx,
1954
                                 const uint8_t *buf, int buf_size)
1955
{
1956
    Mpeg1Context *s1 = avctx->priv_data;
1957
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1958
    int width,height;
1959
    int i, v, j;
1960

    
1961
    init_get_bits(&s->gb, buf, buf_size*8);
1962

    
1963
    width = get_bits(&s->gb, 12);
1964
    height = get_bits(&s->gb, 12);
1965
    if (width <= 0 || height <= 0)
1966
        return -1;
1967
    s->aspect_ratio_info= get_bits(&s->gb, 4);
1968
    if (s->aspect_ratio_info == 0) {
1969
        av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
1970
        if (avctx->error_recognition >= FF_ER_COMPLIANT)
1971
            return -1;
1972
    }
1973
    s->frame_rate_index = get_bits(&s->gb, 4);
1974
    if (s->frame_rate_index == 0 || s->frame_rate_index > 13)
1975
        return -1;
1976
    s->bit_rate = get_bits(&s->gb, 18) * 400;
1977
    if (get_bits1(&s->gb) == 0) /* marker */
1978
        return -1;
1979
    s->width = width;
1980
    s->height = height;
1981

    
1982
    s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16;
1983
    skip_bits(&s->gb, 1);
1984

    
1985
    /* get matrix */
1986
    if (get_bits1(&s->gb)) {
1987
        load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1988
    } else {
1989
        for(i=0;i<64;i++) {
1990
            j = s->dsp.idct_permutation[i];
1991
            v = ff_mpeg1_default_intra_matrix[i];
1992
            s->intra_matrix[j] = v;
1993
            s->chroma_intra_matrix[j] = v;
1994
        }
1995
    }
1996
    if (get_bits1(&s->gb)) {
1997
        load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1998
    } else {
1999
        for(i=0;i<64;i++) {
2000
            int j= s->dsp.idct_permutation[i];
2001
            v = ff_mpeg1_default_non_intra_matrix[i];
2002
            s->inter_matrix[j] = v;
2003
            s->chroma_inter_matrix[j] = v;
2004
        }
2005
    }
2006

    
2007
    if(show_bits(&s->gb, 23) != 0){
2008
        av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2009
        return -1;
2010
    }
2011

    
2012
    /* we set MPEG-2 parameters so that it emulates MPEG-1 */
2013
    s->progressive_sequence = 1;
2014
    s->progressive_frame = 1;
2015
    s->picture_structure = PICT_FRAME;
2016
    s->frame_pred_frame_dct = 1;
2017
    s->chroma_format = 1;
2018
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO;
2019
    avctx->sub_id = 1; /* indicates MPEG-1 */
2020
    s->out_format = FMT_MPEG1;
2021
    s->swap_uv = 0;//AFAIK VCR2 does not have SEQ_HEADER
2022
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
2023

    
2024
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2025
        av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n",
2026
               s->avctx->rc_buffer_size, s->bit_rate);
2027

    
2028
    return 0;
2029
}
2030

    
2031
static int vcr2_init_sequence(AVCodecContext *avctx)
2032
{
2033
    Mpeg1Context *s1 = avctx->priv_data;
2034
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2035
    int i, v;
2036

    
2037
    /* start new MPEG-1 context decoding */
2038
    s->out_format = FMT_MPEG1;
2039
    if (s1->mpeg_enc_ctx_allocated) {
2040
        MPV_common_end(s);
2041
    }
2042
    s->width  = avctx->coded_width;
2043
    s->height = avctx->coded_height;
2044
    avctx->has_b_frames= 0; //true?
2045
    s->low_delay= 1;
2046

    
2047
    avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2048
    avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
2049

    
2050
    if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT || avctx->hwaccel ||
2051
        s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU )
2052
        if( avctx->idct_algo == FF_IDCT_AUTO )
2053
            avctx->idct_algo = FF_IDCT_SIMPLE;
2054

    
2055
    if (MPV_common_init(s) < 0)
2056
        return -1;
2057
    exchange_uv(s);//common init reset pblocks, so we swap them here
2058
    s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB
2059
    s1->mpeg_enc_ctx_allocated = 1;
2060

    
2061
    for(i=0;i<64;i++) {
2062
        int j= s->dsp.idct_permutation[i];
2063
        v = ff_mpeg1_default_intra_matrix[i];
2064
        s->intra_matrix[j] = v;
2065
        s->chroma_intra_matrix[j] = v;
2066

    
2067
        v = ff_mpeg1_default_non_intra_matrix[i];
2068
        s->inter_matrix[j] = v;
2069
        s->chroma_inter_matrix[j] = v;
2070
    }
2071

    
2072
    s->progressive_sequence = 1;
2073
    s->progressive_frame = 1;
2074
    s->picture_structure = PICT_FRAME;
2075
    s->frame_pred_frame_dct = 1;
2076
    s->chroma_format = 1;
2077
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2078
    avctx->sub_id = 2; /* indicates MPEG-2 */
2079
    return 0;
2080
}
2081

    
2082

    
2083
static void mpeg_decode_user_data(AVCodecContext *avctx,
2084
                                  const uint8_t *p, int buf_size)
2085
{
2086
    const uint8_t *buf_end = p+buf_size;
2087

    
2088
    /* we parse the DTG active format information */
2089
    if (buf_end - p >= 5 &&
2090
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2091
        int flags = p[4];
2092
        p += 5;
2093
        if (flags & 0x80) {
2094
            /* skip event id */
2095
            p += 2;
2096
        }
2097
        if (flags & 0x40) {
2098
            if (buf_end - p < 1)
2099
                return;
2100
            avctx->dtg_active_format = p[0] & 0x0f;
2101
        }
2102
    }
2103
}
2104

    
2105
static void mpeg_decode_gop(AVCodecContext *avctx,
2106
                            const uint8_t *buf, int buf_size){
2107
    Mpeg1Context *s1 = avctx->priv_data;
2108
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2109

    
2110
    int drop_frame_flag;
2111
    int time_code_hours, time_code_minutes;
2112
    int time_code_seconds, time_code_pictures;
2113
    int broken_link;
2114

    
2115
    init_get_bits(&s->gb, buf, buf_size*8);
2116

    
2117
    drop_frame_flag = get_bits1(&s->gb);
2118

    
2119
    time_code_hours=get_bits(&s->gb,5);
2120
    time_code_minutes = get_bits(&s->gb,6);
2121
    skip_bits1(&s->gb);//marker bit
2122
    time_code_seconds = get_bits(&s->gb,6);
2123
    time_code_pictures = get_bits(&s->gb,6);
2124

    
2125
    s->closed_gop = get_bits1(&s->gb);
2126
    /*broken_link indicate that after editing the
2127
      reference frames of the first B-Frames after GOP I-Frame
2128
      are missing (open gop)*/
2129
    broken_link = get_bits1(&s->gb);
2130

    
2131
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2132
        av_log(s->avctx, AV_LOG_DEBUG, "GOP (%2d:%02d:%02d.[%02d]) closed_gop=%d broken_link=%d\n",
2133
            time_code_hours, time_code_minutes, time_code_seconds,
2134
            time_code_pictures, s->closed_gop, broken_link);
2135
}
2136
/**
2137
 * Finds the end of the current frame in the bitstream.
2138
 * @return the position of the first byte of the next frame, or -1
2139
 */
2140
int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size, AVCodecParserContext *s)
2141
{
2142
    int i;
2143
    uint32_t state= pc->state;
2144

    
2145
    /* EOF considered as end of frame */
2146
    if (buf_size == 0)
2147
        return 0;
2148

    
2149
/*
2150
 0  frame start         -> 1/4
2151
 1  first_SEQEXT        -> 0/2
2152
 2  first field start   -> 3/0
2153
 3  second_SEQEXT       -> 2/0
2154
 4  searching end
2155
*/
2156

    
2157
    for(i=0; i<buf_size; i++){
2158
        assert(pc->frame_start_found>=0 && pc->frame_start_found<=4);
2159
        if(pc->frame_start_found&1){
2160
            if(state == EXT_START_CODE && (buf[i]&0xF0) != 0x80)
2161
                pc->frame_start_found--;
2162
            else if(state == EXT_START_CODE+2){
2163
                if((buf[i]&3) == 3) pc->frame_start_found= 0;
2164
                else                pc->frame_start_found= (pc->frame_start_found+1)&3;
2165
            }
2166
            state++;
2167
        }else{
2168
            i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1;
2169
            if(pc->frame_start_found==0 && state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2170
                i++;
2171
                pc->frame_start_found=4;
2172
            }
2173
            if(state == SEQ_END_CODE){
2174
                pc->state=-1;
2175
                return i+1;
2176
            }
2177
            if(pc->frame_start_found==2 && state == SEQ_START_CODE)
2178
                pc->frame_start_found= 0;
2179
            if(pc->frame_start_found<4 && state == EXT_START_CODE)
2180
                pc->frame_start_found++;
2181
            if(pc->frame_start_found == 4 && (state&0xFFFFFF00) == 0x100){
2182
                if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2183
                    pc->frame_start_found=0;
2184
                    pc->state=-1;
2185
                    return i-3;
2186
                }
2187
            }
2188
            if(s && state == PICTURE_START_CODE){
2189
                ff_fetch_timestamp(s, i-3, 1);
2190
            }
2191
        }
2192
    }
2193
    pc->state= state;
2194
    return END_NOT_FOUND;
2195
}
2196

    
2197
static int decode_chunks(AVCodecContext *avctx,
2198
                             AVFrame *picture, int *data_size,
2199
                             const uint8_t *buf, int buf_size);
2200

    
2201
/* handle buffering and image synchronisation */
2202
static int mpeg_decode_frame(AVCodecContext *avctx,
2203
                             void *data, int *data_size,
2204
                             AVPacket *avpkt)
2205
{
2206
    const uint8_t *buf = avpkt->data;
2207
    int buf_size = avpkt->size;
2208
    Mpeg1Context *s = avctx->priv_data;
2209
    AVFrame *picture = data;
2210
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2211
    dprintf(avctx, "fill_buffer\n");
2212

    
2213
    if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2214
        /* special case for last picture */
2215
        if (s2->low_delay==0 && s2->next_picture_ptr) {
2216
            *picture= *(AVFrame*)s2->next_picture_ptr;
2217
            s2->next_picture_ptr= NULL;
2218

    
2219
            *data_size = sizeof(AVFrame);
2220
        }
2221
        return buf_size;
2222
    }
2223

    
2224
    if(s2->flags&CODEC_FLAG_TRUNCATED){
2225
        int next= ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size, NULL);
2226

    
2227
        if( ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
2228
            return buf_size;
2229
    }
2230

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

    
2243
    if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == AV_RL32("VCR2"))
2244
        vcr2_init_sequence(avctx);
2245

    
2246
    s->slice_count= 0;
2247

    
2248
    if(avctx->extradata && !avctx->frame_number)
2249
        decode_chunks(avctx, picture, data_size, avctx->extradata, avctx->extradata_size);
2250

    
2251
    return decode_chunks(avctx, picture, data_size, buf, buf_size);
2252
}
2253

    
2254
static int decode_chunks(AVCodecContext *avctx,
2255
                             AVFrame *picture, int *data_size,
2256
                             const uint8_t *buf, int buf_size)
2257
{
2258
    Mpeg1Context *s = avctx->priv_data;
2259
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2260
    const uint8_t *buf_ptr = buf;
2261
    const uint8_t *buf_end = buf + buf_size;
2262
    int ret, input_size;
2263

    
2264
    for(;;) {
2265
        /* find next start code */
2266
        uint32_t start_code = -1;
2267
        buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code);
2268
        if (start_code > 0x1ff){
2269
            if(s2->pict_type != FF_B_TYPE || avctx->skip_frame <= AVDISCARD_DEFAULT){
2270
                if(avctx->thread_count > 1){
2271
                    int i;
2272

    
2273
                    avctx->execute(avctx, slice_decode_thread,  &s2->thread_context[0], NULL, s->slice_count, sizeof(void*));
2274
                    for(i=0; i<s->slice_count; i++)
2275
                        s2->error_count += s2->thread_context[i]->error_count;
2276
                }
2277

    
2278
                if (CONFIG_MPEG_VDPAU_DECODER && avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2279
                    ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2280

    
2281
                if (slice_end(avctx, picture)) {
2282
                    if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
2283
                        *data_size = sizeof(AVPicture);
2284
                }
2285
            }
2286
            s2->pict_type= 0;
2287
            return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2288
        }
2289

    
2290
        input_size = buf_end - buf_ptr;
2291

    
2292
        if(avctx->debug & FF_DEBUG_STARTCODE){
2293
            av_log(avctx, AV_LOG_DEBUG, "%3X at %td left %d\n", start_code, buf_ptr-buf, input_size);
2294
        }
2295

    
2296
        /* prepare data for next start code */
2297
        switch(start_code) {
2298
        case SEQ_START_CODE:
2299
            mpeg1_decode_sequence(avctx, buf_ptr,
2300
                                    input_size);
2301
            break;
2302

    
2303
        case PICTURE_START_CODE:
2304
            if(mpeg_decode_postinit(avctx) < 0){
2305
                av_log(avctx, AV_LOG_ERROR, "mpeg_decode_postinit() failure\n");
2306
                return -1;
2307
            }
2308

    
2309
            /* we have a complete image: we try to decompress it */
2310
            if(mpeg1_decode_picture(avctx,
2311
                                    buf_ptr, input_size) < 0)
2312
                s2->pict_type=0;
2313
            break;
2314
        case EXT_START_CODE:
2315
            init_get_bits(&s2->gb, buf_ptr, input_size*8);
2316

    
2317
            switch(get_bits(&s2->gb, 4)) {
2318
            case 0x1:
2319
                mpeg_decode_sequence_extension(s);
2320
                break;
2321
            case 0x2:
2322
                mpeg_decode_sequence_display_extension(s);
2323
                break;
2324
            case 0x3:
2325
                mpeg_decode_quant_matrix_extension(s2);
2326
                break;
2327
            case 0x7:
2328
                mpeg_decode_picture_display_extension(s);
2329
                break;
2330
            case 0x8:
2331
                mpeg_decode_picture_coding_extension(s);
2332
                break;
2333
            }
2334
            break;
2335
        case USER_START_CODE:
2336
            mpeg_decode_user_data(avctx,
2337
                                    buf_ptr, input_size);
2338
            break;
2339
        case GOP_START_CODE:
2340
            s2->first_field=0;
2341
            mpeg_decode_gop(avctx,
2342
                                    buf_ptr, input_size);
2343
            break;
2344
        default:
2345
            if (start_code >= SLICE_MIN_START_CODE &&
2346
                start_code <= SLICE_MAX_START_CODE) {
2347
                int mb_y= start_code - SLICE_MIN_START_CODE;
2348

    
2349
                if(s2->last_picture_ptr==NULL){
2350
                /* Skip B-frames if we do not have reference frames and gop is not closed */
2351
                    if(s2->pict_type==FF_B_TYPE){
2352
                        int i;
2353
                        if(!s2->closed_gop)
2354
                            break;
2355
                        /* Allocate a dummy frame */
2356
                        i= ff_find_unused_picture(s2, 0);
2357
                        s2->last_picture_ptr= &s2->picture[i];
2358
                        if(ff_alloc_picture(s2, s2->last_picture_ptr, 0) < 0)
2359
                            return -1;
2360
                    }
2361
                }
2362
                if(s2->next_picture_ptr==NULL){
2363
                /* Skip P-frames if we do not have a reference frame or we have an invalid header. */
2364
                    if(s2->pict_type==FF_P_TYPE && (s2->first_field || s2->picture_structure==PICT_FRAME)) break;
2365
                }
2366
                /* Skip B-frames if we are in a hurry. */
2367
                if(avctx->hurry_up && s2->pict_type==FF_B_TYPE) break;
2368
                if(  (avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type==FF_B_TYPE)
2369
                    ||(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type!=FF_I_TYPE)
2370
                    || avctx->skip_frame >= AVDISCARD_ALL)
2371
                    break;
2372
                /* Skip everything if we are in a hurry>=5. */
2373
                if(avctx->hurry_up>=5) break;
2374

    
2375
                if (!s->mpeg_enc_ctx_allocated) break;
2376

    
2377
                if(s2->codec_id == CODEC_ID_MPEG2VIDEO){
2378
                    if(mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom)
2379
                        break;
2380
                }
2381

    
2382
                if(!s2->pict_type){
2383
                    av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2384
                    break;
2385
                }
2386

    
2387
                if(s2->first_slice){
2388
                    s2->first_slice=0;
2389
                    if(mpeg_field_start(s2, buf, buf_size) < 0)
2390
                        return -1;
2391
                }
2392
                if(!s2->current_picture_ptr){
2393
                    av_log(avctx, AV_LOG_ERROR, "current_picture not initialized\n");
2394
                    return -1;
2395
                }
2396

    
2397
                if (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
2398
                    s->slice_count++;
2399
                    break;
2400
                }
2401

    
2402
                if(avctx->thread_count > 1){
2403
                    int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count;
2404
                    if(threshold <= mb_y){
2405
                        MpegEncContext *thread_context= s2->thread_context[s->slice_count];
2406

    
2407
                        thread_context->start_mb_y= mb_y;
2408
                        thread_context->end_mb_y  = s2->mb_height;
2409
                        if(s->slice_count){
2410
                            s2->thread_context[s->slice_count-1]->end_mb_y= mb_y;
2411
                            ff_update_duplicate_context(thread_context, s2);
2412
                        }
2413
                        init_get_bits(&thread_context->gb, buf_ptr, input_size*8);
2414
                        s->slice_count++;
2415
                    }
2416
                    buf_ptr += 2; //FIXME add minimum number of bytes per slice
2417
                }else{
2418
                    ret = mpeg_decode_slice(s, mb_y, &buf_ptr, input_size);
2419
                    emms_c();
2420

    
2421
                    if(ret < 0){
2422
                        if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2423
                            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);
2424
                    }else{
2425
                        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);
2426
                    }
2427
                }
2428
            }
2429
            break;
2430
        }
2431
    }
2432
}
2433

    
2434
static int mpeg_decode_end(AVCodecContext *avctx)
2435
{
2436
    Mpeg1Context *s = avctx->priv_data;
2437

    
2438
    if (s->mpeg_enc_ctx_allocated)
2439
        MPV_common_end(&s->mpeg_enc_ctx);
2440
    return 0;
2441
}
2442

    
2443
AVCodec mpeg1video_decoder = {
2444
    "mpeg1video",
2445
    CODEC_TYPE_VIDEO,
2446
    CODEC_ID_MPEG1VIDEO,
2447
    sizeof(Mpeg1Context),
2448
    mpeg_decode_init,
2449
    NULL,
2450
    mpeg_decode_end,
2451
    mpeg_decode_frame,
2452
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2453
    .flush= ff_mpeg_flush,
2454
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2455
};
2456

    
2457
AVCodec mpeg2video_decoder = {
2458
    "mpeg2video",
2459
    CODEC_TYPE_VIDEO,
2460
    CODEC_ID_MPEG2VIDEO,
2461
    sizeof(Mpeg1Context),
2462
    mpeg_decode_init,
2463
    NULL,
2464
    mpeg_decode_end,
2465
    mpeg_decode_frame,
2466
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2467
    .flush= ff_mpeg_flush,
2468
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2469
};
2470

    
2471
//legacy decoder
2472
AVCodec mpegvideo_decoder = {
2473
    "mpegvideo",
2474
    CODEC_TYPE_VIDEO,
2475
    CODEC_ID_MPEG2VIDEO,
2476
    sizeof(Mpeg1Context),
2477
    mpeg_decode_init,
2478
    NULL,
2479
    mpeg_decode_end,
2480
    mpeg_decode_frame,
2481
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2482
    .flush= ff_mpeg_flush,
2483
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2484
};
2485

    
2486
#if CONFIG_MPEG_XVMC_DECODER
2487
static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx){
2488
    if( avctx->thread_count > 1)
2489
        return -1;
2490
    if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
2491
        return -1;
2492
    if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){
2493
        dprintf(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2494
    }
2495
    mpeg_decode_init(avctx);
2496

    
2497
    avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
2498
    avctx->xvmc_acceleration = 2;//2 - the blocks are packed!
2499

    
2500
    return 0;
2501
}
2502

    
2503
AVCodec mpeg_xvmc_decoder = {
2504
    "mpegvideo_xvmc",
2505
    CODEC_TYPE_VIDEO,
2506
    CODEC_ID_MPEG2VIDEO_XVMC,
2507
    sizeof(Mpeg1Context),
2508
    mpeg_mc_decode_init,
2509
    NULL,
2510
    mpeg_decode_end,
2511
    mpeg_decode_frame,
2512
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
2513
    .flush= ff_mpeg_flush,
2514
    .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2515
};
2516

    
2517
#endif
2518

    
2519
#if CONFIG_MPEG_VDPAU_DECODER
2520
AVCodec mpeg_vdpau_decoder = {
2521
    "mpegvideo_vdpau",
2522
    CODEC_TYPE_VIDEO,
2523
    CODEC_ID_MPEG2VIDEO,
2524
    sizeof(Mpeg1Context),
2525
    mpeg_decode_init,
2526
    NULL,
2527
    mpeg_decode_end,
2528
    mpeg_decode_frame,
2529
    CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
2530
    .flush= ff_mpeg_flush,
2531
    .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
2532
};
2533
#endif
2534

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