Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ 755bfeab

History | View | Annotate | Download (114 KB)

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

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

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

    
33
#include "mpeg12data.h"
34
#include "bytestream.h"
35

    
36
//#undef NDEBUG
37
//#include <assert.h>
38

    
39

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

    
48
#ifdef CONFIG_ENCODERS
49
static void mpeg1_encode_block(MpegEncContext *s,
50
                         DCTELEM *block,
51
                         int component);
52
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code);    // RAL: f_code parameter added
53
#endif //CONFIG_ENCODERS
54
static inline int mpeg1_decode_block_inter(MpegEncContext *s,
55
                              DCTELEM *block,
56
                              int n);
57
static inline int mpeg1_decode_block_intra(MpegEncContext *s,
58
                              DCTELEM *block,
59
                              int n);
60
static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n);
61
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
62
                                        DCTELEM *block,
63
                                        int n);
64
static inline int mpeg2_decode_block_intra(MpegEncContext *s,
65
                                    DCTELEM *block,
66
                                    int n);
67
static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, DCTELEM *block, int n);
68
static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, DCTELEM *block, int n);
69
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
70
static void exchange_uv(MpegEncContext *s);
71

    
72
#ifdef HAVE_XVMC
73
extern int XVMC_field_start(MpegEncContext *s, AVCodecContext *avctx);
74
extern int XVMC_field_end(MpegEncContext *s);
75
extern void XVMC_pack_pblocks(MpegEncContext *s,int cbp);
76
extern void XVMC_init_block(MpegEncContext *s);//set s->block
77
#endif
78

    
79
static const enum PixelFormat pixfmt_yuv_420[]= {PIX_FMT_YUV420P,-1};
80
static const enum PixelFormat pixfmt_yuv_422[]= {PIX_FMT_YUV422P,-1};
81
static const enum PixelFormat pixfmt_yuv_444[]= {PIX_FMT_YUV444P,-1};
82
static const enum PixelFormat pixfmt_xvmc_mpg2_420[] = {
83
                                           PIX_FMT_XVMC_MPEG2_IDCT,
84
                                           PIX_FMT_XVMC_MPEG2_MC,
85
                                           -1};
86
#ifdef CONFIG_ENCODERS
87
static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
88
static uint8_t fcode_tab[MAX_MV*2+1];
89

    
90
static uint8_t  uni_mpeg1_ac_vlc_len [64*64*2];
91
static uint8_t  uni_mpeg2_ac_vlc_len [64*64*2];
92

    
93
/* simple include everything table for dc, first byte is bits number next 3 are code*/
94
static uint32_t mpeg1_lum_dc_uni[512];
95
static uint32_t mpeg1_chr_dc_uni[512];
96

    
97
static uint8_t mpeg1_index_run[2][64];
98
static int8_t mpeg1_max_level[2][64];
99
#endif //CONFIG_ENCODERS
100

    
101
static uint8_t static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3];
102

    
103
static void init_2d_vlc_rl(RLTable *rl, int use_static)
104
{
105
    int i;
106

    
107
    init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2,
108
             &rl->table_vlc[0][1], 4, 2,
109
             &rl->table_vlc[0][0], 4, 2, use_static);
110

    
111
    if(use_static)
112
        rl->rl_vlc[0]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
113
    else
114
        rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
115

    
116
    for(i=0; i<rl->vlc.table_size; i++){
117
        int code= rl->vlc.table[i][0];
118
        int len = rl->vlc.table[i][1];
119
        int level, run;
120

    
121
        if(len==0){ // illegal code
122
            run= 65;
123
            level= MAX_LEVEL;
124
        }else if(len<0){ //more bits needed
125
            run= 0;
126
            level= code;
127
        }else{
128
            if(code==rl->n){ //esc
129
                run= 65;
130
                level= 0;
131
            }else if(code==rl->n+1){ //eob
132
                run= 0;
133
                level= 127;
134
            }else{
135
                run=   rl->table_run  [code] + 1;
136
                level= rl->table_level[code];
137
            }
138
        }
139
        rl->rl_vlc[0][i].len= len;
140
        rl->rl_vlc[0][i].level= level;
141
        rl->rl_vlc[0][i].run= run;
142
    }
143
}
144

    
145
#ifdef CONFIG_ENCODERS
146
static void init_uni_ac_vlc(RLTable *rl, uint8_t *uni_ac_vlc_len){
147
    int i;
148

    
149
    for(i=0; i<128; i++){
150
        int level= i-64;
151
        int run;
152
        for(run=0; run<64; run++){
153
            int len, bits, code;
154

    
155
            int alevel= FFABS(level);
156
            int sign= (level>>31)&1;
157

    
158
            if (alevel > rl->max_level[0][run])
159
                code= 111; /*rl->n*/
160
            else
161
                code= rl->index_run[0][run] + alevel - 1;
162

    
163
            if (code < 111 /* rl->n */) {
164
                /* store the vlc & sign at once */
165
                len=   rl->table_vlc[code][1]+1;
166
                bits= (rl->table_vlc[code][0]<<1) + sign;
167
            } else {
168
                len=  rl->table_vlc[111/*rl->n*/][1]+6;
169
                bits= rl->table_vlc[111/*rl->n*/][0]<<6;
170

    
171
                bits|= run;
172
                if (alevel < 128) {
173
                    bits<<=8; len+=8;
174
                    bits|= level & 0xff;
175
                } else {
176
                    bits<<=16; len+=16;
177
                    bits|= level & 0xff;
178
                    if (level < 0) {
179
                        bits|= 0x8001 + level + 255;
180
                    } else {
181
                        bits|= level & 0xffff;
182
                    }
183
                }
184
            }
185

    
186
            uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len;
187
        }
188
    }
189
}
190

    
191

    
192
static int find_frame_rate_index(MpegEncContext *s){
193
    int i;
194
    int64_t dmin= INT64_MAX;
195
    int64_t d;
196

    
197
    for(i=1;i<14;i++) {
198
        int64_t n0= 1001LL/ff_frame_rate_tab[i].den*ff_frame_rate_tab[i].num*s->avctx->time_base.num;
199
        int64_t n1= 1001LL*s->avctx->time_base.den;
200
        if(s->avctx->strict_std_compliance > FF_COMPLIANCE_INOFFICIAL && i>=9) break;
201

    
202
        d = FFABS(n0 - n1);
203
        if(d < dmin){
204
            dmin=d;
205
            s->frame_rate_index= i;
206
        }
207
    }
208
    if(dmin)
209
        return -1;
210
    else
211
        return 0;
212
}
213

    
214
static int encode_init(AVCodecContext *avctx)
215
{
216
    MpegEncContext *s = avctx->priv_data;
217

    
218
    if(MPV_encode_init(avctx) < 0)
219
        return -1;
220

    
221
    if(find_frame_rate_index(s) < 0){
222
        if(s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){
223
            av_log(avctx, AV_LOG_ERROR, "MPEG1/2 does not support %d/%d fps\n", avctx->time_base.den, avctx->time_base.num);
224
            return -1;
225
        }else{
226
            av_log(avctx, AV_LOG_INFO, "MPEG1/2 does not support %d/%d fps, there may be AV sync issues\n", avctx->time_base.den, avctx->time_base.num);
227
        }
228
    }
229

    
230
    if(avctx->profile == FF_PROFILE_UNKNOWN){
231
        if(avctx->level != FF_LEVEL_UNKNOWN){
232
            av_log(avctx, AV_LOG_ERROR, "Set profile and level\n");
233
            return -1;
234
        }
235
        avctx->profile = s->chroma_format == CHROMA_420 ? 4 : 0; /* Main or 4:2:2 */
236
    }
237

    
238
    if(avctx->level == FF_LEVEL_UNKNOWN){
239
        if(avctx->profile == 0){ /* 4:2:2 */
240
            if(avctx->width <= 720 && avctx->height <= 608) avctx->level = 5; /* Main */
241
            else                                            avctx->level = 2; /* High */
242
        }else{
243
            if(avctx->profile != 1 && s->chroma_format != CHROMA_420){
244
                av_log(avctx, AV_LOG_ERROR, "Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n");
245
                return -1;
246
            }
247
            if(avctx->width <= 720 && avctx->height <= 576) avctx->level = 8; /* Main */
248
            else if(avctx->width <= 1440)                   avctx->level = 6; /* High 1440 */
249
            else                                            avctx->level = 4; /* High */
250
        }
251
    }
252

    
253
    if((avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE) && s->frame_rate_index != 4){
254
        av_log(avctx, AV_LOG_ERROR, "Drop frame time code only allowed with 1001/30000 fps\n");
255
        return -1;
256
    }
257

    
258
    return 0;
259
}
260

    
261
static void put_header(MpegEncContext *s, int header)
262
{
263
    align_put_bits(&s->pb);
264
    put_bits(&s->pb, 16, header>>16);
265
    put_bits(&s->pb, 16, header&0xFFFF);
266
}
267

    
268
/* put sequence header if needed */
269
static void mpeg1_encode_sequence_header(MpegEncContext *s)
270
{
271
        unsigned int vbv_buffer_size;
272
        unsigned int fps, v;
273
        int i;
274
        uint64_t time_code;
275
        float best_aspect_error= 1E10;
276
        float aspect_ratio= av_q2d(s->avctx->sample_aspect_ratio);
277
        int constraint_parameter_flag;
278

    
279
        if(aspect_ratio==0.0) aspect_ratio= 1.0; //pixel aspect 1:1 (VGA)
280

    
281
        if (s->current_picture.key_frame) {
282
            AVRational framerate= ff_frame_rate_tab[s->frame_rate_index];
283

    
284
            /* mpeg1 header repeated every gop */
285
            put_header(s, SEQ_START_CODE);
286

    
287
            put_bits(&s->pb, 12, s->width);
288
            put_bits(&s->pb, 12, s->height);
289

    
290
            for(i=1; i<15; i++){
291
                float error= aspect_ratio;
292
                if(s->codec_id == CODEC_ID_MPEG1VIDEO || i <=1)
293
                    error-= 1.0/mpeg1_aspect[i];
294
                else
295
                    error-= av_q2d(mpeg2_aspect[i])*s->height/s->width;
296

    
297
                error= FFABS(error);
298

    
299
                if(error < best_aspect_error){
300
                    best_aspect_error= error;
301
                    s->aspect_ratio_info= i;
302
                }
303
            }
304

    
305
            put_bits(&s->pb, 4, s->aspect_ratio_info);
306
            put_bits(&s->pb, 4, s->frame_rate_index);
307

    
308
            if(s->avctx->rc_max_rate){
309
                v = (s->avctx->rc_max_rate + 399) / 400;
310
                if (v > 0x3ffff && s->codec_id == CODEC_ID_MPEG1VIDEO)
311
                    v = 0x3ffff;
312
            }else{
313
                v= 0x3FFFF;
314
            }
315

    
316
            if(s->avctx->rc_buffer_size)
317
                vbv_buffer_size = s->avctx->rc_buffer_size;
318
            else
319
                /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */
320
                vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
321
            vbv_buffer_size= (vbv_buffer_size + 16383) / 16384;
322

    
323
            put_bits(&s->pb, 18, v & 0x3FFFF);
324
            put_bits(&s->pb, 1, 1); /* marker */
325
            put_bits(&s->pb, 10, vbv_buffer_size & 0x3FF);
326

    
327
            constraint_parameter_flag=
328
                s->width <= 768 && s->height <= 576 &&
329
                s->mb_width * s->mb_height <= 396 &&
330
                s->mb_width * s->mb_height * framerate.num <= framerate.den*396*25 &&
331
                framerate.num <= framerate.den*30 &&
332
                s->avctx->me_range && s->avctx->me_range < 128 &&
333
                vbv_buffer_size <= 20 &&
334
                v <= 1856000/400 &&
335
                s->codec_id == CODEC_ID_MPEG1VIDEO;
336

    
337
            put_bits(&s->pb, 1, constraint_parameter_flag);
338

    
339
            ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
340
            ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
341

    
342
            if(s->codec_id == CODEC_ID_MPEG2VIDEO){
343
                put_header(s, EXT_START_CODE);
344
                put_bits(&s->pb, 4, 1); //seq ext
345

    
346
                put_bits(&s->pb, 1, s->avctx->profile == 0); //escx 1 for 4:2:2 profile */
347

    
348
                put_bits(&s->pb, 3, s->avctx->profile); //profile
349
                put_bits(&s->pb, 4, s->avctx->level); //level
350

    
351
                put_bits(&s->pb, 1, s->progressive_sequence);
352
                put_bits(&s->pb, 2, s->chroma_format);
353
                put_bits(&s->pb, 2, 0); //horizontal size ext
354
                put_bits(&s->pb, 2, 0); //vertical size ext
355
                put_bits(&s->pb, 12, v>>18); //bitrate ext
356
                put_bits(&s->pb, 1, 1); //marker
357
                put_bits(&s->pb, 8, vbv_buffer_size >>10); //vbv buffer ext
358
                put_bits(&s->pb, 1, s->low_delay);
359
                put_bits(&s->pb, 2, 0); // frame_rate_ext_n
360
                put_bits(&s->pb, 5, 0); // frame_rate_ext_d
361
            }
362

    
363
            put_header(s, GOP_START_CODE);
364
            put_bits(&s->pb, 1, !!(s->avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE)); /* drop frame flag */
365
            /* time code : we must convert from the real frame rate to a
366
               fake mpeg frame rate in case of low frame rate */
367
            fps = (framerate.num + framerate.den/2)/ framerate.den;
368
            time_code = s->current_picture_ptr->coded_picture_number + s->avctx->timecode_frame_start;
369

    
370
            s->gop_picture_number = s->current_picture_ptr->coded_picture_number;
371
            if (s->avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE) {
372
                /* only works for NTSC 29.97 */
373
                int d = time_code / 17982;
374
                int m = time_code % 17982;
375
                //if (m < 2) m += 2; /* not needed since -2,-1 / 1798 in C returns 0 */
376
                time_code += 18 * d + 2 * ((m - 2) / 1798);
377
            }
378
            put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
379
            put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
380
            put_bits(&s->pb, 1, 1);
381
            put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
382
            put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
383
            put_bits(&s->pb, 1, !!(s->flags & CODEC_FLAG_CLOSED_GOP));
384
            put_bits(&s->pb, 1, 0); /* broken link */
385
        }
386
}
387

    
388
static inline void encode_mb_skip_run(MpegEncContext *s, int run){
389
    while (run >= 33) {
390
        put_bits(&s->pb, 11, 0x008);
391
        run -= 33;
392
    }
393
    put_bits(&s->pb, mbAddrIncrTable[run][1],
394
             mbAddrIncrTable[run][0]);
395
}
396
#endif //CONFIG_ENCODERS
397

    
398
static void common_init(MpegEncContext *s)
399
{
400

    
401
    s->y_dc_scale_table=
402
    s->c_dc_scale_table= mpeg2_dc_scale_table[s->intra_dc_precision];
403

    
404
}
405

    
406
void ff_mpeg1_clean_buffers(MpegEncContext *s){
407
    s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
408
    s->last_dc[1] = s->last_dc[0];
409
    s->last_dc[2] = s->last_dc[0];
410
    memset(s->last_mv, 0, sizeof(s->last_mv));
411
}
412

    
413
#ifdef CONFIG_ENCODERS
414

    
415
static av_always_inline void put_qscale(MpegEncContext *s)
416
{
417
    if(s->q_scale_type){
418
        assert(s->qscale>=1 && s->qscale <=12);
419
        put_bits(&s->pb, 5, inv_non_linear_qscale[s->qscale]);
420
    }else{
421
        put_bits(&s->pb, 5, s->qscale);
422
    }
423
}
424

    
425
void ff_mpeg1_encode_slice_header(MpegEncContext *s){
426
    put_header(s, SLICE_MIN_START_CODE + s->mb_y);
427
    put_qscale(s);
428
    put_bits(&s->pb, 1, 0); /* slice extra information */
429
}
430

    
431
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
432
{
433
    mpeg1_encode_sequence_header(s);
434

    
435
    /* mpeg1 picture header */
436
    put_header(s, PICTURE_START_CODE);
437
    /* temporal reference */
438

    
439
    // RAL: s->picture_number instead of s->fake_picture_number
440
    put_bits(&s->pb, 10, (s->picture_number -
441
                          s->gop_picture_number) & 0x3ff);
442
    put_bits(&s->pb, 3, s->pict_type);
443

    
444
    s->vbv_delay_ptr= s->pb.buf + put_bits_count(&s->pb)/8;
445
    put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
446

    
447
    // RAL: Forward f_code also needed for B frames
448
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
449
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
450
        if(s->codec_id == CODEC_ID_MPEG1VIDEO)
451
            put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
452
        else
453
            put_bits(&s->pb, 3, 7); /* forward_f_code */
454
    }
