mpeg12.c 89.3 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1
/*
2
 * MPEG-1/2 decoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
Fabrice Bellard's avatar
Fabrice Bellard committed
5
 *
6 7 8
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
9 10
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
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
Fabrice Bellard's avatar
Fabrice Bellard committed
21
 */
22

Michael Niedermayer's avatar
Michael Niedermayer committed
23
/**
24
 * @file
25
 * MPEG-1/2 decoder
Michael Niedermayer's avatar
Michael Niedermayer committed
26
 */
27

Fabrice Bellard's avatar
Fabrice Bellard committed
28
//#define DEBUG
29
#include "internal.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
30 31 32 33
#include "avcodec.h"
#include "dsputil.h"
#include "mpegvideo.h"

34
#include "mpeg12.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
35
#include "mpeg12data.h"
36
#include "mpeg12decdata.h"
37
#include "bytestream.h"
38
#include "vdpau_internal.h"
39
#include "xvmc_internal.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
40

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

44

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

51 52 53
static inline int mpeg1_decode_block_intra(MpegEncContext *s,
                              DCTELEM *block,
                              int n);
54 55
static inline int mpeg1_decode_block_inter(MpegEncContext *s,
                              DCTELEM *block,
56
                              int n);
57
static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n);
58 59
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
                                        DCTELEM *block,
Fabrice Bellard's avatar
Fabrice Bellard committed
60
                                        int n);
61 62
static inline int mpeg2_decode_block_intra(MpegEncContext *s,
                                    DCTELEM *block,
Fabrice Bellard's avatar
Fabrice Bellard committed
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);
Fabrice Bellard's avatar
Fabrice Bellard committed
66
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
Ivan Kalvachev's avatar
Ivan Kalvachev committed
67
static void exchange_uv(MpegEncContext *s);
Fabrice Bellard's avatar
Fabrice Bellard committed
68

69
static const enum PixelFormat pixfmt_xvmc_mpg2_420[] = {
Ivan Kalvachev's avatar
Ivan Kalvachev committed
70 71
                                           PIX_FMT_XVMC_MPEG2_IDCT,
                                           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 78 79 80 81 82 83 84 85 86 87

#define INIT_2D_VLC_RL(rl, static_size)\
{\
    static RL_VLC_ELEM rl_vlc_table[static_size];\
    INIT_VLC_STATIC(&rl.vlc, TEX_VLC_BITS, rl.n + 2,\
             &rl.table_vlc[0][1], 4, 2,\
             &rl.table_vlc[0][0], 4, 2, static_size);\
\
    rl.rl_vlc[0]= rl_vlc_table;\
    init_2d_vlc_rl(&rl);\
}

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

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

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

121
void ff_mpeg12_common_init(MpegEncContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
122
{
123

124
    s->y_dc_scale_table=
125
    s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
Michael Niedermayer's avatar
Michael Niedermayer committed
126

127
}
128

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

Fabrice Bellard's avatar
Fabrice Bellard committed
136 137 138 139 140 141 142 143 144 145

/******************************************/
/* decoding */

static VLC mv_vlc;
static VLC mbincr_vlc;
static VLC mb_ptype_vlc;
static VLC mb_btype_vlc;
static VLC mb_pat_vlc;

146
av_cold void ff_mpeg12_init_vlcs(void)
Fabrice Bellard's avatar
Fabrice Bellard committed
147 148 149 150
{
    static int done = 0;

    if (!done) {
151
        done = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
152

153
        INIT_VLC_STATIC(&dc_lum_vlc, DC_VLC_BITS, 12,
154
                 ff_mpeg12_vlc_dc_lum_bits, 1, 1,
155 156
                 ff_mpeg12_vlc_dc_lum_code, 2, 2, 512);
        INIT_VLC_STATIC(&dc_chroma_vlc,  DC_VLC_BITS, 12,
157
                 ff_mpeg12_vlc_dc_chroma_bits, 1, 1,
158 159
                 ff_mpeg12_vlc_dc_chroma_code, 2, 2, 514);
        INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 17,
160
                 &ff_mpeg12_mbMotionVectorTable[0][1], 2, 1,
161 162
                 &ff_mpeg12_mbMotionVectorTable[0][0], 2, 1, 518);
        INIT_VLC_STATIC(&mbincr_vlc, MBINCR_VLC_BITS, 36,
163
                 &ff_mpeg12_mbAddrIncrTable[0][1], 2, 1,
164 165
                 &ff_mpeg12_mbAddrIncrTable[0][0], 2, 1, 538);
        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,
Fabrice Bellard's avatar
Fabrice Bellard committed
170
                 &table_mb_ptype[0][1], 2, 1,
171 172
                 &table_mb_ptype[0][0], 2, 1, 64);
        INIT_VLC_STATIC(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11,
Fabrice Bellard's avatar
Fabrice Bellard committed
173
                 &table_mb_btype[0][1], 2, 1,
174
                 &table_mb_btype[0][0], 2, 1, 64);
175 176
        init_rl(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]);
        init_rl(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]);
177

178 179
        INIT_2D_VLC_RL(ff_rl_mpeg1, 680);
        INIT_2D_VLC_RL(ff_rl_mpeg2, 674);
Fabrice Bellard's avatar
Fabrice Bellard committed
180 181 182 183 184
    }
}

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

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

201
/* motion type (for MPEG-2) */
Fabrice Bellard's avatar
Fabrice Bellard committed
202 203 204 205 206 207
#define MT_FIELD 1
#define MT_FRAME 2
#define MT_16X8  2
#define MT_DMV   3

static int mpeg_decode_mb(MpegEncContext *s,
208
                          DCTELEM block[12][64])
Fabrice Bellard's avatar
Fabrice Bellard committed
209
{
Michael Niedermayer's avatar
Michael Niedermayer committed
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);
Fabrice Bellard's avatar
Fabrice Bellard committed
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;
Fabrice Bellard's avatar
Fabrice Bellard committed
221
        } else {
222
            int mb_type;
223

224 225 226
            if(s->mb_x)
                mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1];
            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 229
            if(IS_INTRA(mb_type))
                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 234
//            assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));

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;
Fabrice Bellard's avatar
Fabrice Bellard committed
237
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
238

Fabrice Bellard's avatar
Fabrice Bellard committed
239 240 241 242 243
        return 0;
    }

    switch(s->pict_type) {
    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);
Fabrice Bellard's avatar
Fabrice Bellard committed
248
                return -1;
249
            }
250
            mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
Fabrice Bellard's avatar
Fabrice Bellard committed
251
        } else {
252
            mb_type = MB_TYPE_INTRA;
Fabrice Bellard's avatar
Fabrice Bellard committed
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);
Fabrice Bellard's avatar
Fabrice Bellard committed
259
            return -1;
260
        }
261
        mb_type = ptype2mb_type[ mb_type ];
Fabrice Bellard's avatar
Fabrice Bellard committed
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);
Fabrice Bellard's avatar
Fabrice Bellard committed
267
            return -1;
268
        }
269
        mb_type = btype2mb_type[ mb_type ];
Fabrice Bellard's avatar
Fabrice Bellard committed
270 271
        break;
    }
272
    dprintf(s->avctx, "mb_type=%x\n", mb_type);
273 274
//    motion_type = 0; /* avoid warning */
    if (IS_INTRA(mb_type)) {
275
        s->dsp.clear_blocks(s->block[0]);
276

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

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
290 291
        if (s->concealment_motion_vectors) {
            /* 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 299
                mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);

300
            skip_bits1(&s->gb); /* marker */
301 302
        }else
            memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
Fabrice Bellard's avatar
Fabrice Bellard committed
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 308 309 310
            if(s->swap_uv){
                exchange_uv(s);
            }
        }
