Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ baaf3f46

History | View | Annotate | Download (94.5 KB)

1
/*
2
 * MPEG1 codec / MPEG2 decoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19
 
20
/**
21
 * @file mpeg12.c
22
 * MPEG1/2 codec
23
 */
24
 
25
//#define DEBUG
26
#include "avcodec.h"
27
#include "dsputil.h"
28
#include "mpegvideo.h"
29

    
30
#include "mpeg12data.h"
31

    
32
//#undef NDEBUG
33
//#include <assert.h>
34

    
35

    
36
/* Start codes. */
37
#define SEQ_END_CODE                0x000001b7
38
#define SEQ_START_CODE                0x000001b3
39
#define GOP_START_CODE                0x000001b8
40
#define PICTURE_START_CODE        0x00000100
41
#define SLICE_MIN_START_CODE        0x00000101
42
#define SLICE_MAX_START_CODE        0x000001af
43
#define EXT_START_CODE                0x000001b5
44
#define USER_START_CODE                0x000001b2
45

    
46
#define DC_VLC_BITS 9
47
#define MV_VLC_BITS 9
48
#define MBINCR_VLC_BITS 9
49
#define MB_PAT_VLC_BITS 9
50
#define MB_PTYPE_VLC_BITS 6
51
#define MB_BTYPE_VLC_BITS 6
52
#define TEX_VLC_BITS 9
53

    
54
#ifdef CONFIG_ENCODERS
55
static void mpeg1_encode_block(MpegEncContext *s, 
56
                         DCTELEM *block, 
57
                         int component);
58
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code);    // RAL: f_code parameter added
59
#endif //CONFIG_ENCODERS
60
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
61
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
62
                              DCTELEM *block, 
63
                              int n);
64
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
65
                              DCTELEM *block, 
66
                              int n);
67
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
68
                                        DCTELEM *block, 
69
                                        int n);
70
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
71
                                    DCTELEM *block, 
72
                                    int n);
73
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
74
static void exchange_uv(MpegEncContext *s);
75

    
76
#ifdef HAVE_XVMC
77
extern int XVMC_field_start(MpegEncContext *s, AVCodecContext *avctx);
78
extern int XVMC_field_end(MpegEncContext *s);
79
extern void XVMC_pack_pblocks(MpegEncContext *s,int cbp);
80
extern void XVMC_init_block(MpegEncContext *s);//set s->block
81
#endif
82

    
83
#ifdef CONFIG_ENCODERS
84
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
85
static uint8_t fcode_tab[MAX_MV*2+1];
86

    
87
static uint32_t uni_mpeg1_ac_vlc_bits[64*64*2];
88
static uint8_t  uni_mpeg1_ac_vlc_len [64*64*2];
89

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

    
94
static uint8_t mpeg1_index_run[2][64];
95
static int8_t mpeg1_max_level[2][64];
96
#endif //CONFIG_ENCODERS
97

    
98
static void init_2d_vlc_rl(RLTable *rl)
99
{
100
    int i;
101
    
102
    init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2, 
103
             &rl->table_vlc[0][1], 4, 2,
104
             &rl->table_vlc[0][0], 4, 2);
105

    
106
    
107
    rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
108
    for(i=0; i<rl->vlc.table_size; i++){
109
        int code= rl->vlc.table[i][0];
110
        int len = rl->vlc.table[i][1];
111
        int level, run;
112
    
113
        if(len==0){ // illegal code
114
            run= 65;
115
            level= MAX_LEVEL;
116
        }else if(len<0){ //more bits needed
117
            run= 0;
118
            level= code;
119
        }else{
120
            if(code==rl->n){ //esc
121
                run= 65;
122
                level= 0;
123
            }else if(code==rl->n+1){ //eob
124
                run= 0;
125
                level= 127;
126
            }else{
127
                run=   rl->table_run  [code] + 1;
128
                level= rl->table_level[code];
129
            }
130
        }
131
        rl->rl_vlc[0][i].len= len;
132
        rl->rl_vlc[0][i].level= level;
133
        rl->rl_vlc[0][i].run= run;
134
    }
135
}
136

    
137
#ifdef CONFIG_ENCODERS
138
static void init_uni_ac_vlc(RLTable *rl, uint32_t *uni_ac_vlc_bits, uint8_t *uni_ac_vlc_len){
139
    int i;
140

    
141
    for(i=0; i<128; i++){
142
        int level= i-64;
143
        int run;
144
        for(run=0; run<64; run++){
145
            int len, bits, code;
146
            
147
            int alevel= ABS(level);
148
            int sign= (level>>31)&1;
149

    
150
            if (alevel > rl->max_level[0][run])
151
                code= 111; /*rl->n*/
152
            else
153
                code= rl->index_run[0][run] + alevel - 1;
154

    
155
            if (code < 111 /* rl->n */) {
156
                    /* store the vlc & sign at once */
157
                len=   mpeg1_vlc[code][1]+1;
158
                bits= (mpeg1_vlc[code][0]<<1) + sign;
159
            } else {
160
                len=  mpeg1_vlc[111/*rl->n*/][1]+6;
161
                bits= mpeg1_vlc[111/*rl->n*/][0]<<6;
162

    
163
                bits|= run;
164
                if (alevel < 128) {
165
                    bits<<=8; len+=8;
166
                    bits|= level & 0xff;
167
                } else {
168
                    bits<<=16; len+=16;
169
                    bits|= level & 0xff;
170
                    if (level < 0) {
171
                        bits|= 0x8001 + level + 255;
172
                    } else {
173
                        bits|= level & 0xffff;
174
                    }
175
                }
176
            }
177

    
178
            uni_ac_vlc_bits[UNI_AC_ENC_INDEX(run, i)]= bits;
179
            uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len;
180
        }
181
    }
182
}
183

    
184
static void put_header(MpegEncContext *s, int header)
185
{
186
    align_put_bits(&s->pb);
187
    put_bits(&s->pb, 16, header>>16);
188
    put_bits(&s->pb, 16, header&0xFFFF);
189
}
190

    
191
/* put sequence header if needed */
192
static void mpeg1_encode_sequence_header(MpegEncContext *s)
193
{
194
        unsigned int vbv_buffer_size;
195
        unsigned int fps, v;
196
        int n, i;
197
        uint64_t time_code;
198
        float best_aspect_error= 1E10;
199
        float aspect_ratio= av_q2d(s->avctx->sample_aspect_ratio);
200
        int constraint_parameter_flag;
201
        
202
        if(aspect_ratio==0.0) aspect_ratio= 1.0; //pixel aspect 1:1 (VGA)
203
        
204
        if (s->current_picture.key_frame) {
205
            /* mpeg1 header repeated every gop */
206
            put_header(s, SEQ_START_CODE);
207
            
208
            /* search closest frame rate */
209
            {
210
                int i, dmin, d;
211
                s->frame_rate_index = 0;
212
                dmin = 0x7fffffff;
213
                for(i=1;i<14;i++) {
214
                    if(s->avctx->strict_std_compliance >= 0 && i>=9) break;
215
                     
216
                    d = abs(MPEG1_FRAME_RATE_BASE*(int64_t)s->avctx->frame_rate/s->avctx->frame_rate_base - frame_rate_tab[i]);
217
                    if (d < dmin) {
218
                        dmin = d;
219
                        s->frame_rate_index = i;
220
                    }
221
                }
222
            }
223
 
224
            put_bits(&s->pb, 12, s->width);
225
            put_bits(&s->pb, 12, s->height);
226
            
227
            for(i=1; i<15; i++){
228
                float error= aspect_ratio;
229
                if(s->codec_id == CODEC_ID_MPEG1VIDEO || i <=1)
230
                    error-= 1.0/mpeg1_aspect[i];
231
                else
232
                    error-= av_q2d(mpeg2_aspect[i])*s->height/s->width;
233
             
234
                error= ABS(error);
235
                
236
                if(error < best_aspect_error){
237
                    best_aspect_error= error;
238
                    s->aspect_ratio_info= i;
239
                }
240
            }
241
            
242
            put_bits(&s->pb, 4, s->aspect_ratio_info);
243
            put_bits(&s->pb, 4, s->frame_rate_index);
244
            
245
            if(s->avctx->rc_max_rate){
246
                v = (s->avctx->rc_max_rate + 399) / 400;
247
                if (v > 0x3ffff && s->codec_id == CODEC_ID_MPEG1VIDEO)
248
                    v = 0x3ffff;
249
            }else{
250
                v= 0x3FFFF;
251
            }
252

    
253
            if(s->avctx->rc_buffer_size)
254
                vbv_buffer_size = s->avctx->rc_buffer_size;
255
            else
256
                /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */
257
                vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
258
            vbv_buffer_size= (vbv_buffer_size + 16383) / 16384;
259

    
260
            put_bits(&s->pb, 18, v & 0x3FFFF);
261
            put_bits(&s->pb, 1, 1); /* marker */
262
            put_bits(&s->pb, 10, vbv_buffer_size & 0x3FF);
263

    
264
            constraint_parameter_flag= 
265
                s->width <= 768 && s->height <= 576 && 
266
                s->mb_width * s->mb_height <= 396 &&
267
                s->mb_width * s->mb_height * frame_rate_tab[s->frame_rate_index] <= MPEG1_FRAME_RATE_BASE*396*25 &&
268
                frame_rate_tab[s->frame_rate_index] <= MPEG1_FRAME_RATE_BASE*30 &&
269
                vbv_buffer_size <= 20 &&
270
                v <= 1856000/400 &&
271
                s->codec_id == CODEC_ID_MPEG1VIDEO;
272
                
273
            put_bits(&s->pb, 1, constraint_parameter_flag);
274
            
275
            ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
276
            ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
277

    
278
            if(s->codec_id == CODEC_ID_MPEG2VIDEO){
279
                put_header(s, EXT_START_CODE);
280
                put_bits(&s->pb, 4, 1); //seq ext
281
                put_bits(&s->pb, 1, 0); //esc
282
                put_bits(&s->pb, 3, 4); //profile
283
                put_bits(&s->pb, 4, 8); //level
284
                put_bits(&s->pb, 1, s->progressive_sequence);
285
                put_bits(&s->pb, 2, 1); //chroma format 4:2:0
286
                put_bits(&s->pb, 2, 0); //horizontal size ext
287
                put_bits(&s->pb, 2, 0); //vertical size ext
288
                put_bits(&s->pb, 12, v>>18); //bitrate ext
289
                put_bits(&s->pb, 1, 1); //marker
290
                put_bits(&s->pb, 8, vbv_buffer_size >>10); //vbv buffer ext
291
                put_bits(&s->pb, 1, s->low_delay);
292
                put_bits(&s->pb, 2, 0); // frame_rate_ext_n
293
                put_bits(&s->pb, 5, 0); // frame_rate_ext_d
294
            }
295
            
296
            put_header(s, GOP_START_CODE);
297
            put_bits(&s->pb, 1, 0); /* do drop frame */
298
            /* time code : we must convert from the real frame rate to a
299
               fake mpeg frame rate in case of low frame rate */
300
            fps = frame_rate_tab[s->frame_rate_index];
301
            time_code = (int64_t)s->fake_picture_number * MPEG1_FRAME_RATE_BASE;
302
            s->gop_picture_number = s->fake_picture_number;
303
            put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
304
            put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
305
            put_bits(&s->pb, 1, 1);
306
            put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
307
            put_bits(&s->pb, 6, (uint32_t)((time_code % fps) / MPEG1_FRAME_RATE_BASE));
308
            put_bits(&s->pb, 1, 0); /* closed gop */
309
            put_bits(&s->pb, 1, 0); /* broken link */
310
        }
311

    
312
        if (s->avctx->frame_rate < (24 * s->avctx->frame_rate_base) && s->picture_number > 0) {
313
            /* insert empty P pictures to slow down to the desired
314
               frame rate. Each fake pictures takes about 20 bytes */
315
            fps = frame_rate_tab[s->frame_rate_index];
316
            n = av_rescale((int64_t)s->picture_number * s->avctx->frame_rate_base, fps, s->avctx->frame_rate) / MPEG1_FRAME_RATE_BASE - 1;
317
            while (s->fake_picture_number < n) {
318
                mpeg1_skip_picture(s, s->fake_picture_number - 
319
                                   s->gop_picture_number); 
320
                s->fake_picture_number++;
321
            }
322

    
323
        }
324
}
325

    
326
static inline void encode_mb_skip_run(MpegEncContext *s, int run){
327
    while (run >= 33) {
328
        put_bits(&s->pb, 11, 0x008);
329
        run -= 33;
330
    }
331
    put_bits(&s->pb, mbAddrIncrTable[run][1], 
332
             mbAddrIncrTable[run][0]);
333
}
334

    
335
/* insert a fake P picture */
336
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)
337
{
338
    assert(s->codec_id == CODEC_ID_MPEG1VIDEO); // mpeg2 can do these repeat things
339

    
340
    /* mpeg1 picture header */
341
    put_header(s, PICTURE_START_CODE);
342
    /* temporal reference */
343
    put_bits(&s->pb, 10, pict_num & 0x3ff); 
344
    
345
    put_bits(&s->pb, 3, P_TYPE);
346
    put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
347
    
348
    put_bits(&s->pb, 1, 1); /* integer coordinates */
349
    put_bits(&s->pb, 3, 1); /* forward_f_code */
350
    
351
    put_bits(&s->pb, 1, 0); /* extra bit picture */
352
    
353
    /* only one slice */
354
    put_header(s, SLICE_MIN_START_CODE);
355
    put_bits(&s->pb, 5, 1); /* quantizer scale */
356
    put_bits(&s->pb, 1, 0); /* slice extra information */
357
    
358
    encode_mb_skip_run(s, 0);
359
    
360
    /* empty macroblock */
361
    put_bits(&s->pb, 3, 1); /* motion only */
362
    
363
    /* zero motion x & y */
364
    put_bits(&s->pb, 1, 1); 
365
    put_bits(&s->pb, 1, 1); 
366

    
367
    /* output a number of empty slice */
368
    encode_mb_skip_run(s, s->mb_width * s->mb_height - 2);
369
    
370
    /* empty macroblock */
371
    put_bits(&s->pb, 3, 1); /* motion only */
372
    
373
    /* zero motion x & y */
374
    put_bits(&s->pb, 1, 1); 
375
    put_bits(&s->pb, 1, 1); 
376
}
377
#endif //CONFIG_ENCODERS
378

    
379
static void common_init(MpegEncContext *s)
380
{
381
    s->y_dc_scale_table=
382
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
383
}
384

    
385
void ff_mpeg1_clean_buffers(MpegEncContext *s){
386
    s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
387
    s->last_dc[1] = s->last_dc[0];
388
    s->last_dc[2] = s->last_dc[0];
389
    memset(s->last_mv, 0, sizeof(s->last_mv));
390
}
391

    
392
#ifdef CONFIG_ENCODERS
393

    
394
void ff_mpeg1_encode_slice_header(MpegEncContext *s){
395
    put_header(s, SLICE_MIN_START_CODE + s->mb_y);
396
    put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
397
    put_bits(&s->pb, 1, 0); /* slice extra information */
398
}
399

    
400
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
401
{
402
    mpeg1_encode_sequence_header(s);
403

    
404
    /* mpeg1 picture header */
405
    put_header(s, PICTURE_START_CODE);
406
    /* temporal reference */
407

    
408
    // RAL: s->picture_number instead of s->fake_picture_number
409
    put_bits(&s->pb, 10, (s->picture_number - 
410
                          s->gop_picture_number) & 0x3ff); 
411
    s->fake_picture_number++;
412
    
413
    put_bits(&s->pb, 3, s->pict_type);
414

    
415
    s->vbv_delay_ptr= s->pb.buf + get_bit_count(&s->pb)/8;
416
    put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
417
    
418
    // RAL: Forward f_code also needed for B frames
419
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
420
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
421
        if(s->codec_id == CODEC_ID_MPEG1VIDEO)
422
            put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
423
        else
424
            put_bits(&s->pb, 3, 7); /* forward_f_code */
425
    }