455

    
456
    // RAL: Backward f_code necessary for B frames
457
    if (s->pict_type == B_TYPE) {
458
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
459
        if(s->codec_id == CODEC_ID_MPEG1VIDEO)
460
            put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
461
        else
462
            put_bits(&s->pb, 3, 7); /* backward_f_code */
463
    }
464

    
465
    put_bits(&s->pb, 1, 0); /* extra bit picture */
466

    
467
    s->frame_pred_frame_dct = 1;
468
    if(s->codec_id == CODEC_ID_MPEG2VIDEO){
469
        put_header(s, EXT_START_CODE);
470
        put_bits(&s->pb, 4, 8); //pic ext
471
        if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
472
            put_bits(&s->pb, 4, s->f_code);
473
            put_bits(&s->pb, 4, s->f_code);
474
        }else{
475
            put_bits(&s->pb, 8, 255);
476
        }
477
        if (s->pict_type == B_TYPE) {
478
            put_bits(&s->pb, 4, s->b_code);
479
            put_bits(&s->pb, 4, s->b_code);
480
        }else{
481
            put_bits(&s->pb, 8, 255);
482
        }
483
        put_bits(&s->pb, 2, s->intra_dc_precision);
484

    
485
        assert(s->picture_structure == PICT_FRAME);
486
        put_bits(&s->pb, 2, s->picture_structure);
487
        if (s->progressive_sequence) {
488
            put_bits(&s->pb, 1, 0); /* no repeat */
489
        } else {
490
            put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
491
        }
492
        /* XXX: optimize the generation of this flag with entropy
493
           measures */
494
        s->frame_pred_frame_dct = s->progressive_sequence;
495

    
496
        put_bits(&s->pb, 1, s->frame_pred_frame_dct);
497
        put_bits(&s->pb, 1, s->concealment_motion_vectors);
498
        put_bits(&s->pb, 1, s->q_scale_type);
499
        put_bits(&s->pb, 1, s->intra_vlc_format);
500
        put_bits(&s->pb, 1, s->alternate_scan);
501
        put_bits(&s->pb, 1, s->repeat_first_field);
502
        s->progressive_frame = s->progressive_sequence;
503
        put_bits(&s->pb, 1, s->chroma_format == CHROMA_420 ? s->progressive_frame : 0); /* chroma_420_type */
504
        put_bits(&s->pb, 1, s->progressive_frame);
505
        put_bits(&s->pb, 1, 0); //composite_display_flag
506
    }
507
    if(s->flags & CODEC_FLAG_SVCD_SCAN_OFFSET){
508
        int i;
509

    
510
        put_header(s, USER_START_CODE);
511
        for(i=0; i<sizeof(svcd_scan_offset_placeholder); i++){
512
            put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
513
        }
514
    }
515

    
516
    s->mb_y=0;
517
    ff_mpeg1_encode_slice_header(s);
518
}
519

    
520
static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
521
                                int has_mv, int field_motion)
522
{
523
    put_bits(&s->pb, n, bits);
524
    if (!s->frame_pred_frame_dct) {
525
        if (has_mv)
526
            put_bits(&s->pb, 2, 2 - field_motion); /* motion_type: frame/field */
527
        put_bits(&s->pb, 1, s->interlaced_dct);
528
    }
529
}
530

    
531
static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s,
532
                                                   DCTELEM block[6][64],
533
                                                   int motion_x, int motion_y,
534
                                                   int mb_block_count)
535
{
536
    int i, cbp;
537
    const int mb_x = s->mb_x;
538
    const int mb_y = s->mb_y;
539
    const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
540

    
541
    /* compute cbp */
542
    cbp = 0;
543
    for(i=0;i<mb_block_count;i++) {
544
        if (s->block_last_index[i] >= 0)
545
            cbp |= 1 << (mb_block_count - 1 - i);
546
    }
547

    
548
    if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 &&
549
        (mb_x != s->mb_width - 1 || (mb_y != s->mb_height - 1 && s->codec_id == CODEC_ID_MPEG1VIDEO)) &&
550
        ((s->pict_type == P_TYPE && (motion_x | motion_y) == 0) ||
551
        (s->pict_type == B_TYPE && s->mv_dir == s->last_mv_dir && (((s->mv_dir & MV_DIR_FORWARD) ? ((s->mv[0][0][0] - s->last_mv[0][0][0])|(s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
552
        ((s->mv_dir & MV_DIR_BACKWARD) ? ((s->mv[1][0][0] - s->last_mv[1][0][0])|(s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
553
        s->mb_skip_run++;
554
        s->qscale -= s->dquant;
555
        s->skip_count++;
556
        s->misc_bits++;
557
        s->last_bits++;
558
        if(s->pict_type == P_TYPE){
559
            s->last_mv[0][1][0]= s->last_mv[0][0][0]=
560
            s->last_mv[0][1][1]= s->last_mv[0][0][1]= 0;
561
        }
562
    } else {
563
        if(first_mb){
564
            assert(s->mb_skip_run == 0);
565
            encode_mb_skip_run(s, s->mb_x);
566
        }else{
567
            encode_mb_skip_run(s, s->mb_skip_run);
568
        }
569

    
570
        if (s->pict_type == I_TYPE) {
571
            if(s->dquant && cbp){
572
                put_mb_modes(s, 2, 1, 0, 0); /* macroblock_type : macroblock_quant = 1 */
573
                put_qscale(s);
574
            }else{
575
                put_mb_modes(s, 1, 1, 0, 0); /* macroblock_type : macroblock_quant = 0 */
576
                s->qscale -= s->dquant;
577
            }
578
            s->misc_bits+= get_bits_diff(s);
579
            s->i_count++;
580
        } else if (s->mb_intra) {
581
            if(s->dquant && cbp){
582
                put_mb_modes(s, 6, 0x01, 0, 0);
583
                put_qscale(s);
584
            }else{
585
                put_mb_modes(s, 5, 0x03, 0, 0);
586
                s->qscale -= s->dquant;
587
            }
588
            s->misc_bits+= get_bits_diff(s);
589
            s->i_count++;
590
            memset(s->last_mv, 0, sizeof(s->last_mv));
591
        } else if (s->pict_type == P_TYPE) {
592
            if(s->mv_type == MV_TYPE_16X16){
593
                if (cbp != 0) {
594
                    if ((motion_x|motion_y) == 0) {
595
                        if(s->dquant){
596
                            put_mb_modes(s, 5, 1, 0, 0); /* macroblock_pattern & quant */
597
                            put_qscale(s);
598
                        }else{
599
                            put_mb_modes(s, 2, 1, 0, 0); /* macroblock_pattern only */
600
                        }
601
                        s->misc_bits+= get_bits_diff(s);
602
                    } else {
603
                        if(s->dquant){
604
                            put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */
605
                            put_qscale(s);
606
                        }else{
607
                            put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */
608
                        }
609
                        s->misc_bits+= get_bits_diff(s);
610
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
611
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
612
                        s->mv_bits+= get_bits_diff(s);
613
                    }
614
                } else {
615
                    put_bits(&s->pb, 3, 1); /* motion only */
616
                    if (!s->frame_pred_frame_dct)
617
                        put_bits(&s->pb, 2, 2); /* motion_type: frame */
618
                    s->misc_bits+= get_bits_diff(s);
619
                    mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
620
                    mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
621
                    s->qscale -= s->dquant;
622
                    s->mv_bits+= get_bits_diff(s);
623
                }
624
                s->last_mv[0][1][0]= s->last_mv[0][0][0]= motion_x;
625
                s->last_mv[0][1][1]= s->last_mv[0][0][1]= motion_y;
626
            }else{
627
                assert(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD);
628

    
629
                if (cbp) {
630
                    if(s->dquant){
631
                        put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
632
                        put_qscale(s);
633
                    }else{
634
                        put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
635
                    }
636
                } else {
637
                    put_bits(&s->pb, 3, 1); /* motion only */
638
                    put_bits(&s->pb, 2, 1); /* motion_type: field */
639
                    s->qscale -= s->dquant;
640
                }
641
                s->misc_bits+= get_bits_diff(s);
642
                for(i=0; i<2; i++){
643
                    put_bits(&s->pb, 1, s->field_select[0][i]);
644
                    mpeg1_encode_motion(s, s->mv[0][i][0] -  s->last_mv[0][i][0]    , s->f_code);
645
                    mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code);
646
                    s->last_mv[0][i][0]=   s->mv[0][i][0];
647
                    s->last_mv[0][i][1]= 2*s->mv[0][i][1];
648
                }
649
                s->mv_bits+= get_bits_diff(s);
650
            }
651
            if(cbp) {
652
                if (s->chroma_y_shift) {
653
                    put_bits(&s->pb, mbPatTable[cbp][1], mbPatTable[cbp][0]);
654
                } else {
655
                    put_bits(&s->pb, mbPatTable[cbp>>2][1], mbPatTable[cbp>>2][0]);
656
                    put_bits(&s->pb, 2, cbp & 3);
657
                }
658
            }
659
            s->f_count++;
660
        } else{
661
            static const int mb_type_len[4]={0,3,4,2}; //bak,for,bi
662

    
663
            if(s->mv_type == MV_TYPE_16X16){
664
                if (cbp){    // With coded bloc pattern
665
                    if (s->dquant) {
666
                        if(s->mv_dir == MV_DIR_FORWARD)
667
                            put_mb_modes(s, 6, 3, 1, 0);
668
                        else
669
                            put_mb_modes(s, mb_type_len[s->mv_dir]+3, 2, 1, 0);
670
                        put_qscale(s);
671
                    } else {
672
                        put_mb_modes(s, mb_type_len[s->mv_dir], 3, 1, 0);
673
                    }
674
                }else{    // No coded bloc pattern
675
                    put_bits(&s->pb, mb_type_len[s->mv_dir], 2);
676
                    if (!s->frame_pred_frame_dct)
677
                        put_bits(&s->pb, 2, 2); /* motion_type: frame */
678
                    s->qscale -= s->dquant;
679
                }
680
                s->misc_bits += get_bits_diff(s);
681
                if (s->mv_dir&MV_DIR_FORWARD){
682
                    mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
683
                    mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
684
                    s->last_mv[0][0][0]=s->last_mv[0][1][0]= s->mv[0][0][0];
685
                    s->last_mv[0][0][1]=s->last_mv[0][1][1]= s->mv[0][0][1];
686
                    s->f_count++;
687
                }
688
                if (s->mv_dir&MV_DIR_BACKWARD){
689
                    mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
690
                    mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
691
                    s->last_mv[1][0][0]=s->last_mv[1][1][0]= s->mv[1][0][0];
692
                    s->last_mv[1][0][1]=s->last_mv[1][1][1]= s->mv[1][0][1];
693
                    s->b_count++;
694
                }
695
            }else{
696
                assert(s->mv_type == MV_TYPE_FIELD);
697
                assert(!s->frame_pred_frame_dct);
698
                if (cbp){    // With coded bloc pattern
699
                    if (s->dquant) {
700
                        if(s->mv_dir == MV_DIR_FORWARD)
701
                            put_mb_modes(s, 6, 3, 1, 1);
702
                        else
703
                            put_mb_modes(s, mb_type_len[s->mv_dir]+3, 2, 1, 1);
704
                        put_qscale(s);
705
                    } else {
706
                        put_mb_modes(s, mb_type_len[s->mv_dir], 3, 1, 1);
707
                    }
708
                }else{    // No coded bloc pattern
709
                    put_bits(&s->pb, mb_type_len[s->mv_dir], 2);
710
                    put_bits(&s->pb, 2, 1); /* motion_type: field */
711
                    s->qscale -= s->dquant;
712
                }
713
                s->misc_bits += get_bits_diff(s);
714
                if (s->mv_dir&MV_DIR_FORWARD){
715
                    for(i=0; i<2; i++){
716
                        put_bits(&s->pb, 1, s->field_select[0][i]);
717
                        mpeg1_encode_motion(s, s->mv[0][i][0] -  s->last_mv[0][i][0]    , s->f_code);
718
                        mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code);
719
                        s->last_mv[0][i][0]=   s->mv[0][i][0];
720
                        s->last_mv[0][i][1]= 2*s->mv[0][i][1];
721
                    }
722
                    s->f_count++;
723
                }
724
                if (s->mv_dir&MV_DIR_BACKWARD){
725
                    for(i=0; i<2; i++){
726
                        put_bits(&s->pb, 1, s->field_select[1][i]);
727
                        mpeg1_encode_motion(s, s->mv[1][i][0] -  s->last_mv[1][i][0]    , s->b_code);
728
                        mpeg1_encode_motion(s, s->mv[1][i][1] - (s->last_mv[1][i][1]>>1), s->b_code);
729
                        s->last_mv[1][i][0]=   s->mv[1][i][0];
730
                        s->last_mv[1][i][1]= 2*s->mv[1][i][1];
731
                    }
732
                    s->b_count++;
733
                }
734
            }
735
            s->mv_bits += get_bits_diff(s);
736
            if(cbp) {
737
                if (s->chroma_y_shift) {
738
                    put_bits(&s->pb, mbPatTable[cbp][1], mbPatTable[cbp][0]);
739
                } else {
740
                    put_bits(&s->pb, mbPatTable[cbp>>2][1], mbPatTable[cbp>>2][0]);
741
                    put_bits(&s->pb, 2, cbp & 3);
742
                }
743
            }
744
        }
745
        for(i=0;i<mb_block_count;i++) {
746
            if (cbp & (1 << (mb_block_count - 1 - i))) {
747
                mpeg1_encode_block(s, block[i], i);
748
            }
749
        }
750
        s->mb_skip_run = 0;
751
        if(s->mb_intra)
752
            s->i_tex_bits+= get_bits_diff(s);
753
        else
754
            s->p_tex_bits+= get_bits_diff(s);
755
    }
756
}
757

    
758
void mpeg1_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
759
{
760
    if (s->chroma_format == CHROMA_420) mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6);
761
    else                                mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8);
762
}
763

    
764
// RAL: Parameter added: f_or_b_code
765
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
766
{
767
    int code, bit_size, l, bits, range, sign;
768

    
769
    if (val == 0) {
770
        /* zero vector */
771
        code = 0;
772
        put_bits(&s->pb,
773
                 mbMotionVectorTable[0][1],
774
                 mbMotionVectorTable[0][0]);
775
    } else {
776
        bit_size = f_or_b_code - 1;
777
        range = 1 << bit_size;
778
        /* modulo encoding */
779
        l= INT_BIT - 5 - bit_size;
780
        val= (val<<l)>>l;
781

    
782
        if (val >= 0) {
783
            val--;
784
            code = (val >> bit_size) + 1;
785
            bits = val & (range - 1);
786
            sign = 0;
787
        } else {
788
            val = -val;
789
            val--;
790
            code = (val >> bit_size) + 1;
791
            bits = val & (range - 1);
792
            sign = 1;
793
        }
794

    
795
        assert(code > 0 && code <= 16);
796

    
797
        put_bits(&s->pb,
798
                 mbMotionVectorTable[code][1],
799
                 mbMotionVectorTable[code][0]);
800

    
801
        put_bits(&s->pb, 1, sign);
802
        if (bit_size > 0) {
803
            put_bits(&s->pb, bit_size, bits);
804
        }
805
    }
806
}
807

    
808
void ff_mpeg1_encode_init(MpegEncContext *s)
809
{
810
    static int done=0;
811

    
812
    common_init(s);
813

    
814
    if(!done){
815
        int f_code;
816
        int mv;
817
        int i;
818

    
819
        done=1;
820
        init_rl(&rl_mpeg1, static_rl_table_store[0]);
821
        init_rl(&rl_mpeg2, static_rl_table_store[1]);
822

    
823
        for(i=0; i<64; i++)
824
        {
825
                mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
826
                mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
827
        }
828

    
829
        init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_len);
830
        if(s->intra_vlc_format)
831
            init_uni_ac_vlc(&rl_mpeg2, uni_mpeg2_ac_vlc_len);
832

    
833
        /* build unified dc encoding tables */
834
        for(i=-255; i<256; i++)
835
        {
836
                int adiff, index;
837
                int bits, code;
838
                int diff=i;
839

    
840
                adiff = FFABS(diff);
841
                if(diff<0) diff--;
842
                index = av_log2(2*adiff);
843

    
844
                bits= vlc_dc_lum_bits[index] + index;
845
                code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
846
                mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
847

    
848
                bits= vlc_dc_chroma_bits[index] + index;
849
                code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
850
                mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
851
        }
852

    
853
        for(f_code=1; f_code<=MAX_FCODE; f_code++){
854
            for(mv=-MAX_MV; mv<=MAX_MV; mv++){
855
                int len;
856

    
857
                if(mv==0) len= mbMotionVectorTable[0][1];
858
                else{
859
                    int val, bit_size, range, code;
860

    
861
                    bit_size = f_code - 1;
862
                    range = 1 << bit_size;
863

    
864
                    val=mv;
865
                    if (val < 0)
866
                        val = -val;
867
                    val--;
868
                    code = (val >> bit_size) + 1;
869
                    if(code<17){
870
                        len= mbMotionVectorTable[code][1] + 1 + bit_size;
871
                    }else{
872
                        len= mbMotionVectorTable[16][1] + 2 + bit_size;
873
                    }
874
                }
875

    
876
                mv_penalty[f_code][mv+MAX_MV]= len;
877
            }
878
        }
879

    
880

    
881
        for(f_code=MAX_FCODE; f_code>0; f_code--){
882
            for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
883
                fcode_tab[mv+MAX_MV]= f_code;
884
            }
885
        }
886
    }
887
    s->me.mv_penalty= mv_penalty;
888
    s->fcode_tab= fcode_tab;
889
    if(s->codec_id == CODEC_ID_MPEG1VIDEO){
890
        s->min_qcoeff=-255;
891
        s->max_qcoeff= 255;
892
    }else{
893
        s->min_qcoeff=-2047;
894
        s->max_qcoeff= 2047;
895
    }
896
    if (s->intra_vlc_format) {
897
        s->intra_ac_vlc_length=
898
        s->intra_ac_vlc_last_length= uni_mpeg2_ac_vlc_len;
899
    } else {
900
        s->intra_ac_vlc_length=
901
        s->intra_ac_vlc_last_length= uni_mpeg1_ac_vlc_len;
902
    }
903
    s->inter_ac_vlc_length=
904
    s->inter_ac_vlc_last_length= uni_mpeg1_ac_vlc_len;
905
}
906

    
907
static inline void encode_dc(MpegEncContext *s, int diff, int component)
908
{
909
  if(((unsigned) (diff+255)) >= 511){
910
        int index;
911

    
912
        if(diff<0){
913
            index= av_log2_16bit(-2*diff);
914
            diff--;
915
        }else{
916
            index= av_log2_16bit(2*diff);
917
        }
918
        if (component == 0) {
919
            put_bits(
920
                &s->pb,
921
                vlc_dc_lum_bits[index] + index,
922
                (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1)));
923
        }else{
924
            put_bits(
925
                &s->pb,
926
                vlc_dc_chroma_bits[index] + index,
927
                (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1)));
928
        }
929
  }else{
930
    if (component == 0) {
931
        put_bits(
932
            &s->pb,
933
            mpeg1_lum_dc_uni[diff+255]&0xFF,
934
            mpeg1_lum_dc_uni[diff+255]>>8);
935
    } else {
936
        put_bits(
937
            &s->pb,
938
            mpeg1_chr_dc_uni[diff+255]&0xFF,
939
            mpeg1_chr_dc_uni[diff+255]>>8);
940
    }
941
  }
942
}
943

    
944
static void mpeg1_encode_block(MpegEncContext *s,
945
                               DCTELEM *block,
946
                               int n)