311

Michael Niedermayer's avatar
Michael Niedermayer committed
312
        if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
313 314
            if(s->flags2 & CODEC_FLAG2_FAST){
                for(i=0;i<6;i++) {
315
                    mpeg2_fast_decode_block_intra(s, *s->pblocks[i], i);
316 317 318
                }
            }else{
                for(i=0;i<mb_block_count;i++) {
319
                    if (mpeg2_decode_block_intra(s, *s->pblocks[i], i) < 0)
320 321
                        return -1;
                }
322 323 324
            }
        } else {
            for(i=0;i<6;i++) {
325
                if (mpeg1_decode_block_intra(s, *s->pblocks[i], i) < 0)
326 327 328
                    return -1;
            }
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
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;
Michael Niedermayer's avatar
Michael Niedermayer committed
334 335 336
            if(s->picture_structure == PICT_FRAME){
                if(!s->frame_pred_frame_dct)
                    s->interlaced_dct = get_bits1(&s->gb);
337
                s->mv_type = MV_TYPE_16X16;
Michael Niedermayer's avatar
Michael Niedermayer committed
338
            }else{
339 340 341 342
                s->mv_type = MV_TYPE_FIELD;
                mb_type |= MB_TYPE_INTERLACED;
                s->field_select[0][0]= s->picture_structure - 1;
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
343 344 345 346

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

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

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

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

Michael Niedermayer's avatar
Michael Niedermayer committed
453 454 455 456 457 458
                        mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
                                                s->last_mv[i][0][0]);
                        s->last_mv[i][0][0] = mx;
                        s->last_mv[i][1][0] = mx;
                        dmx = get_dmv(s);
                        my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
459
                                                s->last_mv[i][0][1] >> my_shift);
Michael Niedermayer's avatar
Michael Niedermayer committed
460 461 462
                        dmy = get_dmv(s);


463 464
                        s->last_mv[i][0][1] = my<<my_shift;
                        s->last_mv[i][1][1] = my<<my_shift;
Michael Niedermayer's avatar
Michael Niedermayer committed
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491

                        s->mv[i][0][0] = mx;
                        s->mv[i][0][1] = my;
                        s->mv[i][1][0] = mx;//not used
                        s->mv[i][1][1] = my;//not used

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

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

                            /* top -> top pred */
                            s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
                            s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
                            m = 4 - m;
                            s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
                            s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
                        } else {
                            mb_type |= MB_TYPE_16x16;

                            s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
                            s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
                            if(s->picture_structure == PICT_TOP_FIELD)
                                s->mv[i][2][1]--;
                            else
                                s->mv[i][2][1]++;
Fabrice Bellard's avatar
Fabrice Bellard committed
492 493 494
                        }
                    }
                }
Michael Niedermayer's avatar
Michael Niedermayer committed
495 496 497 498
                break;
            default:
                av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
                return -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
499 500
            }
        }
501

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

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

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

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

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
578 579 580
    return 0;
}

581
/* as H.263, but only 17 codes */
Fabrice Bellard's avatar
Fabrice Bellard committed
582 583
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
{
584
    int code, sign, val, l, shift;
Fabrice Bellard's avatar
Fabrice Bellard committed
585

586
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
Fabrice Bellard's avatar
Fabrice Bellard committed
587 588 589
    if (code == 0) {
        return pred;
    }
590 591 592 593
    if (code < 0) {
        return 0xffff;
    }

594
    sign = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
595
    shift = fcode - 1;
596 597 598
    val = code;
    if (shift) {
        val = (val - 1) << shift;
Fabrice Bellard's avatar
Fabrice Bellard committed
599
        val |= get_bits(&s->gb, shift);
600 601
        val++;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
602 603 604
    if (sign)
        val = -val;
    val += pred;
605

Fabrice Bellard's avatar
Fabrice Bellard committed
606
    /* modulo decoding */
Michael Niedermayer's avatar
Michael Niedermayer committed
607 608
    l= INT_BIT - 5 - shift;
    val = (val<<l)>>l;
Fabrice Bellard's avatar
Fabrice Bellard committed
609 610 611
    return val;
}

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

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

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

            block[j] = level;
        }
        CLOSE_READER(re, &s->gb);
    }
    s->block_last_index[n] = i;
   return 0;
}

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

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

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

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

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

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

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

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

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

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


857 858
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
                               DCTELEM *block,
859
                               int n)
Fabrice Bellard's avatar
Fabrice Bellard committed
860 861
{
    int level, i, j, run;
862
    RLTable *rl = &ff_rl_mpeg1;
863 864
    uint8_t * const scantable= s->intra_scantable.permutated;
    const uint16_t *quant_matrix;
865
    const int qscale= s->qscale;
Fabrice Bellard's avatar
Fabrice Bellard committed
866 867 868 869 870
    int mismatch;

    mismatch = 1;

    {
871
        OPEN_READER(re, &s->gb);
872
        i = -1;
873
        if (n < 4)
874
            quant_matrix = s->inter_matrix;
Fabrice Bellard's avatar
Fabrice Bellard committed
875
        else
876
            quant_matrix = s->chroma_inter_matrix;
877

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

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

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

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
942 943 944 945
    s->block_last_index[n] = i;
    return 0;
}

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

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

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

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

            i += run;
            j = scantable[i];
            if(level<0){
                level= ((-level*2+1)*qscale)>>1;
                level= -level;
            }else{
                level= ((level*2+1)*qscale)>>1;
            }
        }
998

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


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

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

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

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

1086 1087
            mismatch^= level;
            block[j] = level;
1088
        }
1089
        CLOSE_READER(re, &s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
1090
    }
1091
    block[63]^= mismatch&1;
1092

Fabrice Bellard's avatar
Fabrice Bellard committed
1093 1094 1095 1096
    s->block_last_index[n] = i;
    return 0;
}

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

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

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

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

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
1167 1168 1169
typedef struct Mpeg1Context {
    MpegEncContext mpeg_enc_ctx;
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1170
    int repeat_field; /* true if we must repeat the field */
1171
    AVPanScan pan_scan; /** some temporary storage for the panscan */
1172
    int slice_count;
1173 1174
    int swap_uv;//indicate VCR2
    int save_aspect_info;
1175
    int save_width, save_height, save_progressive_seq;
Michael Niedermayer's avatar
Michael Niedermayer committed
1176
    AVRational frame_rate_ext;       ///< MPEG-2 specific framerate modificator
1177
    int sync;                        ///< Did we reach a sync point like a GOP/SEQ/KEYFrame?
Fabrice Bellard's avatar
Fabrice Bellard committed
1178 1179
} Mpeg1Context;