426
    
427
    // RAL: Backward f_code necessary for B frames
428
    if (s->pict_type == B_TYPE) {
429
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
430
        if(s->codec_id == CODEC_ID_MPEG1VIDEO)
431
            put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
432
        else
433
            put_bits(&s->pb, 3, 7); /* backward_f_code */
434
    }
435

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

    
438
    s->frame_pred_frame_dct = 1;
439
    if(s->codec_id == CODEC_ID_MPEG2VIDEO){
440
        put_header(s, EXT_START_CODE);
441
        put_bits(&s->pb, 4, 8); //pic ext
442
        if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
443
            put_bits(&s->pb, 4, s->f_code);
444
            put_bits(&s->pb, 4, s->f_code);
445
        }else{
446
            put_bits(&s->pb, 8, 255);
447
        }
448
        if (s->pict_type == B_TYPE) {
449
            put_bits(&s->pb, 4, s->b_code);
450
            put_bits(&s->pb, 4, s->b_code);
451
        }else{
452
            put_bits(&s->pb, 8, 255);
453
        }
454
        put_bits(&s->pb, 2, s->intra_dc_precision);
455
        put_bits(&s->pb, 2, s->picture_structure= PICT_FRAME);
456
        if (s->progressive_sequence) {
457
            put_bits(&s->pb, 1, 0); /* no repeat */
458
        } else {
459
            put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
460
        }
461
        /* XXX: optimize the generation of this flag with entropy
462
           measures */
463
        s->frame_pred_frame_dct = s->progressive_sequence;
464
        
465
        put_bits(&s->pb, 1, s->frame_pred_frame_dct);
466
        put_bits(&s->pb, 1, s->concealment_motion_vectors);
467
        put_bits(&s->pb, 1, s->q_scale_type);
468
        put_bits(&s->pb, 1, s->intra_vlc_format);
469
        put_bits(&s->pb, 1, s->alternate_scan);
470
        put_bits(&s->pb, 1, s->repeat_first_field);
471
        put_bits(&s->pb, 1, s->chroma_420_type=1);
472
        s->progressive_frame = s->progressive_sequence;
473
        put_bits(&s->pb, 1, s->progressive_frame);
474
        put_bits(&s->pb, 1, 0); //composite_display_flag
475
    }
476
    if(s->flags & CODEC_FLAG_SVCD_SCAN_OFFSET){
477
        int i;
478

    
479
        put_header(s, USER_START_CODE);
480
        for(i=0; i<sizeof(svcd_scan_offset_placeholder); i++){
481
            put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
482
        }
483
    }
484
    
485
    s->mb_y=0;
486
    ff_mpeg1_encode_slice_header(s);
487
}
488

    
489
static inline void put_mb_modes(MpegEncContext *s, int n, int bits, 
490
                                int has_mv, int field_motion)
491
{
492
    put_bits(&s->pb, n, bits);
493
    if (!s->frame_pred_frame_dct) {
494
        if (has_mv) 
495
            put_bits(&s->pb, 2, 2 - field_motion); /* motion_type: frame/field */
496
        put_bits(&s->pb, 1, s->interlaced_dct);
497
    }
498
}
499

    
500
void mpeg1_encode_mb(MpegEncContext *s,
501
                     DCTELEM block[6][64],
502
                     int motion_x, int motion_y)
503
{
504
    int i, cbp;
505
    const int mb_x = s->mb_x;
506
    const int mb_y = s->mb_y;
507
    const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
508

    
509
    /* compute cbp */
510
    cbp = 0;
511
    for(i=0;i<6;i++) {
512
        if (s->block_last_index[i] >= 0)
513
            cbp |= 1 << (5 - i);
514
    }
515
    
516
    if (cbp == 0 && !first_mb && (mb_x != s->mb_width - 1 || (mb_y != s->mb_height - 1 && s->codec_id == CODEC_ID_MPEG1VIDEO)) && 
517
        ((s->pict_type == P_TYPE && s->mv_type == MV_TYPE_16X16 && (motion_x | motion_y) == 0) ||
518
        (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) |
519
        ((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))) {
520
        s->mb_skip_run++;
521
        s->qscale -= s->dquant;
522
        s->skip_count++;
523
        s->misc_bits++;
524
        s->last_bits++;
525
        if(s->pict_type == P_TYPE){
526
            s->last_mv[0][1][0]= s->last_mv[0][0][0]= 
527
            s->last_mv[0][1][1]= s->last_mv[0][0][1]= 0;
528
        }
529
    } else {
530
        if(first_mb){
531
            assert(s->mb_skip_run == 0);
532
            encode_mb_skip_run(s, s->mb_x);
533
        }else{
534
            encode_mb_skip_run(s, s->mb_skip_run);
535
        }
536
        
537
        if (s->pict_type == I_TYPE) {
538
            if(s->dquant && cbp){
539
                put_mb_modes(s, 2, 1, 0, 0); /* macroblock_type : macroblock_quant = 1 */
540
                put_bits(&s->pb, 5, s->qscale);
541
            }else{
542
                put_mb_modes(s, 1, 1, 0, 0); /* macroblock_type : macroblock_quant = 0 */
543
                s->qscale -= s->dquant;
544
            }
545
            s->misc_bits+= get_bits_diff(s);
546
            s->i_count++;
547
        } else if (s->mb_intra) {
548
            if(s->dquant && cbp){
549
                put_mb_modes(s, 6, 0x01, 0, 0);
550
                put_bits(&s->pb, 5, s->qscale);
551
            }else{
552
                put_mb_modes(s, 5, 0x03, 0, 0);
553
                s->qscale -= s->dquant;
554
            }
555
            s->misc_bits+= get_bits_diff(s);
556
            s->i_count++;
557
            memset(s->last_mv, 0, sizeof(s->last_mv));
558
        } else if (s->pict_type == P_TYPE) { 
559
            if(s->mv_type == MV_TYPE_16X16){
560
                if (cbp != 0) {
561
                    if ((motion_x|motion_y) == 0) {
562
                        if(s->dquant){
563
                            put_mb_modes(s, 5, 1, 0, 0); /* macroblock_pattern & quant */
564
                            put_bits(&s->pb, 5, s->qscale);
565
                        }else{
566
                            put_mb_modes(s, 2, 1, 0, 0); /* macroblock_pattern only */
567
                        }
568
                        s->misc_bits+= get_bits_diff(s);
569
                    } else {
570
                        if(s->dquant){
571
                            put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */
572
                            put_bits(&s->pb, 5, s->qscale);
573
                        }else{
574
                            put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */
575
                        }
576
                        s->misc_bits+= get_bits_diff(s);
577
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
578
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
579
                        s->mv_bits+= get_bits_diff(s);
580
                    }
581
                } else {
582
                    put_bits(&s->pb, 3, 1); /* motion only */
583
                    if (!s->frame_pred_frame_dct)
584
                        put_bits(&s->pb, 2, 2); /* motion_type: frame */
585
                    s->misc_bits+= get_bits_diff(s);
586
                    mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
587
                    mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
588
                    s->qscale -= s->dquant;
589
                    s->mv_bits+= get_bits_diff(s);
590
                }
591
                s->last_mv[0][1][0]= s->last_mv[0][0][0]= motion_x;
592
                s->last_mv[0][1][1]= s->last_mv[0][0][1]= motion_y;
593
            }else{
594
                assert(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD);
595

    
596
                if (cbp) {
597
                    if(s->dquant){
598
                        put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
599
                        put_bits(&s->pb, 5, s->qscale);
600
                    }else{
601
                        put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
602
                    }
603
                } else {
604
                    put_bits(&s->pb, 3, 1); /* motion only */
605
                    put_bits(&s->pb, 2, 1); /* motion_type: field */
606
                    s->qscale -= s->dquant;
607
                }
608
                s->misc_bits+= get_bits_diff(s);
609
                for(i=0; i<2; i++){
610
                    put_bits(&s->pb, 1, s->field_select[0][i]);
611
                    mpeg1_encode_motion(s, s->mv[0][i][0] -  s->last_mv[0][i][0]    , s->f_code);
612
                    mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code);
613
                    s->last_mv[0][i][0]=   s->mv[0][i][0];
614
                    s->last_mv[0][i][1]= 2*s->mv[0][i][1];
615
                }
616
                s->mv_bits+= get_bits_diff(s);
617
            }
618
            if(cbp)
619
                put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
620
            s->f_count++;
621
        } else{  
622
            static const int mb_type_len[4]={0,3,4,2}; //bak,for,bi
623

    
624
            if(s->mv_type == MV_TYPE_16X16){
625
                if (cbp){    // With coded bloc pattern
626
                    if (s->dquant) {
627
                        if(s->mv_dir == MV_DIR_FORWARD)
628
                            put_mb_modes(s, 6, 3, 1, 0);
629
                        else
630
                            put_mb_modes(s, mb_type_len[s->mv_dir]+3, 2, 1, 0);
631
                        put_bits(&s->pb, 5, s->qscale);
632
                    } else {
633
                        put_mb_modes(s, mb_type_len[s->mv_dir], 3, 1, 0);
634
                    }
635
                }else{    // No coded bloc pattern
636
                    put_bits(&s->pb, mb_type_len[s->mv_dir], 2);
637
                    if (!s->frame_pred_frame_dct)
638
                        put_bits(&s->pb, 2, 2); /* motion_type: frame */
639
                    s->qscale -= s->dquant;
640
                }
641
                s->misc_bits += get_bits_diff(s);
642
                if (s->mv_dir&MV_DIR_FORWARD){
643
                    mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code); 
644
                    mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); 
645
                    s->last_mv[0][0][0]=s->last_mv[0][1][0]= s->mv[0][0][0];
646
                    s->last_mv[0][0][1]=s->last_mv[0][1][1]= s->mv[0][0][1];
647
                    s->f_count++;
648
                }
649
                if (s->mv_dir&MV_DIR_BACKWARD){
650
                    mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code); 
651
                    mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); 
652
                    s->last_mv[1][0][0]=s->last_mv[1][1][0]= s->mv[1][0][0];
653
                    s->last_mv[1][0][1]=s->last_mv[1][1][1]= s->mv[1][0][1];
654
                    s->b_count++;
655
                }