947
{
948
    int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
949
    int code, component;
950
    const uint16_t (*table_vlc)[2] = rl_mpeg1.table_vlc;
951

    
952
    last_index = s->block_last_index[n];
953

    
954
    /* DC coef */
955
    if (s->mb_intra) {
956
        component = (n <= 3 ? 0 : (n&1) + 1);
957
        dc = block[0]; /* overflow is impossible */
958
        diff = dc - s->last_dc[component];
959
        encode_dc(s, diff, component);
960
        s->last_dc[component] = dc;
961
        i = 1;
962
        if (s->intra_vlc_format)
963
            table_vlc = rl_mpeg2.table_vlc;
964
    } else {
965
        /* encode the first coefficient : needs to be done here because
966
           it is handled slightly differently */
967
        level = block[0];
968
        if (abs(level) == 1) {
969
                code = ((uint32_t)level >> 31); /* the sign bit */
970
                put_bits(&s->pb, 2, code | 0x02);
971
                i = 1;
972
        } else {
973
            i = 0;
974
            last_non_zero = -1;
975
            goto next_coef;
976
        }
977
    }
978

    
979
    /* now quantify & encode AC coefs */
980
    last_non_zero = i - 1;
981

    
982
    for(;i<=last_index;i++) {
983
        j = s->intra_scantable.permutated[i];
984
        level = block[j];
985
    next_coef:
986
#if 0
987
        if (level != 0)
988
            dprintf(s->avctx, "level[%d]=%d\n", i, level);
989
#endif
990
        /* encode using VLC */
991
        if (level != 0) {
992
            run = i - last_non_zero - 1;
993

    
994
            alevel= level;
995
            MASK_ABS(sign, alevel)
996
            sign&=1;
997

    
998
            if (alevel <= mpeg1_max_level[0][run]){
999
                code= mpeg1_index_run[0][run] + alevel - 1;
1000
                /* store the vlc & sign at once */
1001
                put_bits(&s->pb, table_vlc[code][1]+1, (table_vlc[code][0]<<1) + sign);
1002
            } else {
1003
                /* escape seems to be pretty rare <5% so I do not optimize it */
1004
                put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]);
1005
                /* escape: only clip in this case */
1006
                put_bits(&s->pb, 6, run);
1007
                if(s->codec_id == CODEC_ID_MPEG1VIDEO){
1008
                    if (alevel < 128) {
1009
                        put_bits(&s->pb, 8, level & 0xff);
1010
                    } else {
1011
                        if (level < 0) {
1012
                            put_bits(&s->pb, 16, 0x8001 + level + 255);
1013
                        } else {
1014
                            put_bits(&s->pb, 16, level & 0xffff);
1015
                        }
1016
                    }
1017
                }else{
1018
                    put_bits(&s->pb, 12, level & 0xfff);
1019
                }
1020
            }
1021
            last_non_zero = i;
1022
        }
1023
    }
1024
    /* end of block */
1025
    put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
1026
}
1027
#endif //CONFIG_ENCODERS
1028

    
1029
/******************************************/
1030
/* decoding */
1031

    
1032
static VLC dc_lum_vlc;
1033
static VLC dc_chroma_vlc;
1034
static VLC mv_vlc;
1035
static VLC mbincr_vlc;
1036
static VLC mb_ptype_vlc;
1037
static VLC mb_btype_vlc;
1038
static VLC mb_pat_vlc;
1039

    
1040
static void init_vlcs(void)
1041
{
1042
    static int done = 0;
1043

    
1044
    if (!done) {
1045
        done = 1;
1046

    
1047
        init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12,
1048
                 vlc_dc_lum_bits, 1, 1,
1049
                 vlc_dc_lum_code, 2, 2, 1);
1050
        init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12,
1051
                 vlc_dc_chroma_bits, 1, 1,
1052
                 vlc_dc_chroma_code, 2, 2, 1);
1053
        init_vlc(&mv_vlc, MV_VLC_BITS, 17,
1054
                 &mbMotionVectorTable[0][1], 2, 1,
1055
                 &mbMotionVectorTable[0][0], 2, 1, 1);
1056
        init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36,
1057
                 &mbAddrIncrTable[0][1], 2, 1,
1058
                 &mbAddrIncrTable[0][0], 2, 1, 1);
1059
        init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 64,
1060
                 &mbPatTable[0][1], 2, 1,
1061
                 &mbPatTable[0][0], 2, 1, 1);
1062

    
1063
        init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7,
1064
                 &table_mb_ptype[0][1], 2, 1,
1065
                 &table_mb_ptype[0][0], 2, 1, 1);
1066
        init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11,
1067
                 &table_mb_btype[0][1], 2, 1,
1068
                 &table_mb_btype[0][0], 2, 1, 1);
1069
        init_rl(&rl_mpeg1, static_rl_table_store[0]);
1070
        init_rl(&rl_mpeg2, static_rl_table_store[1]);
1071

    
1072
        init_2d_vlc_rl(&rl_mpeg1, 1);
1073
        init_2d_vlc_rl(&rl_mpeg2, 1);
1074
    }
1075
}
1076

    
1077
static inline int get_dmv(MpegEncContext *s)
1078
{
1079
    if(get_bits1(&s->gb))
1080
        return 1 - (get_bits1(&s->gb) << 1);
1081
    else
1082
        return 0;
1083
}
1084

    
1085
static inline int get_qscale(MpegEncContext *s)
1086
{
1087
    int qscale = get_bits(&s->gb, 5);
1088
    if (s->q_scale_type) {
1089
        return non_linear_qscale[qscale];
1090
    } else {
1091
        return qscale << 1;
1092
    }
1093
}
1094

    
1095
/* motion type (for mpeg2) */
1096
#define MT_FIELD 1
1097
#define MT_FRAME 2
1098
#define MT_16X8  2
1099
#define MT_DMV   3
1100

    
1101
static int mpeg_decode_mb(MpegEncContext *s,
1102
                          DCTELEM block[12][64])
1103
{
1104
    int i, j, k, cbp, val, mb_type, motion_type;
1105
    const int mb_block_count = 4 + (1<< s->chroma_format);
1106

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

    
1109
    assert(s->mb_skipped==0);
1110

    
1111
    if (s->mb_skip_run-- != 0) {
1112
        if(s->pict_type == I_TYPE){
1113
            av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1114
            return -1;
1115
        }
1116

    
1117
        /* skip mb */
1118
        s->mb_intra = 0;
1119
        for(i=0;i<12;i++)
1120
            s->block_last_index[i] = -1;
1121
        if(s->picture_structure == PICT_FRAME)
1122
            s->mv_type = MV_TYPE_16X16;
1123
        else
1124
            s->mv_type = MV_TYPE_FIELD;
1125
        if (s->pict_type == P_TYPE) {
1126
            /* if P type, zero motion vector is implied */
1127
            s->mv_dir = MV_DIR_FORWARD;
1128
            s->mv[0][0][0] = s->mv[0][0][1] = 0;
1129
            s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1130
            s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1131
            s->field_select[0][0]= s->picture_structure - 1;
1132
            s->mb_skipped = 1;
1133
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1134
        } else {
1135
            int mb_type;
1136

    
1137
            if(s->mb_x)
1138
                mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1];
1139
            else
1140
                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,
1141
            if(IS_INTRA(mb_type))
1142
                return -1;
1143

    
1144
            /* if B type, reuse previous vectors and directions */
1145
            s->mv[0][0][0] = s->last_mv[0][0][0];
1146
            s->mv[0][0][1] = s->last_mv[0][0][1];
1147
            s->mv[1][0][0] = s->last_mv[1][0][0];
1148
            s->mv[1][0][1] = s->last_mv[1][0][1];
1149

    
1150
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]=
1151
                mb_type | MB_TYPE_SKIP;
1152
//            assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
1153

    
1154
            if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0)
1155
                s->mb_skipped = 1;
1156
        }
1157

    
1158
        return 0;
1159
    }
1160

    
1161
    switch(s->pict_type) {
1162
    default:
1163
    case I_TYPE:
1164
        if (get_bits1(&s->gb) == 0) {
1165
            if (get_bits1(&s->gb) == 0){
1166
                av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
1167
                return -1;
1168
            }
1169
            mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
1170
        } else {
1171
            mb_type = MB_TYPE_INTRA;
1172
        }
1173
        break;
1174
    case P_TYPE:
1175
        mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
1176
        if (mb_type < 0){
1177
            av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
1178
            return -1;
1179
        }
1180
        mb_type = ptype2mb_type[ mb_type ];
1181
        break;
1182
    case B_TYPE:
1183
        mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
1184
        if (mb_type < 0){
1185
            av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
1186
            return -1;
1187
        }
1188
        mb_type = btype2mb_type[ mb_type ];
1189
        break;
1190
    }
1191
    dprintf(s->avctx, "mb_type=%x\n", mb_type);