1180
static av_cold int mpeg_decode_init(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
1181 1182
{
    Mpeg1Context *s = avctx->priv_data;
Michael Niedermayer's avatar
Michael Niedermayer committed
1183
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
Ivan Kalvachev's avatar
Ivan Kalvachev committed
1184
    int i;
1185

1186 1187
    /* we need some permutation to store matrices,
     * until MPV_common_init() sets the real permutation. */
Ivan Kalvachev's avatar
Ivan Kalvachev committed
1188 1189 1190
    for(i=0;i<64;i++)
       s2->dsp.idct_permutation[i]=i;

Michael Niedermayer's avatar
Michael Niedermayer committed
1191
    MPV_decode_defaults(s2);
1192

1193
    s->mpeg_enc_ctx.avctx= avctx;
Michael Niedermayer's avatar
Michael Niedermayer committed
1194
    s->mpeg_enc_ctx.flags= avctx->flags;
1195
    s->mpeg_enc_ctx.flags2= avctx->flags2;
1196
    ff_mpeg12_common_init(&s->mpeg_enc_ctx);
1197
    ff_mpeg12_init_vlcs();
Fabrice Bellard's avatar
Fabrice Bellard committed
1198 1199 1200

    s->mpeg_enc_ctx_allocated = 0;
    s->mpeg_enc_ctx.picture_number = 0;
1201
    s->repeat_field = 0;
1202
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1203
    avctx->color_range= AVCOL_RANGE_MPEG;
1204 1205 1206 1207
    if (avctx->codec->id == CODEC_ID_MPEG1VIDEO)
        avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
    else
        avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
Fabrice Bellard's avatar
Fabrice Bellard committed
1208 1209 1210
    return 0;
}

1211
static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
1212
                                     const uint8_t *new_perm){
Michael Niedermayer's avatar
Michael Niedermayer committed
1213 1214
    uint16_t temp_matrix[64];
    int i;
1215 1216

    memcpy(temp_matrix,matrix,64*sizeof(uint16_t));
1217

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

1223
static enum PixelFormat mpeg_get_pixelformat(AVCodecContext *avctx){
1224 1225 1226 1227 1228
    Mpeg1Context *s1 = avctx->priv_data;
    MpegEncContext *s = &s1->mpeg_enc_ctx;

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

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

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

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

1269 1270
        if( (s->width == 0 )||(s->height == 0))
            return -2;
1271

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

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

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

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

1333 1334
        /* Quantization matrices may need reordering
         * if DCT permutation is changed. */
1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
        memcpy(old_permutation,s->dsp.idct_permutation,64*sizeof(uint8_t));

        if (MPV_common_init(s) < 0)
            return -2;

        quant_matrix_rebuild(s->intra_matrix,       old_permutation,s->dsp.idct_permutation);
        quant_matrix_rebuild(s->inter_matrix,       old_permutation,s->dsp.idct_permutation);
        quant_matrix_rebuild(s->chroma_intra_matrix,old_permutation,s->dsp.idct_permutation);
        quant_matrix_rebuild(s->chroma_inter_matrix,old_permutation,s->dsp.idct_permutation);

        s1->mpeg_enc_ctx_allocated = 1;
    }
    return 0;
}

1350
static int mpeg1_decode_picture(AVCodecContext *avctx,
Zdenek Kabelac's avatar
Zdenek Kabelac committed
1351
                                const uint8_t *buf, int buf_size)
Fabrice Bellard's avatar
Fabrice Bellard committed
1352 1353 1354
{
    Mpeg1Context *s1 = avctx->priv_data;
    MpegEncContext *s = &s1->mpeg_enc_ctx;
Michael Niedermayer's avatar
Michael Niedermayer committed
1355
    int ref, f_code, vbv_delay;
Fabrice Bellard's avatar
Fabrice Bellard committed
1356

1357
    init_get_bits(&s->gb, buf, buf_size*8);
Fabrice Bellard's avatar
Fabrice Bellard committed
1358 1359 1360

    ref = get_bits(&s->gb, 10); /* temporal ref */
    s->pict_type = get_bits(&s->gb, 3);
1361 1362
    if(s->pict_type == 0 || s->pict_type > 3)
        return -1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1363

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
1387 1388 1389 1390 1391
    s->y_dc_scale = 8;
    s->c_dc_scale = 8;
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
1392
static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
Fabrice Bellard's avatar
Fabrice Bellard committed
1393
{
Michael Niedermayer's avatar
Michael Niedermayer committed
1394
    MpegEncContext *s= &s1->mpeg_enc_ctx;
Fabrice Bellard's avatar
Fabrice Bellard committed
1395
    int horiz_size_ext, vert_size_ext;
1396
    int bit_rate_ext;
Fabrice Bellard's avatar
Fabrice Bellard committed
1397

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

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

Michael Niedermayer's avatar
Michael Niedermayer committed
1415 1416
    s1->frame_rate_ext.num = get_bits(&s->gb, 2)+1;
    s1->frame_rate_ext.den = get_bits(&s->gb, 5)+1;
1417

1418
    dprintf(s->avctx, "sequence extension\n");
Michael Niedermayer's avatar
Michael Niedermayer committed
1419
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
1420
    s->avctx->sub_id = 2; /* indicates MPEG-2 found */
1421

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

Fabrice Bellard's avatar
Fabrice Bellard committed
1426 1427
}

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

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

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

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

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

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

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

1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], uint16_t matrix1[64], int intra){
    int i;

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

Fabrice Bellard's avatar
Fabrice Bellard committed
1507 1508
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
{
1509
    dprintf(s->avctx, "matrix extension\n");
1510

1511 1512 1513 1514
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, NULL           , 1);
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, NULL           , 0);
Fabrice Bellard's avatar
Fabrice Bellard committed
1515 1516
}