656
            }else{
657
                assert(s->mv_type == MV_TYPE_FIELD);
658
                assert(!s->frame_pred_frame_dct);
659
                if (cbp){    // With coded bloc pattern
660
                    if (s->dquant) {
661
                        if(s->mv_dir == MV_DIR_FORWARD)
662
                            put_mb_modes(s, 6, 3, 1, 1);
663
                        else
664
                            put_mb_modes(s, mb_type_len[s->mv_dir]+3, 2, 1, 1);
665
                        put_bits(&s->pb, 5, s->qscale);
666
                    } else {
667
                        put_mb_modes(s, mb_type_len[s->mv_dir], 3, 1, 1);
668
                    }
669
                }else{    // No coded bloc pattern
670
                    put_bits(&s->pb, mb_type_len[s->mv_dir], 2);
671
                    put_bits(&s->pb, 2, 1); /* motion_type: field */
672
                    s->qscale -= s->dquant;
673
                }
674
                s->misc_bits += get_bits_diff(s);
675
                if (s->mv_dir&MV_DIR_FORWARD){
676
                    for(i=0; i<2; i++){
677
                        put_bits(&s->pb, 1, s->field_select[0][i]);
678
                        mpeg1_encode_motion(s, s->mv[0][i][0] -  s->last_mv[0][i][0]    , s->f_code);
679
                        mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code);
680
                        s->last_mv[0][i][0]=   s->mv[0][i][0];
681
                        s->last_mv[0][i][1]= 2*s->mv[0][i][1];
682
                    }
683
                    s->f_count++;
684
                }
685
                if (s->mv_dir&MV_DIR_BACKWARD){
686
                    for(i=0; i<2; i++){
687
                        put_bits(&s->pb, 1, s->field_select[1][i]);
688
                        mpeg1_encode_motion(s, s->mv[1][i][0] -  s->last_mv[1][i][0]    , s->b_code);
689
                        mpeg1_encode_motion(s, s->mv[1][i][1] - (s->last_mv[1][i][1]>>1), s->b_code);
690
                        s->last_mv[1][i][0]=   s->mv[1][i][0];
691
                        s->last_mv[1][i][1]= 2*s->mv[1][i][1];
692
                    }
693
                    s->b_count++;
694
                }
695
            }
696
            s->mv_bits += get_bits_diff(s);
697
            if(cbp)
698
                put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
699
        }
700
        for(i=0;i<6;i++) {
701
            if (cbp & (1 << (5 - i))) {
702
                mpeg1_encode_block(s, block[i], i);
703
            }
704
        }
705
        s->mb_skip_run = 0;
706
        if(s->mb_intra)
707
            s->i_tex_bits+= get_bits_diff(s);
708
        else
709
            s->p_tex_bits+= get_bits_diff(s);
710
    }
711
}
712

    
713
// RAL: Parameter added: f_or_b_code
714
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
715
{
716
    int code, bit_size, l, m, bits, range, sign;
717

    
718
    if (val == 0) {
719
        /* zero vector */
720
        code = 0;
721
        put_bits(&s->pb,
722
                 mbMotionVectorTable[0][1], 
723
                 mbMotionVectorTable[0][0]); 
724
    } else {
725
        bit_size = f_or_b_code - 1;
726
        range = 1 << bit_size;
727
        /* modulo encoding */
728
        l = 16 * range;
729
        m = 2 * l;
730
        if (val < -l) {
731
            val += m;
732
        } else if (val >= l) {
733
            val -= m;
734
        }
735

    
736
        if (val >= 0) {
737
            val--;
738
            code = (val >> bit_size) + 1;
739
            bits = val & (range - 1);
740
            sign = 0;
741
        } else {
742
            val = -val;
743
            val--;
744
            code = (val >> bit_size) + 1;
745
            bits = val & (range - 1);
746
            sign = 1;
747
        }
748

    
749
        assert(code > 0 && code <= 16);
750

    
751
        put_bits(&s->pb,
752
                 mbMotionVectorTable[code][1], 
753
                 mbMotionVectorTable[code][0]); 
754

    
755
        put_bits(&s->pb, 1, sign);
756
        if (bit_size > 0) {
757
            put_bits(&s->pb, bit_size, bits);
758
        }
759
    }
760
}
761

    
762
void ff_mpeg1_encode_init(MpegEncContext *s)
763
{
764
    static int done=0;
765

    
766
    common_init(s);
767

    
768
    if(!done){
769
        int f_code;
770
        int mv;
771
        int i;
772

    
773
        done=1;
774
        init_rl(&rl_mpeg1);
775

    
776
        for(i=0; i<64; i++)
777
        {
778
                mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
779
                mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
780
        }
781
        
782
        init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_bits, uni_mpeg1_ac_vlc_len);
783

    
784
        /* build unified dc encoding tables */
785
        for(i=-255; i<256; i++)
786
        {
787
                int adiff, index;
788
                int bits, code;
789
                int diff=i;
790

    
791
                adiff = ABS(diff);
792
                if(diff<0) diff--;
793
                index = vlc_dc_table[adiff];
794

    
795
                bits= vlc_dc_lum_bits[index] + index;
796
                code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
797
                mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
798
                
799
                bits= vlc_dc_chroma_bits[index] + index;
800
                code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
801
                mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
802
        }
803

    
804
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
805

    
806
        for(f_code=1; f_code<=MAX_FCODE; f_code++){
807
            for(mv=-MAX_MV; mv<=MAX_MV; mv++){
808
                int len;
809

    
810
                if(mv==0) len= mbMotionVectorTable[0][1];
811
                else{
812
                    int val, bit_size, range, code;
813

    
814
                    bit_size = s->f_code - 1;
815
                    range = 1 << bit_size;
816

    
817
                    val=mv;
818
                    if (val < 0) 
819
                        val = -val;
820
                    val--;
821
                    code = (val >> bit_size) + 1;
822
                    if(code<17){
823
                        len= mbMotionVectorTable[code][1] + 1 + bit_size;
824
                    }else{
825
                        len= mbMotionVectorTable[16][1] + 2 + bit_size;
826
                    }
827
                }
828

    
829
                mv_penalty[f_code][mv+MAX_MV]= len;
830
            }
831
        }
832
        
833

    
834
        for(f_code=MAX_FCODE; f_code>0; f_code--){
835
            for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
836
                fcode_tab[mv+MAX_MV]= f_code;
837
            }
838
        }
839
    }
840
    s->me.mv_penalty= mv_penalty;
841
    s->fcode_tab= fcode_tab;
842
    if(s->codec_id == CODEC_ID_MPEG1VIDEO){
843
        s->min_qcoeff=-255;
844
        s->max_qcoeff= 255;
845
    }else{
846
        s->min_qcoeff=-2047;
847
        s->max_qcoeff= 2047;
848
    }
849
    s->intra_ac_vlc_length=
850
    s->inter_ac_vlc_length=
851
    s->intra_ac_vlc_last_length=
852
    s->inter_ac_vlc_last_length= uni_mpeg1_ac_vlc_len;
853
}
854

    
855
static inline void encode_dc(MpegEncContext *s, int diff, int component)
856
{
857
    if (component == 0) {
858
        put_bits(
859
            &s->pb, 
860
            mpeg1_lum_dc_uni[diff+255]&0xFF,
861
            mpeg1_lum_dc_uni[diff+255]>>8);
862
    } else {
863
        put_bits(
864
            &s->pb, 
865
            mpeg1_chr_dc_uni[diff+255]&0xFF,
866
            mpeg1_chr_dc_uni[diff+255]>>8);
867
    }
868
}
869

    
870
static void mpeg1_encode_block(MpegEncContext *s, 
871
                               DCTELEM *block, 
872
                               int n)
873
{
874
    int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
875
    int code, component;
876
//    RLTable *rl = &rl_mpeg1;
877

    
878
    last_index = s->block_last_index[n];
879

    
880
    /* DC coef */
881
    if (s->mb_intra) {
882
        component = (n <= 3 ? 0 : n - 4 + 1);
883
        dc = block[0]; /* overflow is impossible */
884
        diff = dc - s->last_dc[component];
885
        encode_dc(s, diff, component);
886
        s->last_dc[component] = dc;
887
        i = 1;
888
/*
889
        if (s->intra_vlc_format)
890
            rl = &rl_mpeg2;
891
        else
892
            rl = &rl_mpeg1;
893
*/
894
    } else {
895
        /* encode the first coefficient : needs to be done here because
896
           it is handled slightly differently */
897
        level = block[0];
898
        if (abs(level) == 1) {
899
                code = ((uint32_t)level >> 31); /* the sign bit */
900
                put_bits(&s->pb, 2, code | 0x02);
901
                i = 1;
902
        } else {
903
            i = 0;
904
            last_non_zero = -1;
905
            goto next_coef;
906
        }
907
    }
908

    
909
    /* now quantify & encode AC coefs */
910
    last_non_zero = i - 1;
911

    
912
    for(;i<=last_index;i++) {
913
        j = s->intra_scantable.permutated[i];
914
        level = block[j];
915
    next_coef:
916
#if 0
917
        if (level != 0)
918
            dprintf("level[%d]=%d\n", i, level);
919
#endif            
920
        /* encode using VLC */
921
        if (level != 0) {
922
            run = i - last_non_zero - 1;
923
            
924
            alevel= level;
925
            MASK_ABS(sign, alevel)
926
            sign&=1;
927

    
928
//            code = get_rl_index(rl, 0, run, alevel);
929
            if (alevel <= mpeg1_max_level[0][run]){
930
                code= mpeg1_index_run[0][run] + alevel - 1;
931
                    /* store the vlc & sign at once */
932
                put_bits(&s->pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign);
933
            } else {
934
                /* escape seems to be pretty rare <5% so i dont optimize it */
935
                put_bits(&s->pb, mpeg1_vlc[111/*rl->n*/][1], mpeg1_vlc[111/*rl->n*/][0]);
936
                /* escape: only clip in this case */
937
                put_bits(&s->pb, 6, run);
938
                if(s->codec_id == CODEC_ID_MPEG1VIDEO){
939
                    if (alevel < 128) {
940
                        put_bits(&s->pb, 8, level & 0xff);
941
                    } else {
942
                        if (level < 0) {
943
                            put_bits(&s->pb, 16, 0x8001 + level + 255);
944
                        } else {
945
                            put_bits(&s->pb, 16, level & 0xffff);
946
                        }
947
                    }
948
                }else{
949
                    put_bits(&s->pb, 12, level & 0xfff);
950
                }
951
            }
952
            last_non_zero = i;
953
        }
954
    }
955
    /* end of block */
956
    put_bits(&s->pb, 2, 0x2);
957
}
958
#endif //CONFIG_ENCODERS
959

    
960
/******************************************/
961
/* decoding */
962

    
963
static VLC dc_lum_vlc;
964
static VLC dc_chroma_vlc;
965
static VLC mv_vlc;
966
static VLC mbincr_vlc;
967
static VLC mb_ptype_vlc;
968
static VLC mb_btype_vlc;
969
static VLC mb_pat_vlc;
970

    
971
static void init_vlcs()
972
{
973
    static int done = 0;
974

    
975
    if (!done) {
976
        done = 1;
977

    
978
        init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12, 
979
                 vlc_dc_lum_bits, 1, 1,
980
                 vlc_dc_lum_code, 2, 2);
981
        init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12, 
982
                 vlc_dc_chroma_bits, 1, 1,
983
                 vlc_dc_chroma_code, 2, 2);
984
        init_vlc(&mv_vlc, MV_VLC_BITS, 17, 
985
                 &mbMotionVectorTable[0][1], 2, 1,
986
                 &mbMotionVectorTable[0][0], 2, 1);