1192
//    motion_type = 0; /* avoid warning */
1193
    if (IS_INTRA(mb_type)) {
1194
        s->dsp.clear_blocks(s->block[0]);
1195

    
1196
        if(!s->chroma_y_shift){
1197
            s->dsp.clear_blocks(s->block[6]);
1198
        }
1199

    
1200
        /* compute dct type */
1201
        if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1202
            !s->frame_pred_frame_dct) {
1203
            s->interlaced_dct = get_bits1(&s->gb);
1204
        }
1205

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

    
1209
        if (s->concealment_motion_vectors) {
1210
            /* just parse them */
1211
            if (s->picture_structure != PICT_FRAME)
1212
                skip_bits1(&s->gb); /* field select */
1213

    
1214
            s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
1215
                mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
1216
            s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
1217
                mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
1218

    
1219
            skip_bits1(&s->gb); /* marker */
1220
        }else
1221
            memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
1222
        s->mb_intra = 1;
1223
#ifdef HAVE_XVMC
1224
        //one 1 we memcpy blocks in xvmcvideo
1225
        if(s->avctx->xvmc_acceleration > 1){
1226
            XVMC_pack_pblocks(s,-1);//inter are always full blocks
1227
            if(s->swap_uv){
1228
                exchange_uv(s);
1229
            }
1230
        }
1231
#endif
1232

    
1233
        if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1234
            if(s->flags2 & CODEC_FLAG2_FAST){
1235
                for(i=0;i<6;i++) {
1236
                    mpeg2_fast_decode_block_intra(s, s->pblocks[i], i);
1237
                }
1238
            }else{
1239
                for(i=0;i<mb_block_count;i++) {
1240
                    if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0)
1241
                        return -1;
1242
                }
1243
            }
1244
        } else {
1245
            for(i=0;i<6;i++) {
1246
                if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 0)
1247
                    return -1;
1248
            }
1249
        }
1250
    } else {
1251
        if (mb_type & MB_TYPE_ZERO_MV){
1252
            assert(mb_type & MB_TYPE_CBP);
1253

    
1254
            /* compute dct type */
1255
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1256
                !s->frame_pred_frame_dct) {
1257
                s->interlaced_dct = get_bits1(&s->gb);
1258
            }
1259

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

    
1263
            s->mv_dir = MV_DIR_FORWARD;
1264
            if(s->picture_structure == PICT_FRAME)
1265
                s->mv_type = MV_TYPE_16X16;
1266
            else{
1267
                s->mv_type = MV_TYPE_FIELD;
1268
                mb_type |= MB_TYPE_INTERLACED;
1269
                s->field_select[0][0]= s->picture_structure - 1;
1270
            }
1271
            s->last_mv[0][0][0] = 0;
1272
            s->last_mv[0][0][1] = 0;
1273
            s->last_mv[0][1][0] = 0;
1274
            s->last_mv[0][1][1] = 0;
1275
            s->mv[0][0][0] = 0;
1276
            s->mv[0][0][1] = 0;
1277
        }else{
1278
            assert(mb_type & MB_TYPE_L0L1);
1279
//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
1280
            /* get additional motion vector type */
1281
            if (s->frame_pred_frame_dct)
1282
                motion_type = MT_FRAME;
1283
            else{
1284
                motion_type = get_bits(&s->gb, 2);
1285
            }
1286

    
1287
            /* compute dct type */
1288
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1289
                !s->frame_pred_frame_dct && HAS_CBP(mb_type)) {
1290
                s->interlaced_dct = get_bits1(&s->gb);
1291
            }
1292

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

    
1296
            /* motion vectors */
1297
            s->mv_dir = 0;
1298
            for(i=0;i<2;i++) {
1299
                if (USES_LIST(mb_type, i)) {
1300
                    s->mv_dir |= (MV_DIR_FORWARD >> i);
1301
                    dprintf(s->avctx, "motion_type=%d\n", motion_type);
1302
                    switch(motion_type) {
1303
                    case MT_FRAME: /* or MT_16X8 */
1304
                        if (s->picture_structure == PICT_FRAME) {
1305
                            /* MT_FRAME */
1306
                            mb_type |= MB_TYPE_16x16;
1307
                            s->mv_type = MV_TYPE_16X16;
1308
                            s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] =
1309
                                mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
1310
                            s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] =
1311
                                mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
1312
                            /* full_pel: only for mpeg1 */
1313
                            if (s->full_pel[i]){
1314
                                s->mv[i][0][0] <<= 1;
1315
                                s->mv[i][0][1] <<= 1;
1316
                            }
1317
                        } else {
1318
                            /* MT_16X8 */
1319
                            mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
1320
                            s->mv_type = MV_TYPE_16X8;
1321
                            for(j=0;j<2;j++) {
1322
                                s->field_select[i][j] = get_bits1(&s->gb);
1323
                                for(k=0;k<2;k++) {
1324
                                    val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1325
                                                             s->last_mv[i][j][k]);
1326
                                    s->last_mv[i][j][k] = val;
1327
                                    s->mv[i][j][k] = val;
1328
                                }
1329
                            }
1330
                        }
1331
                        break;
1332
                    case MT_FIELD:
1333
                        s->mv_type = MV_TYPE_FIELD;
1334
                        if (s->picture_structure == PICT_FRAME) {
1335
                            mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
1336
                            for(j=0;j<2;j++) {
1337
                                s->field_select[i][j] = get_bits1(&s->gb);
1338
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1339
                                                         s->last_mv[i][j][0]);
1340
                                s->last_mv[i][j][0] = val;
1341
                                s->mv[i][j][0] = val;
1342
                                dprintf(s->avctx, "fmx=%d\n", val);
1343
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1344
                                                         s->last_mv[i][j][1] >> 1);
1345
                                s->last_mv[i][j][1] = val << 1;
1346
                                s->mv[i][j][1] = val;
1347
                                dprintf(s->avctx, "fmy=%d\n", val);
1348
                            }
1349
                        } else {
1350
                            mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
1351
                            s->field_select[i][0] = get_bits1(&s->gb);
1352
                            for(k=0;k<2;k++) {
1353
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1354
                                                         s->last_mv[i][0][k]);
1355
                                s->last_mv[i][0][k] = val;
1356
                                s->last_mv[i][1][k] = val;
1357
                                s->mv[i][0][k] = val;
1358
                            }
1359
                        }
1360
                        break;
1361
                    case MT_DMV:
1362
                        {
1363
                            int dmx, dmy, mx, my, m;
1364

    
1365
                            mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1366
                                                    s->last_mv[i][0][0]);
1367
                            s->last_mv[i][0][0] = mx;
1368
                            s->last_mv[i][1][0] = mx;
1369
                            dmx = get_dmv(s);
1370
                            my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1371
                                                    s->last_mv[i][0][1] >> 1);
1372
                            dmy = get_dmv(s);
1373
                            s->mv_type = MV_TYPE_DMV;
1374

    
1375

    
1376
                            s->last_mv[i][0][1] = my<<1;
1377
                            s->last_mv[i][1][1] = my<<1;
1378

    
1379
                            s->mv[i][0][0] = mx;
1380
                            s->mv[i][0][1] = my;
1381
                            s->mv[i][1][0] = mx;//not used
1382
                            s->mv[i][1][1] = my;//not used
1383

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

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

    
1390
                                /* top -> top pred */
1391
                                s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1392
                                s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1393
                                m = 4 - m;
1394
                                s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1395
                                s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1396
                            } else {
1397
                                mb_type |= MB_TYPE_16x16;
1398

    
1399
                                s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
1400
                                s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
1401
                                if(s->picture_structure == PICT_TOP_FIELD)
1402
                                    s->mv[i][2][1]--;
1403
                                else
1404
                                    s->mv[i][2][1]++;
1405
                            }
1406
                        }
1407
                        break;
1408
                    default:
1409
                        av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
1410
                        return -1;
1411
                    }
1412
                }
1413
            }
1414
        }
1415

    
1416
        s->mb_intra = 0;
1417
        if (HAS_CBP(mb_type)) {
1418
            s->dsp.clear_blocks(s->block[0]);
1419

    
1420
            if(!s->chroma_y_shift){
1421
                s->dsp.clear_blocks(s->block[6]);
1422
            }
1423

    
1424
            cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1425
            if (cbp < 0 || ((cbp == 0) && (s->chroma_format < 2)) ){
1426
                av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
1427
                return -1;
1428
            }
1429
            if(mb_block_count > 6){
1430
                 cbp<<= mb_block_count-6;
1431
                 cbp |= get_bits(&s->gb, mb_block_count-6);
1432
            }
1433

    
1434
#ifdef HAVE_XVMC
1435
            //on 1 we memcpy blocks in xvmcvideo
1436
            if(s->avctx->xvmc_acceleration > 1){
1437
                XVMC_pack_pblocks(s,cbp);
1438
                if(s->swap_uv){
1439
                    exchange_uv(s);
1440
                }
1441
            }
1442
#endif
1443

    
1444
            if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1445
                if(s->flags2 & CODEC_FLAG2_FAST){
1446
                    for(i=0;i<6;i++) {
1447
                        if(cbp & 32) {
1448
                            mpeg2_fast_decode_block_non_intra(s, s->pblocks[i], i);
1449
                        } else {
1450
                            s->block_last_index[i] = -1;
1451
                        }
1452
                        cbp+=cbp;
1453
                    }
1454
                }else{
1455
                    cbp<<= 12-mb_block_count;
1456

    
1457
                    for(i=0;i<mb_block_count;i++) {
1458
                        if ( cbp & (1<<11) ) {
1459
                            if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
1460
                                return -1;
1461
                        } else {
1462
                            s->block_last_index[i] = -1;
1463
                        }
1464
                        cbp+=cbp;
1465
                    }
1466
                }
1467
            } else {
1468
                if(s->flags2 & CODEC_FLAG2_FAST){
1469
                    for(i=0;i<6;i++) {
1470
                        if (cbp & 32) {
1471
                            mpeg1_fast_decode_block_inter(s, s->pblocks[i], i);
1472
                        } else {
1473
                            s->block_last_index[i] = -1;
1474
                        }
1475
                        cbp+=cbp;
1476
                    }
1477
                }else{
1478
                    for(i=0;i<6;i++) {
1479
                        if (cbp & 32) {
1480
                            if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 0)
1481
                                return -1;
1482
                        } else {
1483
                            s->block_last_index[i] = -1;
1484
                        }
1485
                        cbp+=cbp;
1486
                    }
1487
                }
1488
            }
1489
        }else{
1490
            for(i=0;i<12;i++)
1491
                s->block_last_index[i] = -1;
1492
        }
1493
    }
1494

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

    
1497
    return 0;
1498
}
1499

    
1500
/* as h263, but only 17 codes */
1501
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
1502
{
1503
    int code, sign, val, l, shift;
1504

    
1505
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
1506
    if (code == 0) {
1507
        return pred;
1508
    }
1509
    if (code < 0) {
1510
        return 0xffff;
1511
    }
1512

    
1513
    sign = get_bits1(&s->gb);
1514
    shift = fcode - 1;
1515
    val = code;
1516
    if (shift) {
1517
        val = (val - 1) << shift;
1518
        val |= get_bits(&s->gb, shift);
1519
        val++;
1520
    }
1521
    if (sign)
1522
        val = -val;
1523
    val += pred;
1524

    
1525
    /* modulo decoding */
1526
    l= INT_BIT - 5 - shift;
1527
    val = (val<<l)>>l;
1528
    return val;
1529
}
1530

    
1531
static inline int decode_dc(GetBitContext *gb, int component)
1532
{
1533
    int code, diff;
1534

    
1535
    if (component == 0) {
1536
        code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1537
    } else {
1538
        code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1539
    }
1540
    if (code < 0){
1541
        av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
1542
        return 0xffff;
1543
    }
1544
    if (code == 0) {
1545
        diff = 0;
1546
    } else {
1547
        diff = get_xbits(gb, code);
1548
    }
1549
    return diff;
1550
}
1551

    
1552
static inline int mpeg1_decode_block_intra(MpegEncContext *s,
1553
                               DCTELEM *block,
1554
                               int n)
1555
{
1556
    int level, dc, diff, i, j, run;
1557
    int component;
1558
    RLTable *rl = &rl_mpeg1;
1559
    uint8_t * const scantable= s->intra_scantable.permutated;
1560
    const uint16_t *quant_matrix= s->intra_matrix;
1561
    const int qscale= s->qscale;
1562

    
1563
    /* DC coef */
1564
    component = (n <= 3 ? 0 : n - 4 + 1);
1565
    diff = decode_dc(&s->gb, component);
1566
    if (diff >= 0xffff)
1567
        return -1;
1568
    dc = s->last_dc[component];
1569
    dc += diff;
1570
    s->last_dc[component] = dc;
1571
    block[0] = dc<<3;
1572
    dprintf(s->avctx, "dc=%d diff=%d\n", dc, diff);
1573
    i = 0;
1574
    {
1575
        OPEN_READER(re, &s->gb);
1576
        /* now quantify & encode AC coefs */
1577
        for(;;) {
1578
            UPDATE_CACHE(re, &s->gb);
1579
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1580

    
1581
            if(level == 127){
1582
                break;
1583
            } else if(level != 0) {
1584
                i += run;
1585
                j = scantable[i];
1586
                level= (level*qscale*quant_matrix[j])>>4;
1587
                level= (level-1)|1;
1588
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1589
                LAST_SKIP_BITS(re, &s->gb, 1);
1590
            } else {
1591
                /* escape */
1592
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1593
                UPDATE_CACHE(re, &s->gb);
1594
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1595
                if (level == -128) {
1596
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1597
                } else if (level == 0) {
1598
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1599
                }
1600
                i += run;
1601
                j = scantable[i];
1602
                if(level<0){
1603
                    level= -level;
1604
                    level= (level*qscale*quant_matrix[j])>>4;
1605
                    level= (level-1)|1;
1606
                    level= -level;
1607
                }else{
1608
                    level= (level*qscale*quant_matrix[j])>>4;
1609
                    level= (level-1)|1;
1610
                }
1611
            }
1612
            if (i > 63){
1613
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1614
                return -1;
1615
            }
1616

    
1617
            block[j] = level;
1618
        }
1619
        CLOSE_READER(re, &s->gb);
1620
    }
1621
    s->block_last_index[n] = i;
1622
   return 0;
1623
}
1624

    
1625
static inline int mpeg1_decode_block_inter(MpegEncContext *s,
1626
                               DCTELEM *block,
1627
                               int n)