1517
static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
Fabrice Bellard's avatar
Fabrice Bellard committed
1518
{
1519 1520
    MpegEncContext *s= &s1->mpeg_enc_ctx;

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

1550
    if(s->progressive_sequence && !s->progressive_frame){
1551
        s->progressive_frame= 1;
1552 1553 1554 1555 1556
        av_log(s->avctx, AV_LOG_ERROR, "interlaced frame in progressive sequence, ignoring\n");
    }

    if(s->picture_structure==0 || (s->progressive_frame && s->picture_structure!=PICT_FRAME)){
        av_log(s->avctx, AV_LOG_ERROR, "picture_structure %d invalid, ignoring\n", s->picture_structure);
1557
        s->picture_structure= PICT_FRAME;
1558 1559
    }

1560
    if(s->progressive_sequence && !s->frame_pred_frame_dct){
1561
        av_log(s->avctx, AV_LOG_ERROR, "invalid frame_pred_frame_dct\n");
1562 1563 1564
        s->frame_pred_frame_dct= 1;
    }

1565
    if(s->picture_structure == PICT_FRAME){
1566
        s->first_field=0;
1567 1568
        s->v_edge_pos= 16*s->mb_height;
    }else{
1569
        s->first_field ^= 1;
1570
        s->v_edge_pos=  8*s->mb_height;
1571
        memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
1572
    }
1573

1574
    if(s->alternate_scan){
Michael Niedermayer's avatar
Michael Niedermayer committed
1575 1576
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
1577
    }else{
Michael Niedermayer's avatar
Michael Niedermayer committed
1578 1579
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
1580
    }
1581

Fabrice Bellard's avatar
Fabrice Bellard committed
1582
    /* composite display not parsed */
1583 1584 1585 1586 1587 1588 1589 1590 1591
    dprintf(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
    dprintf(s->avctx, "picture_structure=%d\n", s->picture_structure);
    dprintf(s->avctx, "top field first=%d\n", s->top_field_first);
    dprintf(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
    dprintf(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
    dprintf(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
    dprintf(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
    dprintf(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
    dprintf(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
Fabrice Bellard's avatar
Fabrice Bellard committed
1592 1593
}

1594
static void exchange_uv(MpegEncContext *s){
1595 1596 1597
    DCTELEM (*tmp)[64];

    tmp           = s->pblocks[4];
1598 1599
    s->pblocks[4] = s->pblocks[5];
    s->pblocks[5] = tmp;
Michael Niedermayer's avatar
Michael Niedermayer committed
1600 1601
}

1602
static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size){
1603 1604
    AVCodecContext *avctx= s->avctx;
    Mpeg1Context *s1 = (Mpeg1Context*)s;
Fabrice Bellard's avatar
Fabrice Bellard committed
1605 1606

    /* start frame decoding */
1607
    if(s->first_field || s->picture_structure==PICT_FRAME){
1608
        if(MPV_frame_start(s, avctx) < 0)
1609
            return -1;
1610 1611 1612

        ff_er_frame_start(s);

1613
        /* first check if we must repeat the frame */
1614
        s->current_picture_ptr->repeat_pict = 0;
1615 1616 1617
        if (s->repeat_first_field) {
            if (s->progressive_sequence) {
                if (s->top_field_first)
1618
                    s->current_picture_ptr->repeat_pict = 4;
1619
                else
1620
                    s->current_picture_ptr->repeat_pict = 2;
1621
            } else if (s->progressive_frame) {
1622
                s->current_picture_ptr->repeat_pict = 1;
1623
            }
1624
        }
1625 1626

        *s->current_picture_ptr->pan_scan= s1->pan_scan;
1627
    }else{ //second field
1628
            int i;
1629

1630
            if(!s->current_picture_ptr){
1631
                av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1632 1633
                return -1;
            }
1634

1635 1636 1637 1638
            for(i=0; i<4; i++){
                s->current_picture.data[i] = s->current_picture_ptr->data[i];
                if(s->picture_structure == PICT_BOTTOM_FIELD){
                    s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
1639
                }
1640
            }
1641
    }
1642 1643 1644 1645 1646 1647

    if (avctx->hwaccel) {
        if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
            return -1;
    }

Ivan Kalvachev's avatar
Ivan Kalvachev committed
1648 1649
// MPV_frame_start will call this function too,
// but we need to call it on every field
1650
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
Ivan Kalvachev's avatar
Ivan Kalvachev committed
1651
        if(ff_xvmc_field_start(s,avctx) < 0)
1652
            return -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1653

1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665
    return 0;
}

#define DECODE_SLICE_ERROR -1
#define DECODE_SLICE_OK 0

/**
 * decodes a slice. MpegEncContext.mb_y must be set to the MB row from the startcode
 * @return DECODE_SLICE_ERROR if the slice is damaged<br>
 *         DECODE_SLICE_OK if this slice is ok<br>
 */
static int mpeg_decode_slice(Mpeg1Context *s1, int mb_y,
Zdenek Kabelac's avatar
Zdenek Kabelac committed
1666
                             const uint8_t **buf, int buf_size)
1667 1668 1669 1670
{
    MpegEncContext *s = &s1->mpeg_enc_ctx;
    AVCodecContext *avctx= s->avctx;
    const int field_pic= s->picture_structure != PICT_FRAME;
1671
    const int lowres= s->avctx->lowres;
1672 1673 1674 1675

    s->resync_mb_x=
    s->resync_mb_y= -1;

1676
    assert(mb_y < s->mb_height);
1677

1678
    init_get_bits(&s->gb, *buf, buf_size*8);
Fabrice Bellard's avatar
Fabrice Bellard committed
1679

1680 1681 1682
    ff_mpeg1_clean_buffers(s);
    s->interlaced_dct = 0;

1683
    s->qscale = get_qscale(s);
1684

1685
    if(s->qscale == 0){
1686
        av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1687
        return -1;
1688
    }
1689

Fabrice Bellard's avatar
Fabrice Bellard committed
1690
    /* extra slice info */
1691 1692
    while (get_bits1(&s->gb) != 0) {
        skip_bits(&s->gb, 8);
Fabrice Bellard's avatar
Fabrice Bellard committed
1693
    }
1694

1695
    s->mb_x=0;
1696

1697 1698 1699
    if(mb_y==0 && s->codec_tag == AV_RL32("SLIF")){
        skip_bits1(&s->gb);
    }else{
1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
        for(;;) {
            int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
            if (code < 0){
                av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
                return -1;
            }
            if (code >= 33) {
                if (code == 33) {
                    s->mb_x += 33;
                }
                /* otherwise, stuffing, nothing to do */
            } else {
                s->mb_x += code;
                break;
1714 1715 1716
            }
        }
    }
1717

1718 1719 1720 1721
    if(s->mb_x >= (unsigned)s->mb_width){
        av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
        return -1;
    }
1722

1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735
    if (avctx->hwaccel) {
        const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
        int start_code = -1;
        buf_end = ff_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
        if (buf_end < *buf + buf_size)
            buf_end -= 4;
        s->mb_y = mb_y;
        if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
            return DECODE_SLICE_ERROR;
        *buf = buf_end;
        return DECODE_SLICE_OK;
    }

1736
    s->resync_mb_x= s->mb_x;
1737
    s->resync_mb_y= s->mb_y= mb_y;
1738
    s->mb_skip_run= 0;
1739
    ff_init_block_index(s);
1740

1741 1742
    if (s->mb_y==0 && s->mb_x==0 && (s->first_field || s->picture_structure==PICT_FRAME)) {
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1743
             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",
1744
                 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],
1745
                 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")),
1746
                 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"",
1747 1748 1749
                 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
                 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
        }
1750 1751
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
1752
    for(;;) {
1753
        //If 1, we memcpy blocks in xvmcvideo.
1754
        if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1)
1755
            ff_xvmc_init_block(s);//set s->block
1756

1757
        if(mpeg_decode_mb(s, s->block) < 0)
Fabrice Bellard's avatar
Fabrice Bellard committed
1758
            return -1;
1759

1760
        if(s->current_picture.motion_val[0] && !s->encoding){ //note motion_val is normally NULL unless we want to extract the MVs
1761
            const int wrap = s->b8_stride;
1762
            int xy = s->mb_x*2 + s->mb_y*2*wrap;
1763
            int b8_xy= 4*(s->mb_x + s->mb_y*s->mb_stride);
1764
            int motion_x, motion_y, dir, i;
1765

Michael Niedermayer's avatar
Michael Niedermayer committed
1766 1767
            for(i=0; i<2; i++){
                for(dir=0; dir<2; dir++){
1768
                    if (s->mb_intra || (dir==1 && s->pict_type != FF_B_TYPE)) {
1769
                        motion_x = motion_y = 0;
1770
                    }else if (s->mv_type == MV_TYPE_16X16 || (s->mv_type == MV_TYPE_FIELD && field_pic)){
1771 1772 1773 1774 1775 1776
                        motion_x = s->mv[dir][0][0];
                        motion_y = s->mv[dir][0][1];
                    } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ {
                        motion_x = s->mv[dir][i][0];
                        motion_y = s->mv[dir][i][1];
                    }
1777

1778 1779 1780 1781
                    s->current_picture.motion_val[dir][xy    ][0] = motion_x;
                    s->current_picture.motion_val[dir][xy    ][1] = motion_y;
                    s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
                    s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1782 1783
                    s->current_picture.ref_index [dir][b8_xy    ]=
                    s->current_picture.ref_index [dir][b8_xy + 1]= s->field_select[dir][i];
Michael Niedermayer's avatar
Michael Niedermayer committed
1784
                    assert(s->field_select[dir][i]==0 || s->field_select[dir][i]==1);
1785
                }
Michael Niedermayer's avatar
Michael Niedermayer committed
1786
                xy += wrap;
1787
                b8_xy +=2;
1788 1789
            }
        }
1790

1791
        s->dest[0] += 16 >> lowres;
1792 1793
        s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
        s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1794

1795
        MPV_decode_mb(s, s->block);
1796

1797
        if (++s->mb_x >= s->mb_width) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1798
            const int mb_size= 16>>s->avctx->lowres;
Michael Niedermayer's avatar
Michael Niedermayer committed
1799

1800
            ff_draw_horiz_band(s, mb_size*(s->mb_y>>field_pic), mb_size);
1801 1802

            s->mb_x = 0;
1803
            s->mb_y += 1<<field_pic;
1804

1805
            if(s->mb_y >= s->mb_height){
1806
                int left= get_bits_left(&s->gb);
1807
                int is_d10= s->chroma_format==2 && s->pict_type==FF_I_TYPE && avctx->profile==0 && avctx->level==5
Michael Niedermayer's avatar
Michael Niedermayer committed
1808 1809
                            && s->intra_dc_precision == 2 && s->q_scale_type == 1 && s->alternate_scan == 0
                            && s->progressive_frame == 0 /* vbv_delay == 0xBBB || 0xE10*/;
1810

Michael Niedermayer's avatar
Michael Niedermayer committed
1811
                if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10)
1812
                   || (avctx->error_recognition >= FF_ER_AGGRESSIVE && left>8)){
Michael Niedermayer's avatar
Michael Niedermayer committed
1813
                    av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n", left, show_bits(&s->gb, FFMIN(left, 23)));
1814 1815 1816 1817
                    return -1;
                }else
                    goto eos;
            }
1818

1819
            ff_init_block_index(s);
1820 1821 1822
        }

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

                /* skip mb */
                s->mb_intra = 0;
                for(i=0;i<12;i++)
                    s->block_last_index[i] = -1;
                if(s->picture_structure == PICT_FRAME)
                    s->mv_type = MV_TYPE_16X16;
                else
                    s->mv_type = MV_TYPE_FIELD;
1863
                if (s->pict_type == FF_P_TYPE) {
1864 1865 1866 1867 1868
                    /* if P type, zero motion vector is implied */
                    s->mv_dir = MV_DIR_FORWARD;
                    s->mv[0][0][0] = s->mv[0][0][1] = 0;
                    s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
                    s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1869
                    s->field_select[0][0]= (s->picture_structure - 1) & 1;
1870 1871 1872 1873 1874 1875 1876 1877
                } else {
                    /* if B type, reuse previous vectors and directions */
                    s->mv[0][0][0] = s->last_mv[0][0][0];
                    s->mv[0][0][1] = s->last_mv[0][0][1];
                    s->mv[1][0][0] = s->last_mv[1][0][0];
                    s->mv[1][0][1] = s->last_mv[1][0][1];
                }
            }
1878
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1879
    }
1880
eos: // end of slice
1881
    *buf += (get_bits_count(&s->gb)-1)/8;
1882
//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
1883 1884
    return 0;
}
1885

