Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ 1206f1d6

History | View | Annotate | Download (87 KB)

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

    
23
/**
24
 * @file libavcodec/mpeg12.c
25
 * MPEG-1/2 decoder
26
 */
27

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

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

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

    
44

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

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

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

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

    
76

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

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

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

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

    
121
void ff_mpeg12_common_init(MpegEncContext *s)
122
{
123

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

    
127
}
128

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

    
136

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
224
            if(s->mb_x)
225
                mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1];
226
            else
227
                mb_type= s->current_picture.mb_type[ s->mb_width + (s->mb_y-1)*s->mb_stride - 1]; // FIXME not sure if this is allowed in MPEG at all
228
            if(IS_INTRA(mb_type))
229
                return -1;
230

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

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

    
239
        return 0;
240
    }
241

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

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

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

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

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

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

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

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

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

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

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

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

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

    
460

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

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

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

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

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

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

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

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

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

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

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

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

    
576
    return 0;
577
}
578

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
854

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

    
866
    mismatch = 1;
867

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1014

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1176
} Mpeg1Context;
1177

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

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

    
1189
    MPV_decode_defaults(s2);
1190

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1428
}
1429

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1582
static void exchange_uv(MpegEncContext *s){
1583
    DCTELEM (*tmp)[64];
1584

    
1585
    tmp           = s->pblocks[4];
1586
    s->pblocks[4] = s->pblocks[5];
1587
    s->pblocks[5] = tmp;
1588
}
1589

    
1590
static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size){
1591
    AVCodecContext *avctx= s->avctx;
1592
    Mpeg1Context *s1 = (Mpeg1Context*)s;
1593

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

    
1599
        ff_er_frame_start(s);
1600

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

    
1614
        *s->current_picture_ptr->pan_scan= s1->pan_scan;
1615
    }else{ //second field
1616
            int i;
1617

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

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

    
1631
    if (avctx->hwaccel) {
1632
        if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
1633
            return -1;
1634
    }
1635

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

    
1642
    return 0;
1643
}
1644

    
1645
#define DECODE_SLICE_ERROR -1
1646
#define DECODE_SLICE_OK 0
1647

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

    
1661
    s->resync_mb_x=
1662
    s->resync_mb_y= -1;
1663

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

    
1669
    init_get_bits(&s->gb, *buf, buf_size*8);
1670

    
1671
    ff_mpeg1_clean_buffers(s);
1672
    s->interlaced_dct = 0;
1673

    
1674
    s->qscale = get_qscale(s);
1675

    
1676
    if(s->qscale == 0){
1677
        av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1678
        return -1;
1679
    }
1680

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

    
1686
    s->mb_x=0;
1687

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

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

    
1722
    s->resync_mb_x= s->mb_x;
1723
    s->resync_mb_y= s->mb_y= mb_y;
1724
    s->mb_skip_run= 0;
1725
    ff_init_block_index(s);
1726

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

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

    
1743
        if(mpeg_decode_mb(s, s->block) < 0)
1744
            return -1;
1745

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

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

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

    
1777
        s->dest[0] += 16 >> lowres;
1778
        s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1779
        s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1780

    
1781
        MPV_decode_mb(s, s->block);
1782

    
1783
        if (++s->mb_x >= s->mb_width) {
1784
            const int mb_size= 16>>s->avctx->lowres;
1785

    
1786
            ff_draw_horiz_band(s, mb_size*s->mb_y, mb_size);
1787

    
1788
            s->mb_x = 0;
1789
            s->mb_y++;
1790

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

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

    
1805
            ff_init_block_index(s);
1806
        }
1807

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

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

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

    
1877
    s->error_count= 3*(s->end_mb_y - s->start_mb_y)*s->mb_width;
1878

    
1879
    for(;;){
1880
        uint32_t start_code;
1881
        int ret;
1882

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

    
1894
        if(s->mb_y == s->end_mb_y)
1895
            return 0;
1896

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

    
1904
    return 0; //not reached
1905
}
1906

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

    
1916
    if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
1917
        return 0;
1918

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

    
1924
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1925
        ff_xvmc_field_end(s);
1926

    
1927
    /* end of slice reached */
1928
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
1929
        /* end of image */
1930

    
1931
        s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
1932

    
1933
        ff_er_frame_end(s);
1934

    
1935
        MPV_frame_end(s);
1936

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

    
1950
        return 1;
1951
    } else {
1952
        return 0;
1953
    }
1954
}
1955

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

    
1964
    init_get_bits(&s->gb, buf, buf_size*8);
1965

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

    
1985
    s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16;
1986
    skip_bits(&s->gb, 1);
1987

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

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

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

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

    
2031
    return 0;
2032
}
2033

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

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

    
2050
    avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2051
    avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
2052

    
2053
    if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT || avctx->hwaccel ||
2054
        s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU )
2055
        if( avctx->idct_algo == FF_IDCT_AUTO )
2056
            avctx->idct_algo = FF_IDCT_SIMPLE;
2057

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

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

    
2070
        v = ff_mpeg1_default_non_intra_matrix[i];
2071
        s->inter_matrix[j] = v;
2072
        s->chroma_inter_matrix[j] = v;
2073
    }
2074

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

    
2085

    
2086
static void mpeg_decode_user_data(AVCodecContext *avctx,
2087
                                  const uint8_t *p, int buf_size)
2088
{
2089
    const uint8_t *buf_end = p+buf_size;
2090

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

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

    
2113
    int drop_frame_flag;
2114
    int time_code_hours, time_code_minutes;
2115
    int time_code_seconds, time_code_pictures;
2116
    int broken_link;
2117

    
2118
    init_get_bits(&s->gb, buf, buf_size*8);
2119

    
2120
    drop_frame_flag = get_bits1(&s->gb);
2121

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

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

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

    
2148
    /* EOF considered as end of frame */
2149
    if (buf_size == 0)
2150
        return 0;
2151

    
2152
/*
2153
 0  frame start         -> 1/4
2154
 1  first_SEQEXT        -> 0/2
2155
 2  first field start   -> 3/0
2156
 3  second_SEQEXT       -> 2/0
2157
 4  searching end
2158
*/
2159

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

    
2200
static int decode_chunks(AVCodecContext *avctx,
2201
                             AVFrame *picture, int *data_size,
2202
                             const uint8_t *buf, int buf_size);
2203

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

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

    
2222
            *data_size = sizeof(AVFrame);
2223
        }
2224
        return buf_size;
2225
    }
2226

    
2227
    if(s2->flags&CODEC_FLAG_TRUNCATED){
2228
        int next= ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size, NULL);
2229

    
2230
        if( ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
2231
            return buf_size;
2232
    }
2233

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

    
2246
    if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == AV_RL32("VCR2"))
2247
        vcr2_init_sequence(avctx);
2248

    
2249
    s->slice_count= 0;
2250

    
2251
    if(avctx->extradata && !avctx->frame_number)
2252
        decode_chunks(avctx, picture, data_size, avctx->extradata, avctx->extradata_size);
2253

    
2254
    return decode_chunks(avctx, picture, data_size, buf, buf_size);
2255
}
2256

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

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

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

    
2281
                if (CONFIG_MPEG_VDPAU_DECODER && avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2282
                    ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2283

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

    
2293
        input_size = buf_end - buf_ptr;
2294

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

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

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

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

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

    
2373
                if (!s->mpeg_enc_ctx_allocated) break;
2374

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2498
    return 0;
2499
}
2500

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

    
2515
#endif
2516

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

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