1628
{
1629
    int level, i, j, run;
1630
    RLTable *rl = &rl_mpeg1;
1631
    uint8_t * const scantable= s->intra_scantable.permutated;
1632
    const uint16_t *quant_matrix= s->inter_matrix;
1633
    const int qscale= s->qscale;
1634

    
1635
    {
1636
        OPEN_READER(re, &s->gb);
1637
        i = -1;
1638
        /* special case for the first coef. no need to add a second vlc table */
1639
        UPDATE_CACHE(re, &s->gb);
1640
        if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
1641
            level= (3*qscale*quant_matrix[0])>>5;
1642
            level= (level-1)|1;
1643
            if(GET_CACHE(re, &s->gb)&0x40000000)
1644
                level= -level;
1645
            block[0] = level;
1646
            i++;
1647
            SKIP_BITS(re, &s->gb, 2);
1648
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1649
                goto end;
1650
        }
1651

    
1652
        /* now quantify & encode AC coefs */
1653
        for(;;) {
1654
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1655

    
1656
            if(level != 0) {
1657
                i += run;
1658
                j = scantable[i];
1659
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1660
                level= (level-1)|1;
1661
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1662
                SKIP_BITS(re, &s->gb, 1);
1663
            } else {
1664
                /* escape */
1665
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1666
                UPDATE_CACHE(re, &s->gb);
1667
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1668
                if (level == -128) {
1669
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
1670
                } else if (level == 0) {
1671
                    level = SHOW_UBITS(re, &s->gb, 8)      ; SKIP_BITS(re, &s->gb, 8);
1672
                }
1673
                i += run;
1674
                j = scantable[i];
1675
                if(level<0){
1676
                    level= -level;
1677
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1678
                    level= (level-1)|1;
1679
                    level= -level;
1680
                }else{
1681
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1682
                    level= (level-1)|1;
1683
                }
1684
            }
1685
            if (i > 63){
1686
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1687
                return -1;
1688
            }
1689

    
1690
            block[j] = level;
1691
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1692
                break;
1693
            UPDATE_CACHE(re, &s->gb);
1694
        }
1695
end:
1696
        LAST_SKIP_BITS(re, &s->gb, 2);
1697
        CLOSE_READER(re, &s->gb);
1698
    }
1699
    s->block_last_index[n] = i;
1700
    return 0;
1701
}
1702

    
1703
static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n)
1704
{
1705
    int level, i, j, run;
1706
    RLTable *rl = &rl_mpeg1;
1707
    uint8_t * const scantable= s->intra_scantable.permutated;
1708
    const int qscale= s->qscale;
1709

    
1710
    {
1711
        OPEN_READER(re, &s->gb);
1712
        i = -1;
1713
        /* special case for the first coef. no need to add a second vlc table */
1714
        UPDATE_CACHE(re, &s->gb);
1715
        if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
1716
            level= (3*qscale)>>1;
1717
            level= (level-1)|1;
1718
            if(GET_CACHE(re, &s->gb)&0x40000000)
1719
                level= -level;
1720
            block[0] = level;
1721
            i++;
1722
            SKIP_BITS(re, &s->gb, 2);
1723
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1724
                goto end;
1725
        }
1726

    
1727
        /* now quantify & encode AC coefs */
1728
        for(;;) {
1729
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1730

    
1731
            if(level != 0) {
1732
                i += run;
1733
                j = scantable[i];
1734
                level= ((level*2+1)*qscale)>>1;
1735
                level= (level-1)|1;
1736
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1737
                SKIP_BITS(re, &s->gb, 1);
1738
            } else {
1739
                /* escape */
1740
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1741
                UPDATE_CACHE(re, &s->gb);
1742
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1743
                if (level == -128) {
1744
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
1745
                } else if (level == 0) {
1746
                    level = SHOW_UBITS(re, &s->gb, 8)      ; SKIP_BITS(re, &s->gb, 8);
1747
                }
1748
                i += run;
1749
                j = scantable[i];
1750
                if(level<0){
1751
                    level= -level;
1752
                    level= ((level*2+1)*qscale)>>1;
1753
                    level= (level-1)|1;
1754
                    level= -level;
1755
                }else{
1756
                    level= ((level*2+1)*qscale)>>1;
1757
                    level= (level-1)|1;
1758
                }
1759
            }
1760

    
1761
            block[j] = level;
1762
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1763
                break;
1764
            UPDATE_CACHE(re, &s->gb);
1765
        }
1766
end:
1767
        LAST_SKIP_BITS(re, &s->gb, 2);
1768
        CLOSE_READER(re, &s->gb);
1769
    }
1770
    s->block_last_index[n] = i;
1771
    return 0;
1772
}
1773

    
1774

    
1775
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
1776
                               DCTELEM *block,
1777
                               int n)
1778
{
1779
    int level, i, j, run;
1780
    RLTable *rl = &rl_mpeg1;
1781
    uint8_t * const scantable= s->intra_scantable.permutated;
1782
    const uint16_t *quant_matrix;
1783
    const int qscale= s->qscale;
1784
    int mismatch;
1785

    
1786
    mismatch = 1;
1787

    
1788
    {
1789
        OPEN_READER(re, &s->gb);
1790
        i = -1;
1791
        if (n < 4)
1792
            quant_matrix = s->inter_matrix;
1793
        else
1794
            quant_matrix = s->chroma_inter_matrix;
1795

    
1796
        /* special case for the first coef. no need to add a second vlc table */
1797
        UPDATE_CACHE(re, &s->gb);
1798
        if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
1799
            level= (3*qscale*quant_matrix[0])>>5;
1800
            if(GET_CACHE(re, &s->gb)&0x40000000)
1801
                level= -level;
1802
            block[0] = level;
1803
            mismatch ^= level;
1804
            i++;
1805
            SKIP_BITS(re, &s->gb, 2);
1806
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1807
                goto end;
1808
        }
1809

    
1810
        /* now quantify & encode AC coefs */
1811
        for(;;) {
1812
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1813

    
1814
            if(level != 0) {
1815
                i += run;
1816
                j = scantable[i];
1817
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1818
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1819
                SKIP_BITS(re, &s->gb, 1);
1820
            } else {
1821
                /* escape */
1822
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1823
                UPDATE_CACHE(re, &s->gb);
1824
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1825

    
1826
                i += run;
1827
                j = scantable[i];
1828
                if(level<0){
1829
                    level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1830
                    level= -level;
1831
                }else{
1832
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1833
                }
1834
            }
1835
            if (i > 63){
1836
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1837
                return -1;
1838
            }
1839

    
1840
            mismatch ^= level;
1841
            block[j] = level;
1842
            if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1843
                break;
1844
            UPDATE_CACHE(re, &s->gb);
1845
        }
1846
end:
1847
        LAST_SKIP_BITS(re, &s->gb, 2);
1848
        CLOSE_READER(re, &s->gb);
1849
    }
1850
    block[63] ^= (mismatch & 1);
1851

    
1852
    s->block_last_index[n] = i;
1853
    return 0;
1854
}
1855

    
1856
static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
1857
                               DCTELEM *block,
1858
                               int n)
1859
{
1860
    int level, i, j, run;
1861
    RLTable *rl = &rl_mpeg1;
1862
    uint8_t * const scantable= s->intra_scantable.permutated;
1863
    const int qscale= s->qscale;
1864
    OPEN_READER(re, &s->gb);
1865
    i = -1;
1866

    
1867
    /* special case for the first coef. no need to add a second vlc table */
1868
    UPDATE_CACHE(re, &s->gb);
1869
    if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
1870
        level= (3*qscale)>>1;
1871
        if(GET_CACHE(re, &s->gb)&0x40000000)
1872
            level= -level;
1873
        block[0] = level;
1874
        i++;
1875
        SKIP_BITS(re, &s->gb, 2);
1876
        if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1877
            goto end;
1878
    }
1879

    
1880
    /* now quantify & encode AC coefs */
1881
    for(;;) {
1882
        GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1883

    
1884
        if(level != 0) {
1885
            i += run;
1886
            j = scantable[i];
1887
            level= ((level*2+1)*qscale)>>1;
1888
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1889
            SKIP_BITS(re, &s->gb, 1);
1890
        } else {
1891
            /* escape */
1892
            run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1893
            UPDATE_CACHE(re, &s->gb);
1894
            level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1895

    
1896
            i += run;
1897
            j = scantable[i];
1898
            if(level<0){
1899
                level= ((-level*2+1)*qscale)>>1;
1900
                level= -level;
1901
            }else{
1902
                level= ((level*2+1)*qscale)>>1;
1903
            }
1904
        }
1905

    
1906
        block[j] = level;
1907
        if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1908
            break;
1909
        UPDATE_CACHE(re, &s->gb);
1910
    }
1911
end:
1912
    LAST_SKIP_BITS(re, &s->gb, 2);
1913
    CLOSE_READER(re, &s->gb);
1914
    s->block_last_index[n] = i;
1915
    return 0;
1916
}
1917

    
1918

    
1919
static inline int mpeg2_decode_block_intra(MpegEncContext *s,
1920
                               DCTELEM *block,
1921
                               int n)
1922
{
1923
    int level, dc, diff, i, j, run;
1924
    int component;
1925
    RLTable *rl;
1926
    uint8_t * const scantable= s->intra_scantable.permutated;
1927
    const uint16_t *quant_matrix;
1928
    const int qscale= s->qscale;
1929
    int mismatch;
1930

    
1931
    /* DC coef */
1932
    if (n < 4){
1933
        quant_matrix = s->intra_matrix;
1934
        component = 0;
1935
    }else{
1936
        quant_matrix = s->chroma_intra_matrix;
1937
        component = (n&1) + 1;
1938
    }
1939
    diff = decode_dc(&s->gb, component);
1940
    if (diff >= 0xffff)
1941
        return -1;
1942
    dc = s->last_dc[component];
1943
    dc += diff;
1944
    s->last_dc[component] = dc;
1945
    block[0] = dc << (3 - s->intra_dc_precision);
1946
    dprintf(s->avctx, "dc=%d\n", block[0]);
1947
    mismatch = block[0] ^ 1;
1948
    i = 0;
1949
    if (s->intra_vlc_format)
1950
        rl = &rl_mpeg2;
1951
    else
1952
        rl = &rl_mpeg1;
1953

    
1954
    {
1955
        OPEN_READER(re, &s->gb);
1956
        /* now quantify & encode AC coefs */
1957
        for(;;) {
1958
            UPDATE_CACHE(re, &s->gb);
1959
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1960

    
1961
            if(level == 127){
1962
                break;
1963
            } else if(level != 0) {
1964
                i += run;
1965
                j = scantable[i];
1966
                level= (level*qscale*quant_matrix[j])>>4;
1967
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1968
                LAST_SKIP_BITS(re, &s->gb, 1);
1969
            } else {
1970
                /* escape */
1971
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1972
                UPDATE_CACHE(re, &s->gb);
1973
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1974
                i += run;
1975
                j = scantable[i];
1976
                if(level<0){
1977
                    level= (-level*qscale*quant_matrix[j])>>4;
1978
                    level= -level;
1979
                }else{
1980
                    level= (level*qscale*quant_matrix[j])>>4;
1981
                }
1982
            }
1983
            if (i > 63){
1984
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1985
                return -1;
1986
            }
1987

    
1988
            mismatch^= level;
1989
            block[j] = level;
1990
        }
1991
        CLOSE_READER(re, &s->gb);
1992
    }
1993
    block[63]^= mismatch&1;
1994

    
1995
    s->block_last_index[n] = i;
1996
    return 0;
1997
}
1998

    
1999
static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
2000
                               DCTELEM *block,
2001
                               int n)
2002
{
2003
    int level, dc, diff, j, run;
2004
    int component;
2005
    RLTable *rl;
2006
    uint8_t * scantable= s->intra_scantable.permutated;
2007
    const uint16_t *quant_matrix;
2008
    const int qscale= s->qscale;
2009

    
2010
    /* DC coef */
2011
    if (n < 4){
2012
        quant_matrix = s->intra_matrix;
2013
        component = 0;
2014
    }else{
2015
        quant_matrix = s->chroma_intra_matrix;
2016
        component = (n&1) + 1;
2017
    }
2018
    diff = decode_dc(&s->gb, component);
2019
    if (diff >= 0xffff)
2020
        return -1;
2021
    dc = s->last_dc[component];
2022
    dc += diff;
2023
    s->last_dc[component] = dc;
2024
    block[0] = dc << (3 - s->intra_dc_precision);
2025
    if (s->intra_vlc_format)
2026
        rl = &rl_mpeg2;
2027
    else
2028
        rl = &rl_mpeg1;
2029

    
2030
    {
2031
        OPEN_READER(re, &s->gb);
2032
        /* now quantify & encode AC coefs */
2033
        for(;;) {
2034
            UPDATE_CACHE(re, &s->gb);
2035
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
2036

    
2037
            if(level == 127){
2038
                break;
2039
            } else if(level != 0) {
2040
                scantable += run;
2041
                j = *scantable;
2042
                level= (level*qscale*quant_matrix[j])>>4;
2043
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
2044
                LAST_SKIP_BITS(re, &s->gb, 1);
2045
            } else {
2046
                /* escape */
2047
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
2048
                UPDATE_CACHE(re, &s->gb);
2049
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
2050
                scantable += run;
2051
                j = *scantable;
2052
                if(level<0){
2053
                    level= (-level*qscale*quant_matrix[j])>>4;
2054
                    level= -level;
2055
                }else{
2056
                    level= (level*qscale*quant_matrix[j])>>4;
2057
                }
2058
            }
2059

    
2060
            block[j] = level;
2061
        }
2062
        CLOSE_READER(re, &s->gb);
2063
    }
2064

    
2065
    s->block_last_index[n] = scantable - s->intra_scantable.permutated;
2066
    return 0;
2067
}
2068

    
2069
typedef struct Mpeg1Context {
2070
    MpegEncContext mpeg_enc_ctx;
2071
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
2072
    int repeat_field; /* true if we must repeat the field */
2073
    AVPanScan pan_scan; /** some temporary storage for the panscan */
2074
    int slice_count;
2075
    int swap_uv;//indicate VCR2
2076
    int save_aspect_info;
2077
    int save_width, save_height;
2078
    AVRational frame_rate_ext;       ///< MPEG-2 specific framerate modificator
2079

    
2080
} Mpeg1Context;
2081

    
2082
static int mpeg_decode_init(AVCodecContext *avctx)
2083
{
2084
    Mpeg1Context *s = avctx->priv_data;
2085
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2086
    int i;
2087

    
2088
    //we need some parmutation to store
2089
    //matrixes, until MPV_common_init()
2090
    //set the real permutatuon
2091
    for(i=0;i<64;i++)
2092
       s2->dsp.idct_permutation[i]=i;
2093

    
2094
    MPV_decode_defaults(s2);
2095

    
2096
    s->mpeg_enc_ctx.avctx= avctx;
2097
    s->mpeg_enc_ctx.flags= avctx->flags;
2098
    s->mpeg_enc_ctx.flags2= avctx->flags2;
2099
    common_init(&s->mpeg_enc_ctx);
2100
    init_vlcs();
2101

    
2102
    s->mpeg_enc_ctx_allocated = 0;
2103
    s->mpeg_enc_ctx.picture_number = 0;
2104
    s->repeat_field = 0;
2105
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
2106
    return 0;
2107
}
2108

    
2109
static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
2110
                                     const uint8_t *new_perm){
2111
    uint16_t temp_matrix[64];
2112
    int i;
2113

    
2114
    memcpy(temp_matrix,matrix,64*sizeof(uint16_t));
2115

    
2116
    for(i=0;i<64;i++){
2117
        matrix[new_perm[i]] = temp_matrix[old_perm[i]];
2118
    }
2119
}
2120

    
2121
//Call this function when we know all parameters
2122
//it may be called in different places for mpeg1 and mpeg2
2123
static int mpeg_decode_postinit(AVCodecContext *avctx){
2124
    Mpeg1Context *s1 = avctx->priv_data;
2125
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2126
    uint8_t old_permutation[64];
2127

    
2128
    if (
2129
        (s1->mpeg_enc_ctx_allocated == 0)||
2130
        avctx->coded_width  != s->width ||
2131
        avctx->coded_height != s->height||
2132
        s1->save_width != s->width ||
2133
        s1->save_height != s->height ||
2134
        s1->save_aspect_info != s->aspect_ratio_info||
2135
        0)
2136
    {
2137

    
2138
        if (s1->mpeg_enc_ctx_allocated) {
2139
            ParseContext pc= s->parse_context;
2140
            s->parse_context.buffer=0;
2141
            MPV_common_end(s);
2142
            s->parse_context= pc;
2143
        }
2144

    
2145
        if( (s->width == 0 )||(s->height == 0))
2146
            return -2;
2147

    
2148
        avcodec_set_dimensions(avctx, s->width, s->height);
2149
        avctx->bit_rate = s->bit_rate;
2150
        s1->save_aspect_info = s->aspect_ratio_info;
2151
        s1->save_width = s->width;
2152
        s1->save_height = s->height;
2153

    
2154
     //low_delay may be forced, in this case we will have B frames
2155
     //that behave like P frames
2156
        avctx->has_b_frames = !(s->low_delay);
2157

    
2158
        if(avctx->sub_id==1){//s->codec_id==avctx->codec_id==CODEC_ID
2159
            //mpeg1 fps
2160
            avctx->time_base.den= ff_frame_rate_tab[s->frame_rate_index].num;
2161
            avctx->time_base.num= ff_frame_rate_tab[s->frame_rate_index].den;
2162
            //mpeg1 aspect
2163
            avctx->sample_aspect_ratio= av_d2q(
2164
                    1.0/mpeg1_aspect[s->aspect_ratio_info], 255);
2165

    
2166
        }else{//mpeg2
2167
        //mpeg2 fps
2168
            av_reduce(
2169
                &s->avctx->time_base.den,
2170
                &s->avctx->time_base.num,
2171
                ff_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
2172
                ff_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
2173
                1<<30);
2174
        //mpeg2 aspect
2175
            if(s->aspect_ratio_info > 1){
2176
                if( (s1->pan_scan.width == 0 )||(s1->pan_scan.height == 0) ){
2177
                    s->avctx->sample_aspect_ratio=
2178
                        av_div_q(
2179
                         mpeg2_aspect[s->aspect_ratio_info],
2180
                         (AVRational){s->width, s->height}
2181
                         );
2182
                }else{
2183
                    s->avctx->sample_aspect_ratio=
2184
                        av_div_q(
2185
                         mpeg2_aspect[s->aspect_ratio_info],
2186
                         (AVRational){s1->pan_scan.width, s1->pan_scan.height}
2187
                        );
2188
                }
2189
            }else{
2190
                s->avctx->sample_aspect_ratio=
2191
                    mpeg2_aspect[s->aspect_ratio_info];
2192
            }
2193
        }//mpeg2
2194

    
2195
        if(avctx->xvmc_acceleration){
2196
            avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
2197
        }else{
2198
            if(s->chroma_format <  2){
2199
                avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420);
2200
            }else
2201
            if(s->chroma_format == 2){
2202
                avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_422);
2203
            }else
2204
            if(s->chroma_format >  2){
2205
                avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_444);
2206
            }