1886
static int slice_decode_thread(AVCodecContext *c, void *arg){
1887
    MpegEncContext *s= *(void**)arg;
1888
    const uint8_t *buf= s->gb.buffer;
1889
    int mb_y= s->start_mb_y;
1890
    const int field_pic= s->picture_structure != PICT_FRAME;
1891

1892
    s->error_count= (3*(s->end_mb_y - s->start_mb_y)*s->mb_width) >> field_pic;
1893 1894

    for(;;){
1895 1896
        uint32_t start_code;
        int ret;
1897 1898 1899

        ret= mpeg_decode_slice((Mpeg1Context*)s, mb_y, &buf, s->gb.buffer_end - buf);
        emms_c();
1900
//av_log(c, AV_LOG_DEBUG, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
1901 1902 1903 1904 1905 1906 1907
//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);
        if(ret < 0){
            if(s->resync_mb_x>=0 && s->resync_mb_y>=0)
                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);
        }else{
            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);
        }
1908

1909 1910
        if(s->mb_y == s->end_mb_y)
            return 0;
1911

1912 1913
        start_code= -1;
        buf = ff_find_start_code(buf, s->gb.buffer_end, &start_code);
1914 1915 1916 1917
        mb_y= start_code - SLICE_MIN_START_CODE;
        if(mb_y < 0 || mb_y >= s->end_mb_y)
            return -1;
    }
1918

1919 1920 1921
    return 0; //not reached
}

1922
/**
1923
 * Handles slice ends.
1924
 * @return 1 if it seems to be the last slice
1925 1926 1927 1928 1929
 */
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
{
    Mpeg1Context *s1 = avctx->priv_data;
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1930

1931
    if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
1932 1933
        return 0;

1934 1935 1936 1937 1938
    if (s->avctx->hwaccel) {
        if (s->avctx->hwaccel->end_frame(s->avctx) < 0)
            av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n");
    }

1939
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1940
        ff_xvmc_field_end(s);
1941

Fabrice Bellard's avatar
Fabrice Bellard committed
1942
    /* end of slice reached */
1943
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
Fabrice Bellard's avatar
Fabrice Bellard committed
1944
        /* end of image */
Michael Niedermayer's avatar
Michael Niedermayer committed
1945

Michael Niedermayer's avatar
Michael Niedermayer committed
1946
        s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
Michael Niedermayer's avatar
Michael Niedermayer committed
1947

1948
        ff_er_frame_end(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
1949 1950 1951

        MPV_frame_end(s);

1952
        if (s->pict_type == FF_B_TYPE || s->low_delay) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1953
            *pict= *(AVFrame*)s->current_picture_ptr;
1954
            ff_print_debug_info(s, pict);
Fabrice Bellard's avatar
Fabrice Bellard committed
1955
        } else {
Michael Niedermayer's avatar
Michael Niedermayer committed
1956
            s->picture_number++;
1957
            /* latency of 1 frame for I- and P-frames */
Fabrice Bellard's avatar
Fabrice Bellard committed
1958
            /* XXX: use another variable than picture_number */
1959
            if (s->last_picture_ptr != NULL) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1960
                *pict= *(AVFrame*)s->last_picture_ptr;
1961
                 ff_print_debug_info(s, pict);
Fabrice Bellard's avatar
Fabrice Bellard committed
1962 1963
            }
        }
1964 1965 1966 1967

        return 1;
    } else {
        return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1968 1969 1970
    }
}

1971
static int mpeg1_decode_sequence(AVCodecContext *avctx,
Zdenek Kabelac's avatar
Zdenek Kabelac committed
1972
                                 const uint8_t *buf, int buf_size)