987
        init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36, 
988
                 &mbAddrIncrTable[0][1], 2, 1,
989
                 &mbAddrIncrTable[0][0], 2, 1);
990
        init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63, 
991
                 &mbPatTable[0][1], 2, 1,
992
                 &mbPatTable[0][0], 2, 1);
993
        
994
        init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7, 
995
                 &table_mb_ptype[0][1], 2, 1,
996
                 &table_mb_ptype[0][0], 2, 1);
997
        init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11, 
998
                 &table_mb_btype[0][1], 2, 1,
999
                 &table_mb_btype[0][0], 2, 1);
1000
        init_rl(&rl_mpeg1);
1001
        init_rl(&rl_mpeg2);
1002

    
1003
        init_2d_vlc_rl(&rl_mpeg1);
1004
        init_2d_vlc_rl(&rl_mpeg2);
1005
    }
1006
}
1007

    
1008
static inline int get_dmv(MpegEncContext *s)
1009
{
1010
    if(get_bits1(&s->gb)) 
1011
        return 1 - (get_bits1(&s->gb) << 1);
1012
    else
1013
        return 0;
1014
}
1015

    
1016
static inline int get_qscale(MpegEncContext *s)
1017
{
1018
    int qscale = get_bits(&s->gb, 5);
1019
    if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1020
        if (s->q_scale_type) {
1021
            return non_linear_qscale[qscale];
1022
        } else {
1023
            return qscale << 1;
1024
        }
1025
    }
1026
    return qscale;
1027
}
1028

    
1029
/* motion type (for mpeg2) */
1030
#define MT_FIELD 1
1031
#define MT_FRAME 2
1032
#define MT_16X8  2
1033
#define MT_DMV   3
1034

    
1035
static int mpeg_decode_mb(MpegEncContext *s,
1036
                          DCTELEM block[6][64])
1037
{
1038
    int i, j, k, cbp, val, mb_type, motion_type;
1039
    
1040
    dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
1041

    
1042
    assert(s->mb_skiped==0);
1043

    
1044
    if (s->mb_skip_run-- != 0) {
1045
        if(s->pict_type == I_TYPE){
1046
            av_log(s->avctx, AV_LOG_ERROR, "skiped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1047
            return -1;
1048
        }
1049
    
1050
        /* skip mb */
1051
        s->mb_intra = 0;
1052
        for(i=0;i<6;i++)
1053
            s->block_last_index[i] = -1;
1054
        s->mv_type = MV_TYPE_16X16;
1055
        if (s->pict_type == P_TYPE) {
1056
            /* if P type, zero motion vector is implied */
1057
            s->mv_dir = MV_DIR_FORWARD;
1058
            s->mv[0][0][0] = s->mv[0][0][1] = 0;
1059
            s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1060
            s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1061
            s->mb_skiped = 1;
1062
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1063
        } else {
1064
            /* if B type, reuse previous vectors and directions */
1065
            s->mv[0][0][0] = s->last_mv[0][0][0];
1066
            s->mv[0][0][1] = s->last_mv[0][0][1];
1067
            s->mv[1][0][0] = s->last_mv[1][0][0];
1068
            s->mv[1][0][1] = s->last_mv[1][0][1];
1069

    
1070
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= 
1071
                s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1] | MB_TYPE_SKIP;
1072
//            assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
1073

    
1074
            if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0) 
1075
                s->mb_skiped = 1;
1076
        }
1077

    
1078
        return 0;
1079
    }
1080

    
1081
    switch(s->pict_type) {
1082
    default:
1083
    case I_TYPE:
1084
        if (get_bits1(&s->gb) == 0) {
1085
            if (get_bits1(&s->gb) == 0){
1086
                av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
1087
                return -1;
1088
            }
1089
            mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
1090
        } else {
1091
            mb_type = MB_TYPE_INTRA;
1092
        }
1093
        break;
1094
    case P_TYPE:
1095
        mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
1096
        if (mb_type < 0){
1097
            av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
1098
            return -1;
1099
        }
1100
        mb_type = ptype2mb_type[ mb_type ];
1101
        break;
1102
    case B_TYPE:
1103
        mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
1104
        if (mb_type < 0){
1105
            av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
1106
            return -1;
1107
        }
1108
        mb_type = btype2mb_type[ mb_type ];
1109
        break;
1110
    }
1111
    dprintf("mb_type=%x\n", mb_type);
1112
//    motion_type = 0; /* avoid warning */
1113
    if (IS_INTRA(mb_type)) {
1114
        /* compute dct type */
1115
        if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1116
            !s->frame_pred_frame_dct) {
1117
            s->interlaced_dct = get_bits1(&s->gb);
1118
        }
1119

    
1120
        if (IS_QUANT(mb_type))
1121
            s->qscale = get_qscale(s);
1122
        
1123
        if (s->concealment_motion_vectors) {
1124
            /* just parse them */
1125
            if (s->picture_structure != PICT_FRAME) 
1126
                skip_bits1(&s->gb); /* field select */
1127
            
1128
            s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] = 
1129
                mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
1130
            s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] = 
1131
                mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
1132

    
1133
            skip_bits1(&s->gb); /* marker */
1134
        }else
1135
            memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
1136
        s->mb_intra = 1;
1137
#ifdef HAVE_XVMC
1138
        //one 1 we memcpy blocks in xvmcvideo
1139
        if(s->avctx->xvmc_acceleration > 1){
1140
            XVMC_pack_pblocks(s,-1);//inter are always full blocks
1141
            if(s->swap_uv){
1142
                exchange_uv(s);
1143
            }
1144
        }
1145
#endif
1146

    
1147
        if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1148
            for(i=0;i<6;i++) {
1149
                if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0)
1150
                    return -1;
1151
            }
1152
        } else {
1153
            for(i=0;i<6;i++) {
1154
                if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 0)
1155
                    return -1;
1156
            }
1157
        }
1158
    } else {
1159
        if (mb_type & MB_TYPE_ZERO_MV){
1160
            assert(mb_type & MB_TYPE_CBP);
1161

    
1162
            /* compute dct type */
1163
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1164
                !s->frame_pred_frame_dct) {
1165
                s->interlaced_dct = get_bits1(&s->gb);
1166
            }
1167

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

    
1171
            s->mv_dir = MV_DIR_FORWARD;
1172
            s->mv_type = MV_TYPE_16X16;
1173
            s->last_mv[0][0][0] = 0;
1174
            s->last_mv[0][0][1] = 0;
1175
            s->last_mv[0][1][0] = 0;
1176
            s->last_mv[0][1][1] = 0;
1177
            s->mv[0][0][0] = 0;
1178
            s->mv[0][0][1] = 0;
1179
        }else{
1180
            assert(mb_type & MB_TYPE_L0L1);
1181
//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
1182
            /* get additionnal motion vector type */
1183
            if (s->frame_pred_frame_dct) 
1184
                motion_type = MT_FRAME;
1185
            else{
1186
                motion_type = get_bits(&s->gb, 2);
1187
            }
1188

    
1189
            /* compute dct type */
1190
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1191
                !s->frame_pred_frame_dct && HAS_CBP(mb_type)) {
1192
                s->interlaced_dct = get_bits1(&s->gb);
1193
            }
1194

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

    
1198
            /* motion vectors */
1199
            s->mv_dir = 0;
1200
            for(i=0;i<2;i++) {
1201
                if (USES_LIST(mb_type, i)) {
1202
                    s->mv_dir |= (MV_DIR_FORWARD >> i);
1203
                    dprintf("motion_type=%d\n", motion_type);
1204
                    switch(motion_type) {
1205
                    case MT_FRAME: /* or MT_16X8 */
1206
                        if (s->picture_structure == PICT_FRAME) {
1207
                            /* MT_FRAME */
1208
                            mb_type |= MB_TYPE_16x16; 
1209
                            s->mv_type = MV_TYPE_16X16;
1210
                            s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] = 
1211
                                mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
1212
                            s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] = 
1213
                                mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
1214
                            /* full_pel: only for mpeg1 */
1215
                            if (s->full_pel[i]){
1216
                                s->mv[i][0][0] <<= 1;
1217
                                s->mv[i][0][1] <<= 1;
1218
                            }
1219
                        } else {
1220
                            /* MT_16X8 */
1221
                            mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; 
1222
                            s->mv_type = MV_TYPE_16X8;
1223
                            for(j=0;j<2;j++) {
1224
                                s->field_select[i][j] = get_bits1(&s->gb);
1225
                                for(k=0;k<2;k++) {
1226
                                    val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1227
                                                             s->last_mv[i][j][k]);
1228
                                    s->last_mv[i][j][k] = val;
1229
                                    s->mv[i][j][k] = val;
1230
                                }
1231
                            }
1232
                        }
1233
                        break;
1234
                    case MT_FIELD:
1235
                        s->mv_type = MV_TYPE_FIELD;
1236
                        if (s->picture_structure == PICT_FRAME) {
1237
                            mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; 
1238
                            for(j=0;j<2;j++) {
1239
                                s->field_select[i][j] = get_bits1(&s->gb);
1240
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1241
                                                         s->last_mv[i][j][0]);
1242
                                s->last_mv[i][j][0] = val;
1243
                                s->mv[i][j][0] = val;
1244
                                dprintf("fmx=%d\n", val);
1245
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1246
                                                         s->last_mv[i][j][1] >> 1);
1247
                                s->last_mv[i][j][1] = val << 1;
1248
                                s->mv[i][j][1] = val;
1249
                                dprintf("fmy=%d\n", val);
1250
                            }
1251
                        } else {
1252
                            mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED; 
1253
                            s->field_select[i][0] = get_bits1(&s->gb);
1254
                            for(k=0;k<2;k++) {
1255
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1256
                                                         s->last_mv[i][0][k]);
1257
                                s->last_mv[i][0][k] = val;
1258
                                s->last_mv[i][1][k] = val;
1259
                                s->mv[i][0][k] = val;
1260
                            }
1261
                        }
1262
                        break;
1263
                    case MT_DMV:
1264
                        {
1265
                            int dmx, dmy, mx, my, m;
1266

    
1267
                            mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 
1268
                                                    s->last_mv[i][0][0]);
1269
                            s->last_mv[i][0][0] = mx;
1270
                            s->last_mv[i][1][0] = mx;
1271
                            dmx = get_dmv(s);
1272
                            my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 
1273
                                                    s->last_mv[i][0][1] >> 1);
1274
                            dmy = get_dmv(s);
1275
                            s->mv_type = MV_TYPE_DMV;
1276

    
1277

    
1278
                            s->last_mv[i][0][1] = my<<1;
1279
                            s->last_mv[i][1][1] = my<<1;
1280

    
1281
                            s->mv[i][0][0] = mx;
1282
                            s->mv[i][0][1] = my;
1283
                            s->mv[i][1][0] = mx;//not used
1284
                            s->mv[i][1][1] = my;//not used
1285

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

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

    
1292
                                /* top -> top pred */
1293
                                s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1294
                                s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1295
                                m = 4 - m;
1296
                                s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1297
                                s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1298
                            } else {
1299
                                mb_type |= MB_TYPE_16x16;
1300

    
1301
                                s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
1302
                                s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
1303
                                if(s->picture_structure == PICT_TOP_FIELD)
1304
                                    s->mv[i][2][1]--;
1305
                                else 
1306
                                    s->mv[i][2][1]++;
1307
                            }
1308
                        }
1309
                        break;
1310
                    default:
1311
                        av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
1312
                        return -1;
1313
                    }
1314
                }
1315
            }
1316
        }
1317
        
1318
        s->mb_intra = 0;
1319

    
1320
        if (HAS_CBP(mb_type)) {
1321
            cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1322
            if (cbp < 0){
1323
                av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
1324
                return -1;
1325
            }
1326
            cbp++;
1327

    
1328
#ifdef HAVE_XVMC
1329
            //on 1 we memcpy blocks in xvmcvideo
1330
            if(s->avctx->xvmc_acceleration > 1){
1331
                XVMC_pack_pblocks(s,cbp);
1332
                if(s->swap_uv){
1333
                    exchange_uv(s);
1334
                }
1335
            }    
1336
#endif
1337

    
1338
            if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1339
                for(i=0;i<6;i++) {
1340
                    if (cbp & 32) {
1341
                        if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
1342
                            return -1;
1343
                    } else {
1344
                        s->block_last_index[i] = -1;
1345
                    }
1346
                    cbp+=cbp;
1347
                }
1348
            } else {
1349
                for(i=0;i<6;i++) {
1350
                    if (cbp & 32) {
1351
                        if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 0)
1352
                            return -1;
1353
                    } else {
1354
                        s->block_last_index[i] = -1;
1355
                    }
1356
                    cbp+=cbp;
1357
                }