2207
        }
2208
        //until then pix_fmt may be changed right after codec init
2209
        if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2210
            if( avctx->idct_algo == FF_IDCT_AUTO )
2211
                avctx->idct_algo = FF_IDCT_SIMPLE;
2212

    
2213
        //quantization matrixes may need reordering
2214
        //if dct permutation is changed
2215
        memcpy(old_permutation,s->dsp.idct_permutation,64*sizeof(uint8_t));
2216

    
2217
        if (MPV_common_init(s) < 0)
2218
            return -2;
2219

    
2220
        quant_matrix_rebuild(s->intra_matrix,       old_permutation,s->dsp.idct_permutation);
2221
        quant_matrix_rebuild(s->inter_matrix,       old_permutation,s->dsp.idct_permutation);
2222
        quant_matrix_rebuild(s->chroma_intra_matrix,old_permutation,s->dsp.idct_permutation);
2223
        quant_matrix_rebuild(s->chroma_inter_matrix,old_permutation,s->dsp.idct_permutation);
2224

    
2225
        s1->mpeg_enc_ctx_allocated = 1;
2226
    }
2227
    return 0;
2228
}
2229

    
2230
static int mpeg1_decode_picture(AVCodecContext *avctx,
2231
                                const uint8_t *buf, int buf_size)
2232
{
2233
    Mpeg1Context *s1 = avctx->priv_data;
2234
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2235
    int ref, f_code, vbv_delay;
2236

    
2237
    if(mpeg_decode_postinit(s->avctx) < 0)
2238
       return -2;
2239

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

    
2242
    ref = get_bits(&s->gb, 10); /* temporal ref */
2243
    s->pict_type = get_bits(&s->gb, 3);
2244
    if(s->pict_type == 0 || s->pict_type > 3)
2245
        return -1;
2246

    
2247
    vbv_delay= get_bits(&s->gb, 16);
2248
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
2249
        s->full_pel[0] = get_bits1(&s->gb);
2250
        f_code = get_bits(&s->gb, 3);
2251
        if (f_code == 0 && avctx->error_resilience >= FF_ER_COMPLIANT)
2252
            return -1;
2253
        s->mpeg_f_code[0][0] = f_code;
2254
        s->mpeg_f_code[0][1] = f_code;
2255
    }
2256
    if (s->pict_type == B_TYPE) {
2257
        s->full_pel[1] = get_bits1(&s->gb);
2258
        f_code = get_bits(&s->gb, 3);
2259
        if (f_code == 0 && avctx->error_resilience >= FF_ER_COMPLIANT)
2260
            return -1;
2261
        s->mpeg_f_code[1][0] = f_code;
2262
        s->mpeg_f_code[1][1] = f_code;
2263
    }
2264
    s->current_picture.pict_type= s->pict_type;
2265
    s->current_picture.key_frame= s->pict_type == I_TYPE;
2266

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

    
2270
    s->y_dc_scale = 8;
2271
    s->c_dc_scale = 8;
2272
    s->first_slice = 1;
2273
    return 0;
2274
}
2275

    
2276
static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
2277
{
2278
    MpegEncContext *s= &s1->mpeg_enc_ctx;
2279
    int horiz_size_ext, vert_size_ext;
2280
    int bit_rate_ext;
2281

    
2282
    skip_bits(&s->gb, 1); /* profil and level esc*/
2283
    s->avctx->profile= get_bits(&s->gb, 3);
2284
    s->avctx->level= get_bits(&s->gb, 4);
2285
    s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
2286
    s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
2287
    horiz_size_ext = get_bits(&s->gb, 2);
2288
    vert_size_ext = get_bits(&s->gb, 2);
2289
    s->width |= (horiz_size_ext << 12);
2290
    s->height |= (vert_size_ext << 12);
2291
    bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
2292
    s->bit_rate += (bit_rate_ext << 18) * 400;
2293
    skip_bits1(&s->gb); /* marker */
2294
    s->avctx->rc_buffer_size += get_bits(&s->gb, 8)*1024*16<<10;
2295

    
2296
    s->low_delay = get_bits1(&s->gb);
2297
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
2298

    
2299
    s1->frame_rate_ext.num = get_bits(&s->gb, 2)+1;
2300
    s1->frame_rate_ext.den = get_bits(&s->gb, 5)+1;
2301

    
2302
    dprintf(s->avctx, "sequence extension\n");
2303
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2304
    s->avctx->sub_id = 2; /* indicates mpeg2 found */
2305

    
2306
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2307
        av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d vbv buffer: %d, bitrate:%d\n",
2308
               s->avctx->profile, s->avctx->level, s->avctx->rc_buffer_size, s->bit_rate);
2309

    
2310
}
2311

    
2312
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
2313
{
2314
    MpegEncContext *s= &s1->mpeg_enc_ctx;
2315
    int color_description, w, h;
2316

    
2317
    skip_bits(&s->gb, 3); /* video format */
2318
    color_description= get_bits1(&s->gb);
2319
    if(color_description){
2320
        skip_bits(&s->gb, 8); /* color primaries */
2321
        skip_bits(&s->gb, 8); /* transfer_characteristics */
2322
        skip_bits(&s->gb, 8); /* matrix_coefficients */
2323
    }
2324
    w= get_bits(&s->gb, 14);
2325
    skip_bits(&s->gb, 1); //marker
2326
    h= get_bits(&s->gb, 14);
2327
    skip_bits(&s->gb, 1); //marker
2328

    
2329
    s1->pan_scan.width= 16*w;
2330
    s1->pan_scan.height=16*h;
2331

    
2332
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2333
        av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
2334
}
2335

    
2336
static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
2337
{
2338
    MpegEncContext *s= &s1->mpeg_enc_ctx;
2339
    int i,nofco;
2340

    
2341
    nofco = 1;
2342
    if(s->progressive_sequence){
2343
        if(s->repeat_first_field){
2344
            nofco++;
2345
            if(s->top_field_first)
2346
                nofco++;
2347
        }
2348
    }else{
2349
        if(s->picture_structure == PICT_FRAME){
2350
            nofco++;
2351
            if(s->repeat_first_field)
2352
                nofco++;
2353
        }
2354
    }
2355
    for(i=0; i<nofco; i++){
2356
        s1->pan_scan.position[i][0]= get_sbits(&s->gb, 16);
2357
        skip_bits(&s->gb, 1); //marker
2358
        s1->pan_scan.position[i][1]= get_sbits(&s->gb, 16);
2359
        skip_bits(&s->gb, 1); //marker
2360
    }
2361

    
2362
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2363
        av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n",
2364
            s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
2365
            s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
2366
            s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]
2367
        );