Fabrice Bellard's avatar
Fabrice Bellard committed
1973 1974 1975
{
    Mpeg1Context *s1 = avctx->priv_data;
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1976
    int width,height;
1977
    int i, v, j;
1978

1979
    init_get_bits(&s->gb, buf, buf_size*8);
Fabrice Bellard's avatar
Fabrice Bellard committed
1980

1981 1982
    width = get_bits(&s->gb, 12);
    height = get_bits(&s->gb, 12);
1983
    if (width <= 0 || height <= 0)
1984
        return -1;
1985
    s->aspect_ratio_info= get_bits(&s->gb, 4);
1986 1987
    if (s->aspect_ratio_info == 0) {
        av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
1988
        if (avctx->error_recognition >= FF_ER_COMPLIANT)
1989 1990
            return -1;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
1991
    s->frame_rate_index = get_bits(&s->gb, 4);
1992
    if (s->frame_rate_index == 0 || s->frame_rate_index > 13)
Fabrice Bellard's avatar
Fabrice Bellard committed
1993 1994
        return -1;
    s->bit_rate = get_bits(&s->gb, 18) * 400;
1995
    if (get_bits1(&s->gb) == 0) /* marker */
Fabrice Bellard's avatar
Fabrice Bellard committed
1996
        return -1;
1997 1998
    s->width = width;
    s->height = height;
Fabrice Bellard's avatar
Fabrice Bellard committed
1999

2000
    s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16;
2001
    skip_bits(&s->gb, 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2002 2003

    /* get matrix */
2004
    if (get_bits1(&s->gb)) {
2005
        load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2006 2007
    } else {
        for(i=0;i<64;i++) {
2008
            j = s->dsp.idct_permutation[i];
2009
            v = ff_mpeg1_default_intra_matrix[i];
2010 2011
            s->intra_matrix[j] = v;
            s->chroma_intra_matrix[j] = v;
Fabrice Bellard's avatar
Fabrice Bellard committed
2012 2013
        }
    }
2014
    if (get_bits1(&s->gb)) {
2015
        load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
Fabrice Bellard's avatar
Fabrice Bellard committed
2016 2017
    } else {
        for(i=0;i<64;i++) {
2018
            int j= s->dsp.idct_permutation[i];
2019
            v = ff_mpeg1_default_non_intra_matrix[i];
2020 2021
            s->inter_matrix[j] = v;
            s->chroma_inter_matrix[j] = v;
Fabrice Bellard's avatar
Fabrice Bellard committed
2022 2023
        }
    }
2024

2025 2026 2027 2028
    if(show_bits(&s->gb, 23) != 0){
        av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
        return -1;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
2029

2030
    /* we set MPEG-2 parameters so that it emulates MPEG-1 */
Fabrice Bellard's avatar
Fabrice Bellard committed
2031 2032 2033 2034
    s->progressive_sequence = 1;
    s->progressive_frame = 1;
    s->picture_structure = PICT_FRAME;
    s->frame_pred_frame_dct = 1;
2035
    s->chroma_format = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
2036
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO;
2037
    avctx->sub_id = 1; /* indicates MPEG-1 */
2038
    s->out_format = FMT_MPEG1;
2039
    s->swap_uv = 0;//AFAIK VCR2 does not have SEQ_HEADER
2040
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
2041

2042
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2043
        av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n",
2044
               s->avctx->rc_buffer_size, s->bit_rate);
2045

Fabrice Bellard's avatar
Fabrice Bellard committed
2046 2047 2048
    return 0;
}

2049 2050 2051 2052
static int vcr2_init_sequence(AVCodecContext *avctx)
{
    Mpeg1Context *s1 = avctx->priv_data;
    MpegEncContext *s = &s1->mpeg_enc_ctx;
Michael Niedermayer's avatar
Michael Niedermayer committed
2053
    int i, v;
2054

2055
    /* start new MPEG-1 context decoding */
2056 2057 2058 2059
    s->out_format = FMT_MPEG1;
    if (s1->mpeg_enc_ctx_allocated) {
        MPV_common_end(s);
    }
2060 2061
    s->width  = avctx->coded_width;
    s->height = avctx->coded_height;
2062
    avctx->has_b_frames= 0; //true?
Michael Niedermayer's avatar
Michael Niedermayer committed
2063
    s->low_delay= 1;
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2064

2065
    avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2066
    avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2067

2068
    if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT || avctx->hwaccel ||
2069
        s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU )
2070 2071
        if( avctx->idct_algo == FF_IDCT_AUTO )
            avctx->idct_algo = FF_IDCT_SIMPLE;
2072

2073 2074
    if (MPV_common_init(s) < 0)
        return -1;
2075
    exchange_uv(s);//common init reset pblocks, so we swap them here
2076
    s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB
2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093
    s1->mpeg_enc_ctx_allocated = 1;

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

        v = ff_mpeg1_default_non_intra_matrix[i];
        s->inter_matrix[j] = v;
        s->chroma_inter_matrix[j] = v;
    }

    s->progressive_sequence = 1;
    s->progressive_frame = 1;
    s->picture_structure = PICT_FRAME;
    s->frame_pred_frame_dct = 1;
2094
    s->chroma_format = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
2095
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2096
    avctx->sub_id = 2; /* indicates MPEG-2 */
2097 2098 2099
    s1->save_width           = s->width;
    s1->save_height          = s->height;
    s1->save_progressive_seq = s->progressive_sequence;
2100 2101 2102 2103
    return 0;
}


2104
static void mpeg_decode_user_data(AVCodecContext *avctx,
2105
                                  const uint8_t *p, int buf_size)
2106
{
2107
    const uint8_t *buf_end = p+buf_size;
2108 2109

    /* we parse the DTG active format information */
2110
    if (buf_end - p >= 5 &&
2111
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2112
        int flags = p[4];
2113 2114 2115 2116 2117 2118
        p += 5;
        if (flags & 0x80) {
            /* skip event id */
            p += 2;
        }
        if (flags & 0x40) {
2119
            if (buf_end - p < 1)
2120 2121 2122 2123 2124 2125
                return;
            avctx->dtg_active_format = p[0] & 0x0f;
        }
    }
}

2126
static void mpeg_decode_gop(AVCodecContext *avctx,
2127 2128 2129 2130 2131 2132 2133
                            const uint8_t *buf, int buf_size){
    Mpeg1Context *s1 = avctx->priv_data;
    MpegEncContext *s = &s1->mpeg_enc_ctx;

    int drop_frame_flag;
    int time_code_hours, time_code_minutes;
    int time_code_seconds, time_code_pictures;
2134
    int broken_link;
2135 2136 2137 2138

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

    drop_frame_flag = get_bits1(&s->gb);
2139

2140 2141 2142 2143 2144 2145
    time_code_hours=get_bits(&s->gb,5);
    time_code_minutes = get_bits(&s->gb,6);
    skip_bits1(&s->gb);//marker bit
    time_code_seconds = get_bits(&s->gb,6);
    time_code_pictures = get_bits(&s->gb,6);

2146
    s->closed_gop = get_bits1(&s->gb);
2147 2148 2149 2150 2151 2152
    /*broken_link indicate that after editing the
      reference frames of the first B-Frames after GOP I-Frame
      are missing (open gop)*/
    broken_link = get_bits1(&s->gb);

    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2153
        av_log(s->avctx, AV_LOG_DEBUG, "GOP (%2d:%02d:%02d.[%02d]) closed_gop=%d broken_link=%d\n",
2154
            time_code_hours, time_code_minutes, time_code_seconds,
2155
            time_code_pictures, s->closed_gop, broken_link);
2156
}
2157
/**
2158
 * Finds the end of the current frame in the bitstream.
2159 2160
 * @return the position of the first byte of the next frame, or -1
 */
2161
int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size, AVCodecParserContext *s)
2162
{
2163
    int i;
2164
    uint32_t state= pc->state;
2165

2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188
    /* EOF considered as end of frame */
    if (buf_size == 0)
        return 0;

/*
 0  frame start         -> 1/4
 1  first_SEQEXT        -> 0/2
 2  first field start   -> 3/0
 3  second_SEQEXT       -> 2/0
 4  searching end
*/

    for(i=0; i<buf_size; i++){
        assert(pc->frame_start_found>=0 && pc->frame_start_found<=4);
        if(pc->frame_start_found&1){
            if(state == EXT_START_CODE && (buf[i]&0xF0) != 0x80)
                pc->frame_start_found--;
            else if(state == EXT_START_CODE+2){
                if((buf[i]&3) == 3) pc->frame_start_found= 0;
                else                pc->frame_start_found= (pc->frame_start_found+1)&3;
            }
            state++;
        }else{
2189
            i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1;
2190
            if(pc->frame_start_found==0 && state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2191
                i++;
2192
                pc->frame_start_found=4;
2193
            }
2194 2195 2196 2197
            if(state == SEQ_END_CODE){
                pc->state=-1;
                return i+1;
            }
2198 2199 2200 2201 2202
            if(pc->frame_start_found==2 && state == SEQ_START_CODE)
                pc->frame_start_found= 0;
            if(pc->frame_start_found<4 && state == EXT_START_CODE)
                pc->frame_start_found++;
            if(pc->frame_start_found == 4 && (state&0xFFFFFF00) == 0x100){
2203 2204
                if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
                    pc->frame_start_found=0;
2205
                    pc->state=-1;
2206 2207 2208
                    return i-3;
                }
            }
2209
            if(pc->frame_start_found == 0 && s && state == PICTURE_START_CODE){
2210
                ff_fetch_timestamp(s, i-3, 1);
2211
            }
2212
        }
2213
    }