1358
            }
1359
        }else{
1360
            for(i=0;i<6;i++)
1361
                s->block_last_index[i] = -1;
1362
        }
1363
    }
1364

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

    
1367
    return 0;
1368
}
1369

    
1370
/* as h263, but only 17 codes */
1371
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
1372
{
1373
    int code, sign, val, l, shift;
1374

    
1375
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
1376
    if (code == 0) {
1377
        return pred;
1378
    }
1379
    if (code < 0) {
1380
        return 0xffff;
1381
    }
1382

    
1383
    sign = get_bits1(&s->gb);
1384
    shift = fcode - 1;
1385
    val = code;
1386
    if (shift) {
1387
        val = (val - 1) << shift;
1388
        val |= get_bits(&s->gb, shift);
1389
        val++;
1390
    }
1391
    if (sign)
1392
        val = -val;
1393
    val += pred;
1394
    
1395
    /* modulo decoding */
1396
    l = 1 << (shift+4);
1397
    val = ((val + l)&(l*2-1)) - l;
1398
    return val;
1399
}
1400

    
1401
static inline int decode_dc(GetBitContext *gb, int component)
1402
{
1403
    int code, diff;
1404

    
1405
    if (component == 0) {
1406
        code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1407
    } else {
1408
        code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1409
    }
1410
    if (code < 0){
1411
        av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
1412
        return 0xffff;
1413
    }
1414
    if (code == 0) {
1415
        diff = 0;
1416
    } else {
1417
        diff = get_xbits(gb, code);
1418
    }
1419
    return diff;
1420
}
1421

    
1422
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
1423
                               DCTELEM *block, 
1424
                               int n)
1425
{
1426
    int level, dc, diff, i, j, run;
1427
    int component;
1428
    RLTable *rl = &rl_mpeg1;
1429
    uint8_t * const scantable= s->intra_scantable.permutated;
1430
    const uint16_t *quant_matrix= s->intra_matrix;
1431
    const int qscale= s->qscale;
1432

    
1433
    /* DC coef */
1434
    component = (n <= 3 ? 0 : n - 4 + 1);
1435
    diff = decode_dc(&s->gb, component);
1436
    if (diff >= 0xffff)
1437
        return -1;
1438
    dc = s->last_dc[component];
1439
    dc += diff;
1440
    s->last_dc[component] = dc;
1441
    block[0] = dc<<3;
1442
    dprintf("dc=%d diff=%d\n", dc, diff);
1443
    i = 0;
1444
    {
1445
        OPEN_READER(re, &s->gb);    
1446
        /* now quantify & encode AC coefs */
1447
        for(;;) {
1448
            UPDATE_CACHE(re, &s->gb);
1449
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1450
            
1451
            if(level == 127){
1452
                break;
1453
            } else if(level != 0) {
1454
                i += run;
1455
                j = scantable[i];
1456
                level= (level*qscale*quant_matrix[j])>>3;
1457
                level= (level-1)|1;
1458
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1459
                LAST_SKIP_BITS(re, &s->gb, 1);
1460
            } else {
1461
                /* escape */
1462
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1463
                UPDATE_CACHE(re, &s->gb);
1464
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1465
                if (level == -128) {
1466
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1467
                } else if (level == 0) {
1468
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1469
                }
1470
                i += run;
1471
                j = scantable[i];
1472
                if(level<0){
1473
                    level= -level;
1474
                    level= (level*qscale*quant_matrix[j])>>3;
1475
                    level= (level-1)|1;
1476
                    level= -level;
1477
                }else{
1478
                    level= (level*qscale*quant_matrix[j])>>3;
1479
                    level= (level-1)|1;
1480
                }
1481
            }
1482
            if (i > 63){
1483
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1484
                return -1;
1485
            }
1486

    
1487
            block[j] = level;
1488
        }
1489
        CLOSE_READER(re, &s->gb);
1490
    }
1491
    s->block_last_index[n] = i;
1492
   return 0;
1493
}
1494

    
1495
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
1496
                               DCTELEM *block, 
1497
                               int n)
1498
{
1499
    int level, i, j, run;
1500
    RLTable *rl = &rl_mpeg1;
1501
    uint8_t * const scantable= s->intra_scantable.permutated;
1502
    const uint16_t *quant_matrix= s->inter_matrix;
1503
    const int qscale= s->qscale;
1504

    
1505
    {
1506
        int v;
1507
        OPEN_READER(re, &s->gb);
1508
        i = -1;
1509
        /* special case for the first coef. no need to add a second vlc table */
1510
        UPDATE_CACHE(re, &s->gb);
1511
        v= SHOW_UBITS(re, &s->gb, 2);
1512
        if (v & 2) {
1513
            LAST_SKIP_BITS(re, &s->gb, 2);
1514
            level= (3*qscale*quant_matrix[0])>>4;
1515
            level= (level-1)|1;
1516
            if(v&1)
1517
                level= -level;
1518
            block[0] = level;
1519
            i++;
1520
        }
1521

    
1522
        /* now quantify & encode AC coefs */
1523
        for(;;) {
1524
            UPDATE_CACHE(re, &s->gb);
1525
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1526
            
1527
            if(level == 127){
1528
                break;
1529
            } else if(level != 0) {
1530
                i += run;
1531
                j = scantable[i];
1532
                level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1533
                level= (level-1)|1;
1534
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1535
                LAST_SKIP_BITS(re, &s->gb, 1);
1536
            } else {
1537
                /* escape */
1538
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1539
                UPDATE_CACHE(re, &s->gb);
1540
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1541
                if (level == -128) {
1542
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1543
                } else if (level == 0) {
1544
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1545
                }
1546
                i += run;
1547
                j = scantable[i];
1548
                if(level<0){
1549
                    level= -level;
1550
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1551
                    level= (level-1)|1;
1552
                    level= -level;
1553
                }else{
1554
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1555
                    level= (level-1)|1;
1556
                }
1557
            }
1558
            if (i > 63){
1559
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1560
                return -1;
1561
            }
1562

    
1563
            block[j] = level;
1564
        }
1565
        CLOSE_READER(re, &s->gb);
1566
    }
1567
    s->block_last_index[n] = i;
1568
    return 0;
1569
}
1570

    
1571
/* Also does unquantization here, since I will never support mpeg2
1572
   encoding */
1573
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1574
                               DCTELEM *block, 
1575
                               int n)
1576
{
1577
    int level, i, j, run;
1578
    RLTable *rl = &rl_mpeg1;
1579
    uint8_t * const scantable= s->intra_scantable.permutated;
1580
    const uint16_t *quant_matrix;
1581
    const int qscale= s->qscale;
1582
    int mismatch;
1583

    
1584
    mismatch = 1;
1585

    
1586
    {
1587
        int v;
1588
        OPEN_READER(re, &s->gb);
1589
        i = -1;
1590
        if (n < 4)
1591
            quant_matrix = s->inter_matrix;
1592
        else
1593
            quant_matrix = s->chroma_inter_matrix;
1594

    
1595
        /* special case for the first coef. no need to add a second vlc table */
1596
        UPDATE_CACHE(re, &s->gb);
1597
        v= SHOW_UBITS(re, &s->gb, 2);
1598
        if (v & 2) {
1599
            LAST_SKIP_BITS(re, &s->gb, 2);
1600
            level= (3*qscale*quant_matrix[0])>>5;
1601
            if(v&1)
1602
                level= -level;
1603
            block[0] = level;
1604
            mismatch ^= level;
1605
            i++;
1606
        }
1607

    
1608
        /* now quantify & encode AC coefs */
1609
        for(;;) {
1610
            UPDATE_CACHE(re, &s->gb);
1611
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1612
            
1613
            if(level == 127){
1614
                break;
1615
            } else if(level != 0) {
1616
                i += run;
1617
                j = scantable[i];
1618
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1619
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1620
                LAST_SKIP_BITS(re, &s->gb, 1);
1621
            } else {
1622
                /* escape */
1623
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1624
                UPDATE_CACHE(re, &s->gb);
1625
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1626

    
1627
                i += run;
1628
                j = scantable[i];
1629
                if(level<0){
1630
                    level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1631
                    level= -level;
1632
                }else{
1633
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1634
                }
1635
            }
1636
            if (i > 63){
1637
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1638
                return -1;
1639
            }
1640
            
1641
            mismatch ^= level;
1642
            block[j] = level;
1643
        }
1644
        CLOSE_READER(re, &s->gb);
1645
    }
1646
    block[63] ^= (mismatch & 1);
1647
    
1648
    s->block_last_index[n] = i;
1649
    return 0;
1650
}
1651

    
1652
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
1653
                               DCTELEM *block, 
1654
                               int n)
1655
{
1656
    int level, dc, diff, i, j, run;
1657
    int component;
1658
    RLTable *rl;
1659
    uint8_t * const scantable= s->intra_scantable.permutated;
1660
    const uint16_t *quant_matrix;
1661
    const int qscale= s->qscale;
1662
    int mismatch;
1663

    
1664
    /* DC coef */
1665
    if (n < 4){
1666
        quant_matrix = s->intra_matrix;
1667
        component = 0; 
1668
    }else{
1669
        quant_matrix = s->chroma_intra_matrix;
1670
        component = n - 3;
1671
    }
1672
    diff = decode_dc(&s->gb, component);
1673
    if (diff >= 0xffff)
1674
        return -1;
1675
    dc = s->last_dc[component];
1676
    dc += diff;
1677
    s->last_dc[component] = dc;
1678
    block[0] = dc << (3 - s->intra_dc_precision);
1679
    dprintf("dc=%d\n", block[0]);
1680
    mismatch = block[0] ^ 1;
1681
    i = 0;
1682
    if (s->intra_vlc_format)
1683
        rl = &rl_mpeg2;
1684
    else
1685
        rl = &rl_mpeg1;
1686

    
1687
    {
1688
        OPEN_READER(re, &s->gb);    
1689
        /* now quantify & encode AC coefs */
1690
        for(;;) {
1691
            UPDATE_CACHE(re, &s->gb);
1692
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1693
            
1694
            if(level == 127){
1695
                break;
1696
            } else if(level != 0) {
1697
                i += run;
1698
                j = scantable[i];
1699
                level= (level*qscale*quant_matrix[j])>>4;
1700
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1701
                LAST_SKIP_BITS(re, &s->gb, 1);
1702
            } else {
1703
                /* escape */
1704
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1705
                UPDATE_CACHE(re, &s->gb);
1706
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1707
                i += run;
1708
                j = scantable[i];
1709
                if(level<0){
1710
                    level= (-level*qscale*quant_matrix[j])>>4;
1711
                    level= -level;
1712
                }else{
1713
                    level= (level*qscale*quant_matrix[j])>>4;
1714
                }
1715
            }
1716
            if (i > 63){
1717
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1718
                return -1;
1719
            }
1720
            
1721
            mismatch^= level;
1722
            block[j] = level;
1723
        }
1724
        CLOSE_READER(re, &s->gb);
1725
    }
1726
    block[63]^= mismatch&1;
1727
    
1728
    s->block_last_index[n] = i;
1729
    return 0;
1730
}
1731

    
1732
typedef struct Mpeg1Context {
1733
    MpegEncContext mpeg_enc_ctx;
1734
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1735
    int repeat_field; /* true if we must repeat the field */
1736
    AVPanScan pan_scan; /** some temporary storage for the panscan */
1737
} Mpeg1Context;
1738

    
1739
static int mpeg_decode_init(AVCodecContext *avctx)
1740
{
1741
    Mpeg1Context *s = avctx->priv_data;
1742
    
1743
    s->mpeg_enc_ctx.flags= avctx->flags;
1744
    common_init(&s->mpeg_enc_ctx);
1745
    init_vlcs();
1746

    
1747
    s->mpeg_enc_ctx_allocated = 0;
1748
    s->mpeg_enc_ctx.picture_number = 0;
1749
    s->repeat_field = 0;
1750
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1751
    return 0;
1752
}
1753

    
1754
/* return the 8 bit start code value and update the search
1755
   state. Return -1 if no start code found */
1756
static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end)
1757
{
1758
    uint8_t *buf_ptr;
1759
    unsigned int state=0xFFFFFFFF, v;
1760
    int val;
1761

    
1762
    buf_ptr = *pbuf_ptr;
1763
    while (buf_ptr < buf_end) {
1764
        v = *buf_ptr++;
1765
        if (state == 0x000001) {
1766
            state = ((state << 8) | v) & 0xffffff;
1767
            val = state;
1768
            goto found;
1769
        }
1770
        state = ((state << 8) | v) & 0xffffff;
1771
    }
1772
    val = -1;
1773
 found:
1774
    *pbuf_ptr = buf_ptr;
1775
    return val;
1776
}
1777

    
1778
static int mpeg1_decode_picture(AVCodecContext *avctx, 
1779
                                uint8_t *buf, int buf_size)