2368
}
2369

    
2370
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
2371
{
2372
    int i, v, j;
2373

    
2374
    dprintf(s->avctx, "matrix extension\n");
2375

    
2376
    if (get_bits1(&s->gb)) {
2377
        for(i=0;i<64;i++) {
2378
            v = get_bits(&s->gb, 8);
2379
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2380
            s->intra_matrix[j] = v;
2381
            s->chroma_intra_matrix[j] = v;
2382
        }
2383
    }
2384
    if (get_bits1(&s->gb)) {
2385
        for(i=0;i<64;i++) {
2386
            v = get_bits(&s->gb, 8);
2387
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2388
            s->inter_matrix[j] = v;
2389
            s->chroma_inter_matrix[j] = v;
2390
        }
2391
    }
2392
    if (get_bits1(&s->gb)) {
2393
        for(i=0;i<64;i++) {
2394
            v = get_bits(&s->gb, 8);
2395
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2396
            s->chroma_intra_matrix[j] = v;
2397
        }
2398
    }
2399
    if (get_bits1(&s->gb)) {
2400
        for(i=0;i<64;i++) {
2401
            v = get_bits(&s->gb, 8);
2402
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2403
            s->chroma_inter_matrix[j] = v;
2404
        }
2405
    }
2406
}
2407

    
2408
static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
2409
{
2410
    s->full_pel[0] = s->full_pel[1] = 0;
2411
    s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
2412
    s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
2413
    s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
2414
    s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
2415
    s->intra_dc_precision = get_bits(&s->gb, 2);
2416
    s->picture_structure = get_bits(&s->gb, 2);
2417
    s->top_field_first = get_bits1(&s->gb);
2418
    s->frame_pred_frame_dct = get_bits1(&s->gb);
2419
    s->concealment_motion_vectors = get_bits1(&s->gb);
2420
    s->q_scale_type = get_bits1(&s->gb);
2421
    s->intra_vlc_format = get_bits1(&s->gb);
2422
    s->alternate_scan = get_bits1(&s->gb);
2423
    s->repeat_first_field = get_bits1(&s->gb);
2424
    s->chroma_420_type = get_bits1(&s->gb);
2425
    s->progressive_frame = get_bits1(&s->gb);
2426

    
2427
    if(s->picture_structure == PICT_FRAME){
2428
        s->first_field=0;
2429
        s->v_edge_pos= 16*s->mb_height;
2430
    }else{
2431
        s->first_field ^= 1;
2432
        s->v_edge_pos=  8*s->mb_height;
2433
        memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
2434
    }
2435

    
2436
    if(s->alternate_scan){
2437
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
2438
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
2439
    }else{
2440
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
2441
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
2442
    }
2443

    
2444
    /* composite display not parsed */
2445
    dprintf(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
2446
    dprintf(s->avctx, "picture_structure=%d\n", s->picture_structure);
2447
    dprintf(s->avctx, "top field first=%d\n", s->top_field_first);
2448
    dprintf(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
2449
    dprintf(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
2450
    dprintf(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
2451
    dprintf(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
2452
    dprintf(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
2453
    dprintf(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
2454
}
2455

    
2456
static void mpeg_decode_extension(AVCodecContext *avctx,
2457
                                  const uint8_t *buf, int buf_size)
2458
{
2459
    Mpeg1Context *s1 = avctx->priv_data;
2460
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2461
    int ext_type;
2462

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

    
2465
    ext_type = get_bits(&s->gb, 4);
2466
    switch(ext_type) {
2467
    case 0x1:
2468
        mpeg_decode_sequence_extension(s1);
2469
        break;
2470
    case 0x2:
2471
        mpeg_decode_sequence_display_extension(s1);
2472
        break;
2473
    case 0x3:
2474
        mpeg_decode_quant_matrix_extension(s);
2475
        break;
2476
    case 0x7:
2477
        mpeg_decode_picture_display_extension(s1);
2478
        break;
2479
    case 0x8:
2480
        mpeg_decode_picture_coding_extension(s);
2481
        break;
2482
    }
2483
}
2484

    
2485
static void exchange_uv(MpegEncContext *s){
2486
    short * tmp = s->pblocks[4];
2487
    s->pblocks[4] = s->pblocks[5];
2488
    s->pblocks[5] = tmp;
2489
}
2490

    
2491
static int mpeg_field_start(MpegEncContext *s){
2492
    AVCodecContext *avctx= s->avctx;
2493
    Mpeg1Context *s1 = (Mpeg1Context*)s;
2494

    
2495
    /* start frame decoding */
2496
    if(s->first_field || s->picture_structure==PICT_FRAME){
2497
        if(MPV_frame_start(s, avctx) < 0)
2498
            return -1;
2499

    
2500
        ff_er_frame_start(s);
2501

    
2502
        /* first check if we must repeat the frame */
2503
        s->current_picture_ptr->repeat_pict = 0;
2504
        if (s->repeat_first_field) {
2505
            if (s->progressive_sequence) {
2506
                if (s->top_field_first)
2507
                    s->current_picture_ptr->repeat_pict = 4;
2508
                else
2509
                    s->current_picture_ptr->repeat_pict = 2;
2510
            } else if (s->progressive_frame) {
2511
                s->current_picture_ptr->repeat_pict = 1;
2512
            }
2513
        }
2514

    
2515
        *s->current_picture_ptr->pan_scan= s1->pan_scan;
2516
    }else{ //second field
2517
            int i;
2518

    
2519
            if(!s->current_picture_ptr){
2520
                av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
2521
                return -1;
2522
            }
2523

    
2524
            for(i=0; i<4; i++){
2525
                s->current_picture.data[i] = s->current_picture_ptr->data[i];
2526
                if(s->picture_structure == PICT_BOTTOM_FIELD){
2527
                    s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
2528
                }
2529
            }
2530
    }
2531
#ifdef HAVE_XVMC
2532
// MPV_frame_start will call this function too,
2533
// but we need to call it on every field
2534
    if(s->avctx->xvmc_acceleration)
2535
         XVMC_field_start(s,avctx);
2536
#endif
2537

    
2538
    return 0;
2539
}
2540

    
2541
#define DECODE_SLICE_ERROR -1
2542
#define DECODE_SLICE_OK 0
2543

    
2544
/**
2545
 * decodes a slice. MpegEncContext.mb_y must be set to the MB row from the startcode
2546
 * @return DECODE_SLICE_ERROR if the slice is damaged<br>
2547
 *         DECODE_SLICE_OK if this slice is ok<br>
2548
 */
2549
static int mpeg_decode_slice(Mpeg1Context *s1, int mb_y,
2550
                             const uint8_t **buf, int buf_size)
2551
{
2552
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2553
    AVCodecContext *avctx= s->avctx;
2554
    int ret;
2555
    const int field_pic= s->picture_structure != PICT_FRAME;
2556
    const int lowres= s->avctx->lowres;
2557

    
2558
    s->resync_mb_x=
2559
    s->resync_mb_y= -1;
2560

    
2561
    if (mb_y<<field_pic >= s->mb_height){
2562
        av_log(s->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s->mb_height);
2563
        return -1;
2564
    }
2565

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

    
2568
    ff_mpeg1_clean_buffers(s);
2569
    s->interlaced_dct = 0;
2570

    
2571
    s->qscale = get_qscale(s);
2572

    
2573
    if(s->qscale == 0){
2574
        av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
2575
        return -1;
2576
    }
2577

    
2578
    /* extra slice info */
2579
    while (get_bits1(&s->gb) != 0) {
2580
        skip_bits(&s->gb, 8);
2581
    }
2582

    
2583
    s->mb_x=0;
2584

    
2585
    for(;;) {
2586
        int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
2587
        if (code < 0){
2588
            av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
2589
            return -1;
2590
        }
2591
        if (code >= 33) {
2592
            if (code == 33) {
2593
                s->mb_x += 33;
2594
            }
2595
            /* otherwise, stuffing, nothing to do */
2596
        } else {
2597
            s->mb_x += code;
2598
            break;
2599
        }
2600
    }
2601
    if(s->mb_x >= (unsigned)s->mb_width){
2602
        av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
2603
        return -1;
2604
    }
2605

    
2606
    s->resync_mb_x= s->mb_x;
2607
    s->resync_mb_y= s->mb_y= mb_y;
2608
    s->mb_skip_run= 0;
2609
    ff_init_block_index(s);
2610

    
2611
    if (s->mb_y==0 && s->mb_x==0 && (s->first_field || s->picture_structure==PICT_FRAME)) {
2612
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
2613
             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",
2614
                 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],
2615
                 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
2616
                 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"",
2617
                 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
2618
                 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
2619
        }
2620
    }
2621

    
2622
    for(;;) {
2623
#ifdef HAVE_XVMC
2624
        //one 1 we memcpy blocks in xvmcvideo
2625
        if(s->avctx->xvmc_acceleration > 1)
2626
            XVMC_init_block(s);//set s->block
2627
#endif
2628

    
2629
        ret = mpeg_decode_mb(s, s->block);
2630
        s->chroma_qscale= s->qscale;
2631

    
2632
        dprintf(s->avctx, "ret=%d\n", ret);
2633
        if (ret < 0)
2634
            return -1;
2635

    
2636
        if(s->current_picture.motion_val[0] && !s->encoding){ //note motion_val is normally NULL unless we want to extract the MVs
2637
            const int wrap = field_pic ? 2*s->b8_stride : s->b8_stride;
2638
            int xy = s->mb_x*2 + s->mb_y*2*wrap;
2639
            int motion_x, motion_y, dir, i;
2640
            if(field_pic && !s->first_field)
2641
                xy += wrap/2;
2642

    
2643
            for(i=0; i<2; i++){
2644
                for(dir=0; dir<2; dir++){
2645
                    if (s->mb_intra || (dir==1 && s->pict_type != B_TYPE)) {
2646
                        motion_x = motion_y = 0;
2647
                    }else if (s->mv_type == MV_TYPE_16X16 || (s->mv_type == MV_TYPE_FIELD && field_pic)){
2648
                        motion_x = s->mv[dir][0][0];
2649
                        motion_y = s->mv[dir][0][1];
2650
                    } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ {
2651
                        motion_x = s->mv[dir][i][0];
2652
                        motion_y = s->mv[dir][i][1];
2653
                    }
2654

    
2655
                    s->current_picture.motion_val[dir][xy    ][0] = motion_x;
2656
                    s->current_picture.motion_val[dir][xy    ][1] = motion_y;
2657
                    s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
2658
                    s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
2659
                    s->current_picture.ref_index [dir][xy    ]=
2660
                    s->current_picture.ref_index [dir][xy + 1]= s->field_select[dir][i];
2661
                    assert(s->field_select[dir][i]==0 || s->field_select[dir][i]==1);
2662
                }
2663
                xy += wrap;
2664
            }
2665
        }
2666

    
2667
        s->dest[0] += 16 >> lowres;
2668
        s->dest[1] += 16 >> (s->chroma_x_shift + lowres);
2669
        s->dest[2] += 16 >> (s->chroma_x_shift + lowres);
2670

    
2671
        MPV_decode_mb(s, s->block);
2672

    
2673
        if (++s->mb_x >= s->mb_width) {
2674
            const int mb_size= 16>>s->avctx->lowres;
2675

    
2676
            ff_draw_horiz_band(s, mb_size*s->mb_y, mb_size);
2677

    
2678
            s->mb_x = 0;
2679
            s->mb_y++;
2680

    
2681
            if(s->mb_y<<field_pic >= s->mb_height){
2682
                int left= s->gb.size_in_bits - get_bits_count(&s->gb);
2683
                int is_d10= s->chroma_format==2 && s->pict_type==I_TYPE && avctx->profile==0 && avctx->level==5
2684
                            && s->intra_dc_precision == 2 && s->q_scale_type == 1 && s->alternate_scan == 0
2685
                            && s->progressive_frame == 0 /* vbv_delay == 0xBBB || 0xE10*/;
2686

    
2687
                if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10)
2688
                   || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
2689
                    av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n", left, show_bits(&s->gb, FFMIN(left, 23)));
2690
                    return -1;
2691
                }else
2692
                    goto eos;
2693
            }
2694

    
2695
            ff_init_block_index(s);
2696
        }
2697

    
2698
        /* skip mb handling */
2699
        if (s->mb_skip_run == -1) {
2700
            /* read again increment */
2701
            s->mb_skip_run = 0;
2702
            for(;;) {
2703
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
2704
                if (code < 0){
2705
                    av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
2706
                    return -1;
2707
                }
2708
                if (code >= 33) {
2709
                    if (code == 33) {
2710
                        s->mb_skip_run += 33;
2711
                    }else if(code == 35){
2712
                        if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
2713
                            av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
2714
                            return -1;
2715
                        }
2716
                        goto eos; /* end of slice */
2717
                    }
2718
                    /* otherwise, stuffing, nothing to do */
2719
                } else {
2720
                    s->mb_skip_run += code;
2721
                    break;
2722
                }
2723
            }
2724
        }
2725
    }
2726
eos: // end of slice
2727
    *buf += get_bits_count(&s->gb)/8 - 1;
2728
//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
2729
    return 0;
2730
}
2731

    
2732
static int slice_decode_thread(AVCodecContext *c, void *arg){
2733
    MpegEncContext *s= arg;
2734
    const uint8_t *buf= s->gb.buffer;
2735
    int mb_y= s->start_mb_y;
2736

    
2737
    s->error_count= 3*(s->end_mb_y - s->start_mb_y)*s->mb_width;
2738

    
2739
    for(;;){
2740
        uint32_t start_code;
2741
        int ret;
2742

    
2743
        ret= mpeg_decode_slice((Mpeg1Context*)s, mb_y, &buf, s->gb.buffer_end - buf);
2744
        emms_c();
2745
//av_log(c, AV_LOG_DEBUG, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2746
//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);
2747
        if(ret < 0){
2748
            if(s->resync_mb_x>=0 && s->resync_mb_y>=0)
2749
                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);
2750
        }else{
2751
            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);
2752
        }
2753

    
2754
        if(s->mb_y == s->end_mb_y)
2755
            return 0;
2756

    
2757
        start_code= -1;
2758
        buf = ff_find_start_code(buf, s->gb.buffer_end, &start_code);
2759
        mb_y= start_code - SLICE_MIN_START_CODE;
2760
        if(mb_y < 0 || mb_y >= s->end_mb_y)
2761
            return -1;
2762
    }
2763

    
2764
    return 0; //not reached
2765
}
2766

    
2767
/**
2768
 * handles slice ends.
2769
 * @return 1 if it seems to be the last slice of
2770
 */
2771
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2772
{
2773
    Mpeg1Context *s1 = avctx->priv_data;
2774
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2775

    
2776
    if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2777
        return 0;
2778

    
2779
#ifdef HAVE_XVMC
2780
    if(s->avctx->xvmc_acceleration)
2781
        XVMC_field_end(s);
2782
#endif
2783
    /* end of slice reached */
2784
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
2785
        /* end of image */
2786

    
2787
        s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
2788

    
2789
        ff_er_frame_end(s);
2790

    
2791
        MPV_frame_end(s);
2792

    
2793
        if (s->pict_type == B_TYPE || s->low_delay) {
2794
            *pict= *(AVFrame*)s->current_picture_ptr;
2795
            ff_print_debug_info(s, pict);
2796
        } else {
2797
            s->picture_number++;
2798
            /* latency of 1 frame for I and P frames */
2799
            /* XXX: use another variable than picture_number */
2800
            if (s->last_picture_ptr != NULL) {
2801
                *pict= *(AVFrame*)s->last_picture_ptr;
2802
                 ff_print_debug_info(s, pict);
2803
            }
2804
        }
2805

    
2806
        return 1;
2807
    } else {
2808
        return 0;
2809
    }
2810
}
2811

    
2812
static int mpeg1_decode_sequence(AVCodecContext *avctx,
2813
                                 const uint8_t *buf, int buf_size)
2814
{
2815
    Mpeg1Context *s1 = avctx->priv_data;
2816
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2817
    int width,height;
2818
    int i, v, j;
2819

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

    
2822
    width = get_bits(&s->gb, 12);
2823
    height = get_bits(&s->gb, 12);
2824
    if (width <= 0 || height <= 0 ||
2825
        (width % 2) != 0 || (height % 2) != 0)
2826
        return -1;
2827
    s->aspect_ratio_info= get_bits(&s->gb, 4);
2828
    if (s->aspect_ratio_info == 0)
2829
        return -1;
2830
    s->frame_rate_index = get_bits(&s->gb, 4);
2831
    if (s->frame_rate_index == 0 || s->frame_rate_index > 13)
2832
        return -1;
2833
    s->bit_rate = get_bits(&s->gb, 18) * 400;
2834
    if (get_bits1(&s->gb) == 0) /* marker */
2835
        return -1;
2836
    s->width = width;
2837
    s->height = height;
2838

    
2839
    s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16;
2840
    skip_bits(&s->gb, 1);
2841

    
2842
    /* get matrix */
2843
    if (get_bits1(&s->gb)) {
2844
        for(i=0;i<64;i++) {
2845
            v = get_bits(&s->gb, 8);
2846
            if(v==0){
2847
                av_log(s->avctx, AV_LOG_ERROR, "intra matrix damaged\n");
2848
                return -1;
2849
            }
2850
            j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2851
            s->intra_matrix[j] = v;
2852
            s->chroma_intra_matrix[j] = v;
2853
        }
2854
#ifdef DEBUG
2855
        dprintf(s->avctx, "intra matrix present\n");
2856
        for(i=0;i<64;i++)
2857
            dprintf(s->avctx, " %d", s->intra_matrix[s->dsp.idct_permutation[i]]);
2858
        dprintf(s->avctx, "\n");
2859
#endif
2860
    } else {
2861
        for(i=0;i<64;i++) {
2862
            j = s->dsp.idct_permutation[i];
2863
            v = ff_mpeg1_default_intra_matrix[i];
2864
            s->intra_matrix[j] = v;
2865
            s->chroma_intra_matrix[j] = v;
2866
        }
2867
    }
2868
    if (get_bits1(&s->gb)) {
2869
        for(i=0;i<64;i++) {
2870
            v = get_bits(&s->gb, 8);
2871
            if(v==0){
2872
                av_log(s->avctx, AV_LOG_ERROR, "inter matrix damaged\n");
2873
                return -1;
2874
            }
2875
            j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2876
            s->inter_matrix[j] = v;
2877
            s->chroma_inter_matrix[j] = v;
2878
        }
2879
#ifdef DEBUG
2880
        dprintf(s->avctx, "non intra matrix present\n");
2881
        for(i=0;i<64;i++)
2882
            dprintf(s->avctx, " %d", s->inter_matrix[s->dsp.idct_permutation[i]]);
2883
        dprintf(s->avctx, "\n");
2884
#endif
2885
    } else {
2886
        for(i=0;i<64;i++) {
2887
            int j= s->dsp.idct_permutation[i];
2888
            v = ff_mpeg1_default_non_intra_matrix[i];
2889
            s->inter_matrix[j] = v;
2890
            s->chroma_inter_matrix[j] = v;
2891
        }
2892
    }
2893

    
2894
    if(show_bits(&s->gb, 23) != 0){
2895
        av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2896
        return -1;
2897
    }
2898

    
2899
    /* we set mpeg2 parameters so that it emulates mpeg1 */
2900
    s->progressive_sequence = 1;
2901
    s->progressive_frame = 1;
2902
    s->picture_structure = PICT_FRAME;
2903
    s->frame_pred_frame_dct = 1;
2904
    s->chroma_format = 1;
2905
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO;
2906
    avctx->sub_id = 1; /* indicates mpeg1 */
2907
    s->out_format = FMT_MPEG1;
2908
    s->swap_uv = 0;//AFAIK VCR2 don't have SEQ_HEADER
2909
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
2910

    
2911
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2912
        av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n",
2913
               s->avctx->rc_buffer_size, s->bit_rate);
2914

    
2915
    return 0;
2916
}
2917

    
2918
static int vcr2_init_sequence(AVCodecContext *avctx)
2919
{
2920
    Mpeg1Context *s1 = avctx->priv_data;
2921
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2922
    int i, v;
2923

    
2924
    /* start new mpeg1 context decoding */
2925
    s->out_format = FMT_MPEG1;
2926
    if (s1->mpeg_enc_ctx_allocated) {
2927
        MPV_common_end(s);
2928
    }
2929
    s->width  = avctx->coded_width;
2930
    s->height = avctx->coded_height;
2931
    avctx->has_b_frames= 0; //true?
2932
    s->low_delay= 1;
2933

    
2934
    if(avctx->xvmc_acceleration){
2935
        avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
2936
    }else{
2937
        avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420);
2938
    }