2214
    pc->state= state;
2215
    return END_NOT_FOUND;
2216 2217
}

2218 2219 2220 2221
static int decode_chunks(AVCodecContext *avctx,
                             AVFrame *picture, int *data_size,
                             const uint8_t *buf, int buf_size);

Fabrice Bellard's avatar
Fabrice Bellard committed
2222
/* handle buffering and image synchronisation */
2223
static int mpeg_decode_frame(AVCodecContext *avctx,
Fabrice Bellard's avatar
Fabrice Bellard committed
2224
                             void *data, int *data_size,
2225
                             AVPacket *avpkt)
Fabrice Bellard's avatar
Fabrice Bellard committed
2226
{
2227 2228
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
Fabrice Bellard's avatar
Fabrice Bellard committed
2229
    Mpeg1Context *s = avctx->priv_data;
2230
    AVFrame *picture = data;
2231
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2232
    dprintf(avctx, "fill_buffer\n");
Fabrice Bellard's avatar
Fabrice Bellard committed
2233

2234
    if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2235 2236 2237 2238
        /* special case for last picture */
        if (s2->low_delay==0 && s2->next_picture_ptr) {
            *picture= *(AVFrame*)s2->next_picture_ptr;
            s2->next_picture_ptr= NULL;
Michael Niedermayer's avatar
Michael Niedermayer committed
2239

2240 2241
            *data_size = sizeof(AVFrame);
        }
2242
        return buf_size;
Fabrice Bellard's avatar
Fabrice Bellard committed
2243 2244
    }

2245
    if(s2->flags&CODEC_FLAG_TRUNCATED){
2246
        int next= ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size, NULL);
2247

2248
        if( ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
2249
            return buf_size;
2250 2251 2252 2253
    }

#if 0
    if (s->repeat_field % 2 == 1) {
2254 2255
        s->repeat_field++;
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2256 2257 2258 2259 2260
        //        s2->picture_number, s->repeat_field);
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
            *data_size = sizeof(AVPicture);
            goto the_end;
        }
2261
    }
2262
#endif
2263

2264
    if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == AV_RL32("VCR2"))
2265
        vcr2_init_sequence(avctx);
2266

2267
    s->slice_count= 0;
2268

2269 2270 2271
    if(avctx->extradata && !avctx->frame_number)
        decode_chunks(avctx, picture, data_size, avctx->extradata, avctx->extradata_size);

2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283
    return decode_chunks(avctx, picture, data_size, buf, buf_size);
}

static int decode_chunks(AVCodecContext *avctx,
                             AVFrame *picture, int *data_size,
                             const uint8_t *buf, int buf_size)
{
    Mpeg1Context *s = avctx->priv_data;
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
    const uint8_t *buf_ptr = buf;
    const uint8_t *buf_end = buf + buf_size;
    int ret, input_size;
2284
    int last_code= 0;
2285

2286
    for(;;) {
2287
        /* find next start code */
2288
        uint32_t start_code = -1;
2289
        buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code);
2290
        if (start_code > 0x1ff){
2291
            if(s2->pict_type != FF_B_TYPE || avctx->skip_frame <= AVDISCARD_DEFAULT){
2292 2293 2294
                if(avctx->thread_count > 1){
                    int i;

2295
                    avctx->execute(avctx, slice_decode_thread,  &s2->thread_context[0], NULL, s->slice_count, sizeof(void*));
2296 2297 2298
                    for(i=0; i<s->slice_count; i++)
                        s2->error_count += s2->thread_context[i]->error_count;
                }
2299

2300
                if (CONFIG_MPEG_VDPAU_DECODER && avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2301 2302
                    ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);

2303 2304 2305 2306
                if (slice_end(avctx, picture)) {
                    if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
                        *data_size = sizeof(AVPicture);
                }
2307
            }
2308
            s2->pict_type= 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
2309
            return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
Fabrice Bellard's avatar
Fabrice Bellard committed
2310
        }
2311

2312 2313 2314
        input_size = buf_end - buf_ptr;

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

2318 2319 2320
        /* prepare data for next start code */
        switch(start_code) {
        case SEQ_START_CODE:
2321
            if(last_code == 0){
2322 2323
            mpeg1_decode_sequence(avctx, buf_ptr,
                                    input_size);
2324
                s->sync=1;
2325 2326 2327
            }else{
                av_log(avctx, AV_LOG_ERROR, "ignoring SEQ_START_CODE after %X\n", last_code);
            }
2328
            break;
2329

2330
        case PICTURE_START_CODE:
2331
            if(last_code == 0 || last_code == SLICE_MIN_START_CODE){
2332 2333 2334 2335 2336
            if(mpeg_decode_postinit(avctx) < 0){
                av_log(avctx, AV_LOG_ERROR, "mpeg_decode_postinit() failure\n");
                return -1;
            }

2337
            /* we have a complete image: we try to decompress it */
2338 2339 2340
            if(mpeg1_decode_picture(avctx,
                                    buf_ptr, input_size) < 0)
                s2->pict_type=0;
2341
                s2->first_slice = 1;
2342
            last_code= PICTURE_START_CODE;
2343 2344 2345
            }else{
                av_log(avctx, AV_LOG_ERROR, "ignoring pic after %X\n", last_code);
            }
2346 2347
            break;
        case EXT_START_CODE:
2348 2349 2350 2351
            init_get_bits(&s2->gb, buf_ptr, input_size*8);

            switch(get_bits(&s2->gb, 4)) {
            case 0x1:
2352
                if(last_code == 0){
2353
                mpeg_decode_sequence_extension(s);
2354 2355 2356
                }else{
                    av_log(avctx, AV_LOG_ERROR, "ignoring seq ext after %X\n", last_code);
                }
2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367
                break;
            case 0x2:
                mpeg_decode_sequence_display_extension(s);
                break;
            case 0x3:
                mpeg_decode_quant_matrix_extension(s2);
                break;
            case 0x7:
                mpeg_decode_picture_display_extension(s);
                break;
            case 0x8:
2368
                if(last_code == PICTURE_START_CODE){
2369
                mpeg_decode_picture_coding_extension(s);
2370 2371 2372
                }else{
                    av_log(avctx, AV_LOG_ERROR, "ignoring pic cod ext after %X\n", last_code);
                }
2373 2374
                break;
            }
2375 2376 2377 2378 2379 2380
            break;
        case USER_START_CODE:
            mpeg_decode_user_data(avctx,
                                    buf_ptr, input_size);
            break;
        case GOP_START_CODE:
2381
            if(last_code == 0){
2382 2383 2384
            s2->first_field=0;
            mpeg_decode_gop(avctx,
                                    buf_ptr, input_size);
2385
                s->sync=1;
2386 2387 2388
            }else{
                av_log(avctx, AV_LOG_ERROR, "ignoring GOP_START_CODE after %X\n", last_code);
            }
2389 2390 2391
            break;
        default:
            if (start_code >= SLICE_MIN_START_CODE &&
2392
                start_code <= SLICE_MAX_START_CODE && last_code!=0) {
2393 2394
                const int field_pic= s2->picture_structure != PICT_FRAME;
                int mb_y= (start_code - SLICE_MIN_START_CODE) << field_pic;
2395
                last_code= SLICE_MIN_START_CODE;
2396

2397 2398 2399
                if(s2->picture_structure == PICT_BOTTOM_FIELD)
                    mb_y++;

2400 2401 2402 2403 2404
                if (mb_y >= s2->mb_height){
                    av_log(s2->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
                    return -1;
                }

2405
                if(s2->last_picture_ptr==NULL){
2406 2407 2408 2409 2410
                /* Skip B-frames if we do not have reference frames and gop is not closed */
                    if(s2->pict_type==FF_B_TYPE){
                        if(!s2->closed_gop)
                            break;
                    }
2411
                }
2412 2413
                if(s2->pict_type==FF_I_TYPE)
                    s->sync=1;
2414
                if(s2->next_picture_ptr==NULL){
2415
                /* Skip P-frames if we do not have a reference frame or we have an invalid header. */
2416
                    if(s2->pict_type==FF_P_TYPE && !s->sync) break;
2417
                }
Diego Biurrun's avatar
Diego Biurrun committed
2418
                /* Skip B-frames if we are in a hurry. */
2419 2420 2421
                if(avctx->hurry_up && s2->pict_type==FF_B_TYPE) break;
                if(  (avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type==FF_B_TYPE)
                    ||(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type!=FF_I_TYPE)
2422
                    || avctx->skip_frame >= AVDISCARD_ALL)
Michael Niedermayer's avatar
Michael Niedermayer committed
2423
                    break;
Diego Biurrun's avatar
Diego Biurrun committed
2424
                /* Skip everything if we are in a hurry>=5. */
2425
                if(avctx->hurry_up>=5) break;
2426

2427 2428 2429 2430 2431 2432
                if (!s->mpeg_enc_ctx_allocated) break;

                if(s2->codec_id == CODEC_ID_MPEG2VIDEO){
                    if(mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom)
                        break;
                }
2433

2434 2435 2436 2437 2438
                if(!s2->pict_type){
                    av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
                    break;
                }

2439 2440
                if(s2->first_slice){
                    s2->first_slice=0;
2441
                    if(mpeg_field_start(s2, buf, buf_size) < 0)
2442
                        return -1;
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2443
                }
2444
                if(!s2->current_picture_ptr){
Diego Biurrun's avatar
Diego Biurrun committed
2445
                    av_log(avctx, AV_LOG_ERROR, "current_picture not initialized\n");
2446 2447
                    return -1;
                }
2448

2449 2450 2451 2452 2453
                if (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
                    s->slice_count++;
                    break;
                }

2454 2455 2456 2457 2458 2459 2460 2461 2462 2463
                if(avctx->thread_count > 1){
                    int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count;
                    if(threshold <= mb_y){
                        MpegEncContext *thread_context= s2->thread_context[s->slice_count];

                        thread_context->start_mb_y= mb_y;
                        thread_context->end_mb_y  = s2->mb_height;
                        if(s->slice_count){
                            s2->thread_context[s->slice_count-1]->end_mb_y= mb_y;
                            ff_update_duplicate_context(thread_context, s2);
Fabrice Bellard's avatar
Fabrice Bellard committed
2464
                        }
2465 2466 2467
                        init_get_bits(&thread_context->gb, buf_ptr, input_size*8);
                        s->slice_count++;
                    }
2468
                    buf_ptr += 2; //FIXME add minimum number of bytes per slice
2469 2470 2471 2472 2473 2474 2475 2476 2477
                }else{
                    ret = mpeg_decode_slice(s, mb_y, &buf_ptr, input_size);
                    emms_c();

                    if(ret < 0){
                        if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
                            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);
                    }else{
                        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);
Fabrice Bellard's avatar
Fabrice Bellard committed
2478 2479
                    }
                }
2480 2481 2482
            }
            break;
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
2483 2484 2485
    }
}