1780
{
1781
    Mpeg1Context *s1 = avctx->priv_data;
1782
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1783
    int ref, f_code, vbv_delay;
1784

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

    
1787
    ref = get_bits(&s->gb, 10); /* temporal ref */
1788
    s->pict_type = get_bits(&s->gb, 3);
1789
    dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number);
1790

    
1791
    vbv_delay= get_bits(&s->gb, 16);
1792
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
1793
        s->full_pel[0] = get_bits1(&s->gb);
1794
        f_code = get_bits(&s->gb, 3);
1795
        if (f_code == 0)
1796
            return -1;
1797
        s->mpeg_f_code[0][0] = f_code;
1798
        s->mpeg_f_code[0][1] = f_code;
1799
    }
1800
    if (s->pict_type == B_TYPE) {
1801
        s->full_pel[1] = get_bits1(&s->gb);
1802
        f_code = get_bits(&s->gb, 3);
1803
        if (f_code == 0)
1804
            return -1;
1805
        s->mpeg_f_code[1][0] = f_code;
1806
        s->mpeg_f_code[1][1] = f_code;
1807
    }
1808
    s->current_picture.pict_type= s->pict_type;
1809
    s->current_picture.key_frame= s->pict_type == I_TYPE;
1810
    
1811
    s->y_dc_scale = 8;
1812
    s->c_dc_scale = 8;
1813
    s->first_slice = 1;
1814
    return 0;
1815
}
1816

    
1817
static void mpeg_decode_sequence_extension(MpegEncContext *s)
1818
{
1819
    int horiz_size_ext, vert_size_ext;
1820
    int bit_rate_ext;
1821
    int frame_rate_ext_n, frame_rate_ext_d;
1822
    int level, profile;
1823

    
1824
    skip_bits(&s->gb, 1); /* profil and level esc*/
1825
    profile= get_bits(&s->gb, 3);
1826
    level= get_bits(&s->gb, 4);
1827
    s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1828
    skip_bits(&s->gb, 2); /* chroma_format */
1829
    horiz_size_ext = get_bits(&s->gb, 2);
1830
    vert_size_ext = get_bits(&s->gb, 2);
1831
    s->width |= (horiz_size_ext << 12);
1832
    s->height |= (vert_size_ext << 12);
1833
    bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1834
    s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
1835
    skip_bits1(&s->gb); /* marker */
1836
    s->avctx->rc_buffer_size += get_bits(&s->gb, 8)*1024*16<<10;
1837

    
1838
    s->low_delay = get_bits1(&s->gb);
1839
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
1840

    
1841
    frame_rate_ext_n = get_bits(&s->gb, 2);
1842
    frame_rate_ext_d = get_bits(&s->gb, 5);
1843
    av_reduce(
1844
        &s->avctx->frame_rate, 
1845
        &s->avctx->frame_rate_base, 
1846
        frame_rate_tab[s->frame_rate_index] * (frame_rate_ext_n+1),
1847
        MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d+1),
1848
        1<<30);
1849

    
1850
    dprintf("sequence extension\n");
1851
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
1852
    s->avctx->sub_id = 2; /* indicates mpeg2 found */
1853

    
1854
    if(s->aspect_ratio_info <= 1)
1855
        s->avctx->sample_aspect_ratio= mpeg2_aspect[s->aspect_ratio_info];
1856
    else{
1857
        s->avctx->sample_aspect_ratio= 
1858
            av_div_q(
1859
                mpeg2_aspect[s->aspect_ratio_info], 
1860
                (AVRational){s->width, s->height}
1861
            );
1862
    }
1863
    
1864
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1865
        av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d vbv buffer: %d, bitrate:%d\n", 
1866
               profile, level, s->avctx->rc_buffer_size, s->bit_rate);
1867
}
1868

    
1869
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1870
{
1871
    MpegEncContext *s= &s1->mpeg_enc_ctx;
1872
    int color_description, w, h;
1873

    
1874
    skip_bits(&s->gb, 3); /* video format */
1875
    color_description= get_bits1(&s->gb);
1876
    if(color_description){
1877
        skip_bits(&s->gb, 8); /* color primaries */
1878
        skip_bits(&s->gb, 8); /* transfer_characteristics */
1879
        skip_bits(&s->gb, 8); /* matrix_coefficients */
1880
    }
1881
    w= get_bits(&s->gb, 14);
1882
    skip_bits(&s->gb, 1); //marker
1883
    h= get_bits(&s->gb, 14);
1884
    skip_bits(&s->gb, 1); //marker
1885
    
1886
    s1->pan_scan.width= 16*w;
1887
    s1->pan_scan.height=16*h;
1888

    
1889
    if(s->aspect_ratio_info > 1)
1890
        s->avctx->sample_aspect_ratio= 
1891
            av_div_q(
1892
                mpeg2_aspect[s->aspect_ratio_info], 
1893
                (AVRational){w, h}
1894
            );
1895
    
1896
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1897
        av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1898
}
1899

    
1900
static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1901
{
1902
    MpegEncContext *s= &s1->mpeg_enc_ctx;
1903
    int i;
1904

    
1905
    for(i=0; i<1; i++){ //FIXME count
1906
        s1->pan_scan.position[i][0]= get_sbits(&s->gb, 16);
1907
        skip_bits(&s->gb, 1); //marker
1908
        s1->pan_scan.position[i][1]= get_sbits(&s->gb, 16);
1909
        skip_bits(&s->gb, 1); //marker
1910
    }
1911
   
1912
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1913
        av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n", 
1914
            s1->pan_scan.position[0][0], s1->pan_scan.position[0][1], 
1915
            s1->pan_scan.position[1][0], s1->pan_scan.position[1][1], 
1916
            s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]
1917
        );
1918
}
1919

    
1920
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1921
{
1922
    int i, v, j;
1923

    
1924
    dprintf("matrix extension\n");
1925

    
1926
    if (get_bits1(&s->gb)) {
1927
        for(i=0;i<64;i++) {
1928
            v = get_bits(&s->gb, 8);
1929
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1930
            s->intra_matrix[j] = v;
1931
            s->chroma_intra_matrix[j] = v;
1932
        }
1933
    }
1934
    if (get_bits1(&s->gb)) {
1935
        for(i=0;i<64;i++) {
1936
            v = get_bits(&s->gb, 8);
1937
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1938
            s->inter_matrix[j] = v;
1939
            s->chroma_inter_matrix[j] = v;
1940
        }
1941
    }
1942
    if (get_bits1(&s->gb)) {
1943
        for(i=0;i<64;i++) {
1944
            v = get_bits(&s->gb, 8);
1945
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1946
            s->chroma_intra_matrix[j] = v;
1947
        }
1948
    }
1949
    if (get_bits1(&s->gb)) {
1950
        for(i=0;i<64;i++) {
1951
            v = get_bits(&s->gb, 8);
1952
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1953
            s->chroma_inter_matrix[j] = v;
1954
        }
1955
    }
1956
}
1957

    
1958
static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
1959
{
1960
    s->full_pel[0] = s->full_pel[1] = 0;
1961
    s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1962
    s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1963
    s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1964
    s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1965
    s->intra_dc_precision = get_bits(&s->gb, 2);
1966
    s->picture_structure = get_bits(&s->gb, 2);
1967
    s->top_field_first = get_bits1(&s->gb);
1968
    s->frame_pred_frame_dct = get_bits1(&s->gb);
1969
    s->concealment_motion_vectors = get_bits1(&s->gb);
1970
    s->q_scale_type = get_bits1(&s->gb);
1971
    s->intra_vlc_format = get_bits1(&s->gb);
1972
    s->alternate_scan = get_bits1(&s->gb);
1973
    s->repeat_first_field = get_bits1(&s->gb);
1974
    s->chroma_420_type = get_bits1(&s->gb);
1975
    s->progressive_frame = get_bits1(&s->gb);
1976

    
1977
    if(s->picture_structure == PICT_FRAME)
1978
        s->first_field=0;
1979
    else{
1980
        s->first_field ^= 1;
1981
        memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
1982
    }
1983
    
1984
    if(s->alternate_scan){
1985
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
1986
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
1987
    }else{
1988
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
1989
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
1990
    }
1991
    
1992
    /* composite display not parsed */
1993
    dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
1994
    dprintf("picture_structure=%d\n", s->picture_structure);
1995
    dprintf("top field first=%d\n", s->top_field_first);
1996
    dprintf("repeat first field=%d\n", s->repeat_first_field);
1997
    dprintf("conceal=%d\n", s->concealment_motion_vectors);
1998
    dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
1999
    dprintf("alternate_scan=%d\n", s->alternate_scan);
2000
    dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
2001
    dprintf("progressive_frame=%d\n", s->progressive_frame);
2002
}
2003

    
2004
static void mpeg_decode_extension(AVCodecContext *avctx, 
2005
                                  uint8_t *buf, int buf_size)
2006
{
2007
    Mpeg1Context *s1 = avctx->priv_data;
2008
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2009
    int ext_type;
2010

    
2011
    init_get_bits(&s->gb, buf, buf_size*8);
2012
    
2013
    ext_type = get_bits(&s->gb, 4);
2014
    switch(ext_type) {
2015
    case 0x1:
2016
        mpeg_decode_sequence_extension(s);
2017
        break;
2018
    case 0x2:
2019
        mpeg_decode_sequence_display_extension(s1);
2020
        break;
2021
    case 0x3:
2022
        mpeg_decode_quant_matrix_extension(s);
2023
        break;
2024
    case 0x7:
2025
        mpeg_decode_picture_display_extension(s1);
2026
        break;
2027
    case 0x8:
2028
        mpeg_decode_picture_coding_extension(s);
2029
        break;
2030
    }
2031
}
2032

    
2033
static void exchange_uv(MpegEncContext *s){
2034
short * tmp;
2035

    
2036
    tmp = s->pblocks[4];
2037
    s->pblocks[4] = s->pblocks[5];
2038
    s->pblocks[5] = tmp;
2039
}
2040

    
2041
#define DECODE_SLICE_FATAL_ERROR -2
2042
#define DECODE_SLICE_ERROR -1
2043
#define DECODE_SLICE_OK 0
2044

    
2045
/**
2046
 * decodes a slice.
2047
 * @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br>
2048
 *         DECODE_SLICE_ERROR if the slice is damaged<br>
2049
 *         DECODE_SLICE_OK if this slice is ok<br>
2050
 */
2051
static int mpeg_decode_slice(AVCodecContext *avctx, 
2052
                              AVFrame *pict,
2053
                              int start_code,
2054
                              uint8_t **buf, int buf_size)
2055
{
2056
    Mpeg1Context *s1 = avctx->priv_data;
2057
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2058
    int ret;
2059
    const int field_pic= s->picture_structure != PICT_FRAME;
2060

    
2061
    s->resync_mb_x= s->mb_x = 
2062
    s->resync_mb_y= s->mb_y = -1;
2063
    
2064
    start_code = (start_code - 1) & 0xff;
2065
    if (start_code >= s->mb_height){
2066
        av_log(s->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", start_code, s->mb_height);
2067
        return -1;
2068
    }
2069
    
2070
    ff_mpeg1_clean_buffers(s);
2071
    s->interlaced_dct = 0;
2072
        
2073
    /* start frame decoding */
2074
    if (s->first_slice) {
2075
      if(s->first_field || s->picture_structure==PICT_FRAME){
2076
        if(MPV_frame_start(s, avctx) < 0)
2077
            return DECODE_SLICE_FATAL_ERROR;
2078

    
2079
        ff_er_frame_start(s);
2080

    
2081
        /* first check if we must repeat the frame */
2082
        s->current_picture_ptr->repeat_pict = 0;
2083
        if (s->repeat_first_field) {
2084
            if (s->progressive_sequence) {
2085
                if (s->top_field_first)
2086
                    s->current_picture_ptr->repeat_pict = 4;
2087
                else
2088
                    s->current_picture_ptr->repeat_pict = 2;
2089
            } else if (s->progressive_frame) {
2090
                s->current_picture_ptr->repeat_pict = 1;
2091
            }
2092
        }         
2093

    
2094
        *s->current_picture_ptr->pan_scan= s1->pan_scan;
2095
      }else{ //second field
2096
            int i;
2097
            
2098
            if(!s->current_picture_ptr){
2099
                av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
2100
                return -1;
2101
            }
2102
            
2103
            for(i=0; i<4; i++){
2104
                s->current_picture.data[i] = s->current_picture_ptr->data[i];
2105
                if(s->picture_structure == PICT_BOTTOM_FIELD){
2106
                    s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
2107
                } 
2108
            }
2109
      }
2110
#ifdef HAVE_XVMC
2111
// MPV_frame_start will call this function too,
2112
// but we need to call it on every field
2113
      if(s->avctx->xvmc_acceleration)
2114
         XVMC_field_start(s,avctx);
2115
#endif
2116
    }//fi(s->first_slice)
2117

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

    
2120
    s->qscale = get_qscale(s);
2121
    if (s->first_slice && (s->first_field || s->picture_structure==PICT_FRAME)) {
2122
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
2123
             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", 
2124
                 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],
2125
                 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), 
2126
                 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"", 
2127
                 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
2128
                 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
2129
        }