2939

    
2940
    if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2941
        if( avctx->idct_algo == FF_IDCT_AUTO )
2942
            avctx->idct_algo = FF_IDCT_SIMPLE;
2943

    
2944
    if (MPV_common_init(s) < 0)
2945
        return -1;
2946
    exchange_uv(s);//common init reset pblocks, so we swap them here
2947
    s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB
2948
    s1->mpeg_enc_ctx_allocated = 1;
2949

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

    
2956
        v = ff_mpeg1_default_non_intra_matrix[i];
2957
        s->inter_matrix[j] = v;
2958
        s->chroma_inter_matrix[j] = v;
2959
    }
2960

    
2961
    s->progressive_sequence = 1;
2962
    s->progressive_frame = 1;
2963
    s->picture_structure = PICT_FRAME;
2964
    s->frame_pred_frame_dct = 1;
2965
    s->chroma_format = 1;
2966
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2967
    avctx->sub_id = 2; /* indicates mpeg2 */
2968
    return 0;
2969
}
2970

    
2971

    
2972
static void mpeg_decode_user_data(AVCodecContext *avctx,
2973
                                  const uint8_t *buf, int buf_size)
2974
{
2975
    const uint8_t *p;
2976
    int len, flags;
2977
    p = buf;
2978
    len = buf_size;
2979

    
2980
    /* we parse the DTG active format information */
2981
    if (len >= 5 &&
2982
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2983
        flags = p[4];
2984
        p += 5;
2985
        len -= 5;
2986
        if (flags & 0x80) {
2987
            /* skip event id */
2988
            if (len < 2)
2989
                return;
2990
            p += 2;
2991
            len -= 2;
2992
        }
2993
        if (flags & 0x40) {
2994
            if (len < 1)
2995
                return;
2996
            avctx->dtg_active_format = p[0] & 0x0f;
2997
        }
2998
    }
2999
}
3000

    
3001
static void mpeg_decode_gop(AVCodecContext *avctx,
3002
                            const uint8_t *buf, int buf_size){
3003
    Mpeg1Context *s1 = avctx->priv_data;
3004
    MpegEncContext *s = &s1->mpeg_enc_ctx;
3005

    
3006
    int drop_frame_flag;
3007
    int time_code_hours, time_code_minutes;
3008
    int time_code_seconds, time_code_pictures;
3009
    int broken_link;
3010

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

    
3013
    drop_frame_flag = get_bits1(&s->gb);
3014

    
3015
    time_code_hours=get_bits(&s->gb,5);
3016
    time_code_minutes = get_bits(&s->gb,6);
3017
    skip_bits1(&s->gb);//marker bit
3018
    time_code_seconds = get_bits(&s->gb,6);
3019
    time_code_pictures = get_bits(&s->gb,6);
3020

    
3021
    /*broken_link indicate that after editing the
3022
      reference frames of the first B-Frames after GOP I-Frame
3023
      are missing (open gop)*/
3024
    broken_link = get_bits1(&s->gb);
3025

    
3026
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
3027
        av_log(s->avctx, AV_LOG_DEBUG, "GOP (%2d:%02d:%02d.[%02d]) broken_link=%d\n",
3028
            time_code_hours, time_code_minutes, time_code_seconds,
3029
            time_code_pictures, broken_link);
3030
}
3031
/**
3032
 * finds the end of the current frame in the bitstream.
3033
 * @return the position of the first byte of the next frame, or -1
3034
 */
3035
int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)
3036
{
3037
    int i;
3038
    uint32_t state= pc->state;
3039

    
3040
    i=0;
3041
    if(!pc->frame_start_found){
3042
        for(i=0; i<buf_size; i++){
3043
            i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1;
3044
            if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
3045
                i++;
3046
                pc->frame_start_found=1;
3047
                break;
3048
            }
3049
        }
3050
    }
3051

    
3052
    if(pc->frame_start_found){
3053
        /* EOF considered as end of frame */
3054
        if (buf_size == 0)
3055
            return 0;
3056
        for(; i<buf_size; i++){
3057
            i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1;
3058
            if((state&0xFFFFFF00) == 0x100){
3059
                if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
3060
                    pc->frame_start_found=0;
3061
                    pc->state=-1;
3062
                    return i-3;
3063
                }
3064
            }
3065
        }
3066
    }
3067
    pc->state= state;
3068
    return END_NOT_FOUND;
3069
}
3070

    
3071
/* handle buffering and image synchronisation */
3072
static int mpeg_decode_frame(AVCodecContext *avctx,
3073
                             void *data, int *data_size,
3074
                             uint8_t *buf, int buf_size)
3075
{
3076
    Mpeg1Context *s = avctx->priv_data;
3077
    const uint8_t *buf_end;
3078
    const uint8_t *buf_ptr;
3079
    uint32_t start_code;
3080
    int ret, input_size;
3081
    AVFrame *picture = data;
3082
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
3083
    dprintf(avctx, "fill_buffer\n");
3084

    
3085
    if (buf_size == 0) {
3086
        /* special case for last picture */
3087
        if (s2->low_delay==0 && s2->next_picture_ptr) {
3088
            *picture= *(AVFrame*)s2->next_picture_ptr;
3089
            s2->next_picture_ptr= NULL;
3090

    
3091
            *data_size = sizeof(AVFrame);
3092
        }
3093
        return 0;
3094
    }
3095

    
3096
    if(s2->flags&CODEC_FLAG_TRUNCATED){
3097
        int next= ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size);
3098

    
3099
        if( ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
3100
            return buf_size;
3101
    }
3102

    
3103
    buf_ptr = buf;
3104
    buf_end = buf + buf_size;
3105

    
3106
#if 0
3107
    if (s->repeat_field % 2 == 1) {
3108
        s->repeat_field++;
3109
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
3110
        //        s2->picture_number, s->repeat_field);
3111
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
3112
            *data_size = sizeof(AVPicture);
3113
            goto the_end;
3114
        }
3115
    }
3116
#endif
3117

    
3118
    if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2"))
3119
        vcr2_init_sequence(avctx);
3120

    
3121
    s->slice_count= 0;
3122

    
3123
    for(;;) {
3124
        /* find start next code */
3125
        start_code = -1;
3126
        buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code);
3127
        if (start_code > 0x1ff){
3128
            if(s2->pict_type != B_TYPE || avctx->skip_frame <= AVDISCARD_DEFAULT){
3129
                if(avctx->thread_count > 1){
3130
                    int i;
3131

    
3132
                    avctx->execute(avctx, slice_decode_thread,  (void**)&(s2->thread_context[0]), NULL, s->slice_count);
3133
                    for(i=0; i<s->slice_count; i++)
3134
                        s2->error_count += s2->thread_context[i]->error_count;
3135
                }
3136
                if (slice_end(avctx, picture)) {
3137
                    if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
3138
                        *data_size = sizeof(AVPicture);
3139
                }
3140
            }
3141
            return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
3142
        }
3143

    
3144
        input_size = buf_end - buf_ptr;
3145

    
3146
        if(avctx->debug & FF_DEBUG_STARTCODE){
3147
            av_log(avctx, AV_LOG_DEBUG, "%3X at %zd left %d\n", start_code, buf_ptr-buf, input_size);
3148
        }
3149

    
3150
        /* prepare data for next start code */
3151
        switch(start_code) {
3152
        case SEQ_START_CODE:
3153
            mpeg1_decode_sequence(avctx, buf_ptr,
3154
                                    input_size);
3155
            break;
3156

    
3157
        case PICTURE_START_CODE:
3158
            /* we have a complete image : we try to decompress it */
3159
            mpeg1_decode_picture(avctx,
3160
                                    buf_ptr, input_size);
3161
            break;
3162
        case EXT_START_CODE:
3163
            mpeg_decode_extension(avctx,
3164
                                    buf_ptr, input_size);
3165
            break;
3166
        case USER_START_CODE:
3167
            mpeg_decode_user_data(avctx,
3168
                                    buf_ptr, input_size);
3169
            break;
3170
        case GOP_START_CODE:
3171
            s2->first_field=0;
3172
            mpeg_decode_gop(avctx,
3173
                                    buf_ptr, input_size);
3174
            break;
3175
        default:
3176
            if (start_code >= SLICE_MIN_START_CODE &&
3177
                start_code <= SLICE_MAX_START_CODE) {
3178
                int mb_y= start_code - SLICE_MIN_START_CODE;
3179

    
3180
                if(s2->last_picture_ptr==NULL){
3181
                /* Skip B-frames if we do not have reference frames. */
3182
                    if(s2->pict_type==B_TYPE) break;
3183
                /* Skip P-frames if we do not have reference frame no valid header. */
3184
//                    if(s2->pict_type==P_TYPE && s2->first_field && !s2->first_slice) break;
3185
                }
3186
                /* Skip B-frames if we are in a hurry. */
3187
                if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
3188
                if(  (avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type==B_TYPE)
3189
                    ||(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type!=I_TYPE)
3190
                    || avctx->skip_frame >= AVDISCARD_ALL)
3191
                    break;
3192
                /* Skip everything if we are in a hurry>=5. */
3193
                if(avctx->hurry_up>=5) break;
3194

    
3195
                if (!s->mpeg_enc_ctx_allocated) break;
3196

    
3197
                if(s2->codec_id == CODEC_ID_MPEG2VIDEO){
3198
                    if(mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom)
3199
                        break;
3200
                }
3201

    
3202
                if(s2->first_slice){
3203
                    s2->first_slice=0;
3204
                            if(mpeg_field_start(s2) < 0)
3205
                        return -1;
3206
                    }
3207
                if(!s2->current_picture_ptr){
3208
                    av_log(avctx, AV_LOG_ERROR, "current_picture not initalized\n");
3209
                    return -1;
3210
                }
3211

    
3212
                if(avctx->thread_count > 1){
3213
                    int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count;
3214
                    if(threshold <= mb_y){
3215
                        MpegEncContext *thread_context= s2->thread_context[s->slice_count];
3216

    
3217
                        thread_context->start_mb_y= mb_y;
3218
                        thread_context->end_mb_y  = s2->mb_height;
3219
                        if(s->slice_count){
3220
                            s2->thread_context[s->slice_count-1]->end_mb_y= mb_y;
3221
                            ff_update_duplicate_context(thread_context, s2);
3222
                        }
3223
                        init_get_bits(&thread_context->gb, buf_ptr, input_size*8);
3224
                        s->slice_count++;
3225
                    }
3226
                    buf_ptr += 2; //FIXME add minimum num of bytes per slice
3227
                }else{
3228
                    ret = mpeg_decode_slice(s, mb_y, &buf_ptr, input_size);
3229
                    emms_c();
3230

    
3231
                    if(ret < 0){
3232
                        if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
3233
                            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);
3234
                    }else{
3235
                        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);
3236
                    }
3237
                }
3238
            }
3239
            break;
3240
        }
3241
    }
3242
}
3243

    
3244
static int mpeg_decode_end(AVCodecContext *avctx)
3245
{
3246
    Mpeg1Context *s = avctx->priv_data;
3247

    
3248
    if (s->mpeg_enc_ctx_allocated)
3249
        MPV_common_end(&s->mpeg_enc_ctx);
3250
    return 0;
3251
}
3252

    
3253
AVCodec mpeg1video_decoder = {
3254
    "mpeg1video",
3255
    CODEC_TYPE_VIDEO,
3256
    CODEC_ID_MPEG1VIDEO,
3257
    sizeof(Mpeg1Context),
3258
    mpeg_decode_init,
3259
    NULL,
3260
    mpeg_decode_end,
3261
    mpeg_decode_frame,
3262
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
3263
    .flush= ff_mpeg_flush,
3264
};
3265

    
3266
AVCodec mpeg2video_decoder = {
3267
    "mpeg2video",
3268
    CODEC_TYPE_VIDEO,
3269
    CODEC_ID_MPEG2VIDEO,
3270
    sizeof(Mpeg1Context),
3271
    mpeg_decode_init,
3272
    NULL,
3273
    mpeg_decode_end,
3274
    mpeg_decode_frame,
3275
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
3276
    .flush= ff_mpeg_flush,
3277
};
3278

    
3279
//legacy decoder
3280
AVCodec mpegvideo_decoder = {
3281
    "mpegvideo",
3282
    CODEC_TYPE_VIDEO,
3283
    CODEC_ID_MPEG2VIDEO,
3284
    sizeof(Mpeg1Context),
3285
    mpeg_decode_init,
3286
    NULL,
3287
    mpeg_decode_end,
3288
    mpeg_decode_frame,
3289
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
3290
    .flush= ff_mpeg_flush,
3291
};
3292

    
3293
#ifdef CONFIG_ENCODERS
3294

    
3295
AVCodec mpeg1video_encoder = {
3296
    "mpeg1video",
3297
    CODEC_TYPE_VIDEO,
3298
    CODEC_ID_MPEG1VIDEO,
3299
    sizeof(MpegEncContext),
3300
    encode_init,
3301
    MPV_encode_picture,
3302
    MPV_encode_end,
3303
    .supported_framerates= ff_frame_rate_tab+1,
3304
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
3305
    .capabilities= CODEC_CAP_DELAY,
3306
};
3307

    
3308
AVCodec mpeg2video_encoder = {
3309
    "mpeg2video",
3310
    CODEC_TYPE_VIDEO,
3311
    CODEC_ID_MPEG2VIDEO,
3312
    sizeof(MpegEncContext),
3313
    encode_init,
3314
    MPV_encode_picture,
3315
    MPV_encode_end,
3316
    .supported_framerates= ff_frame_rate_tab+1,
3317
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, -1},
3318
    .capabilities= CODEC_CAP_DELAY,
3319
};
3320
#endif
3321

    
3322
#ifdef HAVE_XVMC
3323
static int mpeg_mc_decode_init(AVCodecContext *avctx){
3324
    Mpeg1Context *s;
3325

    
3326
    if( avctx->thread_count > 1)
3327
        return -1;
3328
    if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
3329
        return -1;
3330
    if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){
3331
        dprintf(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
3332
    }
3333
    mpeg_decode_init(avctx);
3334
    s = avctx->priv_data;
3335

    
3336
    avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
3337
    avctx->xvmc_acceleration = 2;//2 - the blocks are packed!
3338

    
3339
    return 0;
3340
}
3341

    
3342
AVCodec mpeg_xvmc_decoder = {
3343
    "mpegvideo_xvmc",
3344
    CODEC_TYPE_VIDEO,
3345
    CODEC_ID_MPEG2VIDEO_XVMC,
3346
    sizeof(Mpeg1Context),
3347
    mpeg_mc_decode_init,
3348
    NULL,
3349
    mpeg_decode_end,
3350
    mpeg_decode_frame,
3351
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
3352
    .flush= ff_mpeg_flush,
3353
};
3354

    
3355
#endif
3356

    
3357
/* this is ugly i know, but the alternative is too make
3358
   hundreds of vars global and prefix them with ff_mpeg1_
3359
   which is far uglier. */
3360
#include "mdec.c"