2486 2487 2488 2489 2490 2491 2492 2493
static void flush(AVCodecContext *avctx){
    Mpeg1Context *s = avctx->priv_data;

    s->sync=0;

    ff_mpeg_flush(avctx);
}

Fabrice Bellard's avatar
Fabrice Bellard committed
2494 2495 2496 2497 2498 2499 2500 2501 2502
static int mpeg_decode_end(AVCodecContext *avctx)
{
    Mpeg1Context *s = avctx->priv_data;

    if (s->mpeg_enc_ctx_allocated)
        MPV_common_end(&s->mpeg_enc_ctx);
    return 0;
}

2503 2504
AVCodec mpeg1video_decoder = {
    "mpeg1video",
2505
    AVMEDIA_TYPE_VIDEO,
Fabrice Bellard's avatar
Fabrice Bellard committed
2506 2507 2508 2509 2510 2511
    CODEC_ID_MPEG1VIDEO,
    sizeof(Mpeg1Context),
    mpeg_decode_init,
    NULL,
    mpeg_decode_end,
    mpeg_decode_frame,
2512
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2513
    .flush= flush,
2514
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2515 2516 2517 2518
};

AVCodec mpeg2video_decoder = {
    "mpeg2video",
2519
    AVMEDIA_TYPE_VIDEO,
2520 2521 2522 2523 2524 2525
    CODEC_ID_MPEG2VIDEO,
    sizeof(Mpeg1Context),
    mpeg_decode_init,
    NULL,
    mpeg_decode_end,
    mpeg_decode_frame,
2526
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2527
    .flush= flush,
2528
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-2 video"),
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2529 2530 2531 2532 2533
};

//legacy decoder
AVCodec mpegvideo_decoder = {
    "mpegvideo",
2534
    AVMEDIA_TYPE_VIDEO,
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2535 2536 2537 2538 2539 2540
    CODEC_ID_MPEG2VIDEO,
    sizeof(Mpeg1Context),
    mpeg_decode_init,
    NULL,
    mpeg_decode_end,
    mpeg_decode_frame,
2541
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2542
    .flush= flush,
2543
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
Fabrice Bellard's avatar
Fabrice Bellard committed
2544
};
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2545

2546
#if CONFIG_MPEG_XVMC_DECODER
2547
static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx){
2548
    if( avctx->thread_count > 1)
2549
        return -1;
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2550 2551
    if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
        return -1;
2552
    if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){
2553
        dprintf(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2554
    }
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2555 2556 2557
    mpeg_decode_init(avctx);

    avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
2558
    avctx->xvmc_acceleration = 2;//2 - the blocks are packed!
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2559 2560 2561 2562 2563 2564

    return 0;
}

AVCodec mpeg_xvmc_decoder = {
    "mpegvideo_xvmc",
2565
    AVMEDIA_TYPE_VIDEO,
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2566 2567 2568 2569 2570 2571
    CODEC_ID_MPEG2VIDEO_XVMC,
    sizeof(Mpeg1Context),
    mpeg_mc_decode_init,
    NULL,
    mpeg_decode_end,
    mpeg_decode_frame,
2572
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
2573
    .flush= flush,
2574
    .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2575 2576 2577
};

#endif
2578 2579 2580 2581

#if CONFIG_MPEG_VDPAU_DECODER
AVCodec mpeg_vdpau_decoder = {
    "mpegvideo_vdpau",
2582
    AVMEDIA_TYPE_VIDEO,
2583 2584 2585 2586 2587 2588 2589
    CODEC_ID_MPEG2VIDEO,
    sizeof(Mpeg1Context),
    mpeg_decode_init,
    NULL,
    mpeg_decode_end,
    mpeg_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
2590
    .flush= flush,
2591 2592 2593 2594
    .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
};
#endif

2595 2596 2597
#if CONFIG_MPEG1_VDPAU_DECODER
AVCodec mpeg1_vdpau_decoder = {
    "mpeg1video_vdpau",
2598
    AVMEDIA_TYPE_VIDEO,
2599 2600 2601 2602 2603 2604 2605
    CODEC_ID_MPEG1VIDEO,
    sizeof(Mpeg1Context),
    mpeg_decode_init,
    NULL,
    mpeg_decode_end,
    mpeg_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
2606
    .flush= flush,
2607 2608 2609 2610
    .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
};
#endif