2130
    }
2131

    
2132
    s->first_slice = 0;
2133
    if(s->qscale == 0){
2134
        av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
2135
        return -1;
2136
    }
2137
    
2138
    /* extra slice info */
2139
    while (get_bits1(&s->gb) != 0) {
2140
        skip_bits(&s->gb, 8);
2141
    }
2142
    
2143
    s->mb_x=0;
2144

    
2145
    for(;;) {
2146
        int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
2147
        if (code < 0){
2148
            av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
2149
            return -1;
2150
        }
2151
        if (code >= 33) {
2152
            if (code == 33) {
2153
                s->mb_x += 33;
2154
            }
2155
            /* otherwise, stuffing, nothing to do */
2156
        } else {
2157
            s->mb_x += code;
2158
            break;
2159
        }
2160
    }
2161
    
2162
    s->resync_mb_x= s->mb_x;
2163
    s->resync_mb_y= s->mb_y = start_code;
2164
    s->mb_skip_run= 0;
2165
    ff_init_block_index(s);
2166

    
2167
    for(;;) {
2168
#ifdef HAVE_XVMC
2169
        //one 1 we memcpy blocks in xvmcvideo
2170
        if(s->avctx->xvmc_acceleration > 1)
2171
            XVMC_init_block(s);//set s->block
2172
#endif
2173

    
2174
        s->dsp.clear_blocks(s->block[0]);
2175

    
2176
        ret = mpeg_decode_mb(s, s->block);
2177
        s->chroma_qscale= s->qscale;
2178

    
2179
        dprintf("ret=%d\n", ret);
2180
        if (ret < 0)
2181
            return -1;
2182

    
2183
        if(s->current_picture.motion_val[0] && !s->encoding){ //note motion_val is normally NULL unless we want to extract the MVs
2184
            const int wrap = field_pic ? 2*s->block_wrap[0] : s->block_wrap[0];
2185
            int xy = s->mb_x*2 + 1 + (s->mb_y*2 +1)*wrap;
2186
            int motion_for_top_x, motion_for_top_y, motion_back_top_x, motion_back_top_y;
2187
            int motion_for_bottom_x, motion_for_bottom_y, motion_back_bottom_x, motion_back_bottom_y;
2188
            if(field_pic && !s->first_field)
2189
                xy += wrap/2;
2190

    
2191
            if (s->mb_intra) {
2192
                motion_for_top_x = motion_for_top_y = motion_back_top_x = motion_back_top_y =
2193
                motion_for_bottom_x = motion_for_bottom_y = motion_back_bottom_x = motion_back_bottom_y = 0;
2194
            }else if (s->mv_type == MV_TYPE_16X16){
2195
                motion_for_top_x = motion_for_bottom_x = s->mv[0][0][0];
2196
                motion_for_top_y = motion_for_bottom_y = s->mv[0][0][1];
2197
                motion_back_top_x = motion_back_bottom_x = s->mv[1][0][0];
2198
                motion_back_top_y = motion_back_bottom_y = s->mv[1][0][1];
2199
            } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ {
2200
                motion_for_top_x = s->mv[0][0][0];
2201
                motion_for_top_y = s->mv[0][0][1];
2202
                motion_for_bottom_x = s->mv[0][1][0];
2203
                motion_for_bottom_y = s->mv[0][1][1];
2204
                motion_back_top_x = s->mv[1][0][0];
2205
                motion_back_top_y = s->mv[1][0][1];
2206
                motion_back_bottom_x = s->mv[1][1][0];
2207
                motion_back_bottom_y = s->mv[1][1][1];
2208
            }
2209

    
2210
            s->current_picture.motion_val[0][xy][0] = motion_for_top_x;
2211
            s->current_picture.motion_val[0][xy][1] = motion_for_top_y;
2212
            s->current_picture.motion_val[0][xy + 1][0] = motion_for_top_x;
2213
            s->current_picture.motion_val[0][xy + 1][1] = motion_for_top_y;
2214
            s->current_picture.motion_val[0][xy + wrap][0] = motion_for_bottom_x;
2215
            s->current_picture.motion_val[0][xy + wrap][1] = motion_for_bottom_y;
2216
            s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_for_bottom_x;
2217
            s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_for_bottom_y;
2218

    
2219
            if(s->pict_type != B_TYPE){
2220
                motion_back_top_x = motion_back_top_y = motion_back_bottom_x = motion_back_bottom_y = 0;
2221
            }
2222

    
2223
            s->current_picture.motion_val[1][xy][0] = motion_back_top_x;
2224
            s->current_picture.motion_val[1][xy][1] = motion_back_top_y;
2225
            s->current_picture.motion_val[1][xy + 1][0] = motion_back_top_x;
2226
            s->current_picture.motion_val[1][xy + 1][1] = motion_back_top_y;
2227
            s->current_picture.motion_val[1][xy + wrap][0] = motion_back_bottom_x;
2228
            s->current_picture.motion_val[1][xy + wrap][1] = motion_back_bottom_y;
2229
            s->current_picture.motion_val[1][xy + 1 + wrap][0] = motion_back_bottom_x;
2230
            s->current_picture.motion_val[1][xy + 1 + wrap][1] = motion_back_bottom_y;
2231
        }
2232

    
2233
        s->dest[0] += 16;
2234
        s->dest[1] += 8;
2235
        s->dest[2] += 8;
2236

    
2237
        MPV_decode_mb(s, s->block);
2238
        
2239
        if (++s->mb_x >= s->mb_width) {
2240

    
2241
            ff_draw_horiz_band(s, 16*s->mb_y, 16);
2242

    
2243
            s->mb_x = 0;
2244
            s->mb_y++;
2245

    
2246
            if(s->mb_y<<field_pic >= s->mb_height){
2247
                int left= s->gb.size_in_bits - get_bits_count(&s->gb);
2248

    
2249
                if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)))
2250
                   || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
2251
                    av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d\n", left);
2252
                    return -1;
2253
                }else
2254
                    goto eos;
2255
            }
2256
            
2257
            ff_init_block_index(s);
2258
        }
2259

    
2260
        /* skip mb handling */
2261
        if (s->mb_skip_run == -1) {
2262
            /* read again increment */
2263
            s->mb_skip_run = 0;
2264
            for(;;) {
2265
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
2266
                if (code < 0){
2267
                    av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
2268
                    return -1;
2269
                }
2270
                if (code >= 33) {
2271
                    if (code == 33) {
2272
                        s->mb_skip_run += 33;
2273
                    }else if(code == 35){
2274
                        if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
2275
                            av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
2276
                            return -1;
2277
                        }
2278
                        goto eos; /* end of slice */
2279
                    }
2280
                    /* otherwise, stuffing, nothing to do */
2281
                } else {
2282
                    s->mb_skip_run += code;
2283
                    break;
2284
                }
2285
            }
2286
        }
2287
    }
2288
eos: // end of slice
2289
    *buf += get_bits_count(&s->gb)/8 - 1;
2290
//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
2291
    return 0;
2292
}
2293

    
2294
/**
2295
 * handles slice ends.
2296
 * @return 1 if it seems to be the last slice of 
2297
 */
2298
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2299
{
2300
    Mpeg1Context *s1 = avctx->priv_data;
2301
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2302
       
2303
    if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2304
        return 0;
2305

    
2306
#ifdef HAVE_XVMC
2307
    if(s->avctx->xvmc_acceleration)
2308
        XVMC_field_end(s);
2309
#endif
2310
    /* end of slice reached */
2311
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
2312
        /* end of image */
2313

    
2314
        if(s->codec_id == CODEC_ID_MPEG2VIDEO){
2315
            s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
2316
        }else
2317
            s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG1;
2318

    
2319
        ff_er_frame_end(s);
2320

    
2321
        MPV_frame_end(s);
2322

    
2323
        if (s->pict_type == B_TYPE || s->low_delay) {
2324
            *pict= *(AVFrame*)s->current_picture_ptr;
2325
            ff_print_debug_info(s, pict);
2326
        } else {
2327
            s->picture_number++;
2328
            /* latency of 1 frame for I and P frames */
2329
            /* XXX: use another variable than picture_number */
2330
            if (s->last_picture_ptr != NULL) {
2331
                *pict= *(AVFrame*)s->last_picture_ptr;
2332
                 ff_print_debug_info(s, pict);
2333
            }
2334
        }
2335

    
2336
        return 1;
2337
    } else {
2338
        return 0;
2339
    }
2340
}
2341

    
2342
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
2343
                                 uint8_t *buf, int buf_size)
2344
{
2345
    Mpeg1Context *s1 = avctx->priv_data;
2346
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2347
    int width, height, i, v, j;
2348
    float aspect;
2349

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

    
2352
    width = get_bits(&s->gb, 12);
2353
    height = get_bits(&s->gb, 12);
2354
    s->aspect_ratio_info= get_bits(&s->gb, 4);
2355
    if (s->aspect_ratio_info == 0)
2356
        return -1;
2357
    aspect= 1.0/mpeg1_aspect[s->aspect_ratio_info];
2358
    avctx->sample_aspect_ratio= av_d2q(aspect, 255);
2359

    
2360
    s->frame_rate_index = get_bits(&s->gb, 4);
2361
    if (s->frame_rate_index == 0)
2362
        return -1;
2363
    s->bit_rate = get_bits(&s->gb, 18) * 400;
2364
    if (get_bits1(&s->gb) == 0) /* marker */
2365
        return -1;
2366
    if (width <= 0 || height <= 0 ||
2367
        (width % 2) != 0 || (height % 2) != 0)
2368
        return -1;
2369
    if (width != s->width ||
2370
        height != s->height) {
2371
        /* start new mpeg1 context decoding */
2372
        s->out_format = FMT_MPEG1;
2373
        if (s1->mpeg_enc_ctx_allocated) {
2374
            MPV_common_end(s);
2375
        }
2376
        s->width = width;
2377
        s->height = height;
2378
        avctx->has_b_frames= 1;
2379
        s->avctx = avctx;
2380
        avctx->width = width;
2381
        avctx->height = height;
2382
        av_reduce(
2383
            &avctx->frame_rate, 
2384
            &avctx->frame_rate_base,
2385
            frame_rate_tab[s->frame_rate_index],
2386
            MPEG1_FRAME_RATE_BASE, //FIXME store in allready reduced form 
2387
            1<<30
2388
            );
2389
        avctx->bit_rate = s->bit_rate;
2390
        
2391
        //get_format() or set_video(width,height,aspect,pix_fmt);
2392
        //until then pix_fmt may be changed right after codec init
2393
        if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2394
            if( avctx->idct_algo == FF_IDCT_AUTO )
2395
                avctx->idct_algo = FF_IDCT_SIMPLE;
2396

    
2397
        if (MPV_common_init(s) < 0)
2398
            return -1;
2399
        s1->mpeg_enc_ctx_allocated = 1;
2400
        s->swap_uv = 0;//just in case vcr2 and mpeg2 stream have been concatinated
2401
    }
2402

    
2403
    s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16;
2404
    skip_bits(&s->gb, 1);
2405

    
2406
    /* get matrix */
2407
    if (get_bits1(&s->gb)) {
2408
        for(i=0;i<64;i++) {
2409
            v = get_bits(&s->gb, 8);
2410
            j = s->intra_scantable.permutated[i];
2411
            s->intra_matrix[j] = v;
2412
            s->chroma_intra_matrix[j] = v;
2413
        }
2414
#ifdef DEBUG
2415
        dprintf("intra matrix present\n");
2416
        for(i=0;i<64;i++)
2417
            dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
2418
        printf("\n");
2419
#endif
2420
    } else {
2421
        for(i=0;i<64;i++) {
2422
            int j= s->dsp.idct_permutation[i];
2423
            v = ff_mpeg1_default_intra_matrix[i];
2424
            s->intra_matrix[j] = v;
2425
            s->chroma_intra_matrix[j] = v;
2426
        }
2427
    }
2428
    if (get_bits1(&s->gb)) {
2429
        for(i=0;i<64;i++) {
2430
            v = get_bits(&s->gb, 8);
2431
            j = s->intra_scantable.permutated[i];
2432
            s->inter_matrix[j] = v;
2433
            s->chroma_inter_matrix[j] = v;
2434
        }
2435
#ifdef DEBUG
2436
        dprintf("non intra matrix present\n");
2437
        for(i=0;i<64;i++)
2438
            dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
2439
        printf("\n");
2440
#endif
2441
    } else {
2442
        for(i=0;i<64;i++) {
2443
            int j= s->dsp.idct_permutation[i];
2444
            v = ff_mpeg1_default_non_intra_matrix[i];
2445
            s->inter_matrix[j] = v;
2446
            s->chroma_inter_matrix[j] = v;
2447
        }
2448
    }
2449

    
2450
    /* we set mpeg2 parameters so that it emulates mpeg1 */
2451
    s->progressive_sequence = 1;
2452
    s->progressive_frame = 1;
2453
    s->picture_structure = PICT_FRAME;
2454
    s->frame_pred_frame_dct = 1;
2455
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO;
2456
    avctx->sub_id = 1; /* indicates mpeg1 */
2457
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
2458
    
2459
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2460
        av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n", 
2461
               s->avctx->rc_buffer_size, s->bit_rate);
2462
    
2463
    return 0;
2464
}
2465

    
2466
static int vcr2_init_sequence(AVCodecContext *avctx)
2467
{
2468
    Mpeg1Context *s1 = avctx->priv_data;
2469
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2470
    int i, v;
2471

    
2472
    /* start new mpeg1 context decoding */
2473
    s->out_format = FMT_MPEG1;
2474
    if (s1->mpeg_enc_ctx_allocated) {
2475
        MPV_common_end(s);
2476
    }
2477
    s->width = avctx->width;
2478
    s->height = avctx->height;
2479
    avctx->has_b_frames= 0; //true?
2480
    s->low_delay= 1;
2481
    s->avctx = avctx;
2482

    
2483
    //get_format() or set_video(width,height,aspect,pix_fmt);
2484
    //until then pix_fmt may be changed right after codec init
2485
    if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2486
        if( avctx->idct_algo == FF_IDCT_AUTO )
2487
            avctx->idct_algo = FF_IDCT_SIMPLE;
2488
    
2489
    if (MPV_common_init(s) < 0)
2490
        return -1;
2491
    exchange_uv(s);//common init reset pblocks, so we swap them here
2492
    s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB 
2493
    s1->mpeg_enc_ctx_allocated = 1;
2494

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

    
2501
        v = ff_mpeg1_default_non_intra_matrix[i];
2502
        s->inter_matrix[j] = v;
2503
        s->chroma_inter_matrix[j] = v;
2504
    }
2505

    
2506
    s->progressive_sequence = 1;
2507
    s->progressive_frame = 1;
2508
    s->picture_structure = PICT_FRAME;
2509
    s->frame_pred_frame_dct = 1;
2510
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2511
    avctx->sub_id = 2; /* indicates mpeg2 */
2512
    return 0;
2513
}
2514

    
2515

    
2516
static void mpeg_decode_user_data(AVCodecContext *avctx, 
2517
                                  const uint8_t *buf, int buf_size)
2518
{
2519
    const uint8_t *p;
2520
    int len, flags;
2521
    p = buf;
2522
    len = buf_size;
2523

    
2524
    /* we parse the DTG active format information */
2525
    if (len >= 5 &&
2526
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2527
        flags = p[4];
2528
        p += 5;
2529
        len -= 5;
2530
        if (flags & 0x80) {
2531
            /* skip event id */
2532
            if (len < 2)
2533
                return;
2534
            p += 2;
2535
            len -= 2;
2536
        }
2537
        if (flags & 0x40) {
2538
            if (len < 1)
2539
                return;
2540
            avctx->dtg_active_format = p[0] & 0x0f;
2541
        }
2542
    }
2543
}
2544

    
2545
/**
2546
 * finds the end of the current frame in the bitstream.
2547
 * @return the position of the first byte of the next frame, or -1
2548
 */
2549
static int mpeg1_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
2550
    ParseContext *pc= &s->parse_context;
2551
    int i;
2552
    uint32_t state;
2553
    
2554
    state= pc->state;
2555
    
2556
    i=0;
2557
    if(!pc->frame_start_found){
2558
        for(i=0; i<buf_size; i++){
2559
            state= (state<<8) | buf[i];
2560
            if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2561
                i++;
2562
                pc->frame_start_found=1;
2563
                break;
2564
            }
2565
        }
2566
    }
2567
    
2568
    if(pc->frame_start_found){
2569
        for(; i<buf_size; i++){
2570
            state= (state<<8) | buf[i];
2571
            if((state&0xFFFFFF00) == 0x100){
2572
                if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2573
                    pc->frame_start_found=0;
2574
                    pc->state=-1; 
2575
                    return i-3;
2576
                }
2577
            }
2578
        }
2579
    }        
2580
    pc->state= state;
2581
    return END_NOT_FOUND;
2582
}
2583

    
2584
/* handle buffering and image synchronisation */
2585
static int mpeg_decode_frame(AVCodecContext *avctx, 
2586
                             void *data, int *data_size,
2587
                             uint8_t *buf, int buf_size)
2588
{
2589
    Mpeg1Context *s = avctx->priv_data;
2590
    uint8_t *buf_end, *buf_ptr;
2591
    int ret, start_code, input_size;
2592
    AVFrame *picture = data;
2593
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2594
    dprintf("fill_buffer\n");
2595

    
2596
    *data_size = 0;
2597

    
2598
    /* special case for last picture */
2599
    if (buf_size == 0 && s2->low_delay==0 && s2->next_picture_ptr) {
2600
        *picture= *(AVFrame*)s2->next_picture_ptr;
2601
        s2->next_picture_ptr= NULL;
2602

    
2603
        *data_size = sizeof(AVFrame);
2604
        return 0;
2605
    }
2606

    
2607
    if(s2->flags&CODEC_FLAG_TRUNCATED){
2608
        int next= mpeg1_find_frame_end(s2, buf, buf_size);
2609
        
2610
        if( ff_combine_frame(s2, next, &buf, &buf_size) < 0 )
2611
            return buf_size;
2612
    }    
2613
    
2614
    buf_ptr = buf;
2615
    buf_end = buf + buf_size;
2616

    
2617
#if 0    
2618
    if (s->repeat_field % 2 == 1) { 
2619
        s->repeat_field++;
2620
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2621
        //        s2->picture_number, s->repeat_field);
2622
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2623
            *data_size = sizeof(AVPicture);
2624
            goto the_end;
2625
        }
2626
    }
2627
#endif
2628

    
2629
    if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2"))
2630
        vcr2_init_sequence(avctx);
2631

    
2632
    for(;;) {
2633
        /* find start next code */
2634
        start_code = find_start_code(&buf_ptr, buf_end);
2635
        if (start_code < 0){
2636
            if(s2->pict_type != B_TYPE || avctx->hurry_up==0){
2637
                if (slice_end(avctx, picture)) {
2638
                    if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
2639
                        *data_size = sizeof(AVPicture);
2640
                }
2641
            }
2642
            return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2643
        }
2644
        
2645
        input_size = buf_end - buf_ptr;
2646

    
2647
        if(avctx->debug & FF_DEBUG_STARTCODE){
2648
            av_log(avctx, AV_LOG_DEBUG, "%3X at %d left %d\n", start_code, buf_ptr-buf, input_size);
2649
        }
2650

    
2651
                /* prepare data for next start code */
2652
                switch(start_code) {
2653
                case SEQ_START_CODE:
2654
                    mpeg1_decode_sequence(avctx, buf_ptr, 
2655
                                          input_size);
2656
                    break;
2657
                            
2658
                case PICTURE_START_CODE:
2659
                    /* we have a complete image : we try to decompress it */
2660
                    mpeg1_decode_picture(avctx, 
2661
                                         buf_ptr, input_size);
2662
                    break;
2663
                case EXT_START_CODE:
2664
                    mpeg_decode_extension(avctx,
2665
                                          buf_ptr, input_size);
2666
                    break;
2667
                case USER_START_CODE:
2668
                    mpeg_decode_user_data(avctx, 
2669
                                          buf_ptr, input_size);
2670
                    break;
2671
                case GOP_START_CODE:
2672
                    s2->first_field=0;
2673
                    break;
2674
                default:
2675
                    if (start_code >= SLICE_MIN_START_CODE &&
2676
                        start_code <= SLICE_MAX_START_CODE) {
2677
                        
2678
                        /* skip b frames if we dont have reference frames */
2679
                        if(s2->last_picture_ptr==NULL && s2->pict_type==B_TYPE) break;
2680
                        /* skip b frames if we are in a hurry */
2681
                        if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
2682
                        /* skip everything if we are in a hurry>=5 */
2683
                        if(avctx->hurry_up>=5) break;
2684
                        
2685
                        if (!s->mpeg_enc_ctx_allocated) break;
2686

    
2687
                        ret = mpeg_decode_slice(avctx, picture,
2688
                                                start_code, &buf_ptr, input_size);
2689
                        emms_c();
2690

    
2691
                        if(ret < 0){
2692
                            if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2693
                                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);
2694
                            if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
2695
                        }else{
2696
                            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);
2697
                        }
2698
                    }
2699
                    break;
2700
                }
2701
    }
2702
}
2703

    
2704
static int mpeg_decode_end(AVCodecContext *avctx)
2705
{
2706
    Mpeg1Context *s = avctx->priv_data;
2707

    
2708
    if (s->mpeg_enc_ctx_allocated)
2709
        MPV_common_end(&s->mpeg_enc_ctx);
2710
    return 0;
2711
}
2712

    
2713
AVCodec mpeg1video_decoder = {
2714
    "mpeg1video",
2715
    CODEC_TYPE_VIDEO,
2716
    CODEC_ID_MPEG1VIDEO,
2717
    sizeof(Mpeg1Context),
2718
    mpeg_decode_init,
2719
    NULL,
2720
    mpeg_decode_end,
2721
    mpeg_decode_frame,
2722
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2723
    .flush= ff_mpeg_flush,
2724
};
2725

    
2726
AVCodec mpeg2video_decoder = {
2727
    "mpeg2video",
2728
    CODEC_TYPE_VIDEO,
2729
    CODEC_ID_MPEG2VIDEO,
2730
    sizeof(Mpeg1Context),
2731
    mpeg_decode_init,
2732
    NULL,
2733
    mpeg_decode_end,
2734
    mpeg_decode_frame,
2735
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2736
    .flush= ff_mpeg_flush,
2737
};
2738

    
2739
//legacy decoder
2740
AVCodec mpegvideo_decoder = {
2741
    "mpegvideo",
2742
    CODEC_TYPE_VIDEO,
2743
    CODEC_ID_MPEG2VIDEO,
2744
    sizeof(Mpeg1Context),
2745
    mpeg_decode_init,
2746
    NULL,
2747
    mpeg_decode_end,
2748
    mpeg_decode_frame,
2749
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2750
    .flush= ff_mpeg_flush,
2751
};
2752

    
2753
#ifdef HAVE_XVMC
2754
static int mpeg_mc_decode_init(AVCodecContext *avctx){
2755
    Mpeg1Context *s;
2756

    
2757
    if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
2758
        return -1;
2759
    if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){
2760
        dprintf("mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2761
    }
2762
    mpeg_decode_init(avctx);
2763
    s = avctx->priv_data;
2764

    
2765
    avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
2766
    avctx->xvmc_acceleration = 2;//2 - the blocks are packed!
2767

    
2768
    return 0;
2769
}
2770

    
2771
AVCodec mpeg_xvmc_decoder = {
2772
    "mpegvideo_xvmc",
2773
    CODEC_TYPE_VIDEO,
2774
    CODEC_ID_MPEG2VIDEO_XVMC,
2775
    sizeof(Mpeg1Context),
2776
    mpeg_mc_decode_init,
2777
    NULL,
2778
    mpeg_decode_end,
2779
    mpeg_decode_frame,
2780
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2781
};
2782

    
2783
#endif
2784

    
2785
/* this is ugly i know, but the alternative is too make 
2786
   hundreds of vars global and prefix them with ff_mpeg1_
2787
   which is far uglier. */
2788
#include "mdec.c"