Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg12.c @ 8fe2c60e

History | View | Annotate | Download (101 KB)

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

    
31
#include "mpeg12data.h"
32

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

    
36

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

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

    
55
#ifdef CONFIG_ENCODERS
56
static void mpeg1_encode_block(MpegEncContext *s, 
57
                         DCTELEM *block, 
58
                         int component);
59
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code);    // RAL: f_code parameter added
60
#endif //CONFIG_ENCODERS
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
const enum PixelFormat pixfmt_yuv_420[]= {PIX_FMT_YUV420P,-1};
84
const enum PixelFormat pixfmt_yuv_422[]= {PIX_FMT_YUV422P,-1};
85
const enum PixelFormat pixfmt_yuv_444[]= {PIX_FMT_YUV444P,-1};
86
const enum PixelFormat pixfmt_xvmc_mpg2_420[] = {
87
                                           PIX_FMT_XVMC_MPEG2_IDCT,
88
                                           PIX_FMT_XVMC_MPEG2_MC,
89
                                           -1};
90
#ifdef CONFIG_ENCODERS
91
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
92
static uint8_t fcode_tab[MAX_MV*2+1];
93

    
94
static uint32_t uni_mpeg1_ac_vlc_bits[64*64*2];
95
static uint8_t  uni_mpeg1_ac_vlc_len [64*64*2];
96

    
97
/* simple include everything table for dc, first byte is bits number next 3 are code*/
98
static uint32_t mpeg1_lum_dc_uni[512];
99
static uint32_t mpeg1_chr_dc_uni[512];
100

    
101
static uint8_t mpeg1_index_run[2][64];
102
static int8_t mpeg1_max_level[2][64];
103
#endif //CONFIG_ENCODERS
104

    
105
static void init_2d_vlc_rl(RLTable *rl)
106
{
107
    int i;
108
    
109
    init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2, 
110
             &rl->table_vlc[0][1], 4, 2,
111
             &rl->table_vlc[0][0], 4, 2);
112

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

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

    
148
    for(i=0; i<128; i++){
149
        int level= i-64;
150
        int run;
151
        for(run=0; run<64; run++){
152
            int len, bits, code;
153
            
154
            int alevel= ABS(level);
155
            int sign= (level>>31)&1;
156

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

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

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

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

    
191

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

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

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

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

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

    
221
    if(find_frame_rate_index(s) < 0){
222
        if(s->strict_std_compliance >=0){
223
            av_log(avctx, AV_LOG_ERROR, "MPEG1/2 doesnt support %d/%d fps\n", avctx->frame_rate, avctx->frame_rate_base);
224
            return -1;
225
        }else{
226
            av_log(avctx, AV_LOG_INFO, "MPEG1/2 doesnt support %d/%d fps, there may be AV sync issues\n", avctx->frame_rate, avctx->frame_rate_base);
227
        }
228
    }
229
    
230
    return 0;
231
}
232

    
233
static void put_header(MpegEncContext *s, int header)
234
{
235
    align_put_bits(&s->pb);
236
    put_bits(&s->pb, 16, header>>16);
237
    put_bits(&s->pb, 16, header&0xFFFF);
238
}
239

    
240
/* put sequence header if needed */
241
static void mpeg1_encode_sequence_header(MpegEncContext *s)
242
{
243
        unsigned int vbv_buffer_size;
244
        unsigned int fps, v;
245
        int n, i;
246
        uint64_t time_code;
247
        float best_aspect_error= 1E10;
248
        float aspect_ratio= av_q2d(s->avctx->sample_aspect_ratio);
249
        int constraint_parameter_flag;
250
        
251
        if(aspect_ratio==0.0) aspect_ratio= 1.0; //pixel aspect 1:1 (VGA)
252
        
253
        if (s->current_picture.key_frame) {
254
            AVRational framerate= frame_rate_tab[s->frame_rate_index];
255

    
256
            /* mpeg1 header repeated every gop */
257
            put_header(s, SEQ_START_CODE);
258
 
259
            put_bits(&s->pb, 12, s->width);
260
            put_bits(&s->pb, 12, s->height);
261
            
262
            for(i=1; i<15; i++){
263
                float error= aspect_ratio;
264
                if(s->codec_id == CODEC_ID_MPEG1VIDEO || i <=1)
265
                    error-= 1.0/mpeg1_aspect[i];
266
                else
267
                    error-= av_q2d(mpeg2_aspect[i])*s->height/s->width;
268
             
269
                error= ABS(error);
270
                
271
                if(error < best_aspect_error){
272
                    best_aspect_error= error;
273
                    s->aspect_ratio_info= i;
274
                }
275
            }
276
            
277
            put_bits(&s->pb, 4, s->aspect_ratio_info);
278
            put_bits(&s->pb, 4, s->frame_rate_index);
279
            
280
            if(s->avctx->rc_max_rate){
281
                v = (s->avctx->rc_max_rate + 399) / 400;
282
                if (v > 0x3ffff && s->codec_id == CODEC_ID_MPEG1VIDEO)
283
                    v = 0x3ffff;
284
            }else{
285
                v= 0x3FFFF;
286
            }
287

    
288
            if(s->avctx->rc_buffer_size)
289
                vbv_buffer_size = s->avctx->rc_buffer_size;
290
            else
291
                /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */
292
                vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
293
            vbv_buffer_size= (vbv_buffer_size + 16383) / 16384;
294

    
295
            put_bits(&s->pb, 18, v & 0x3FFFF);
296
            put_bits(&s->pb, 1, 1); /* marker */
297
            put_bits(&s->pb, 10, vbv_buffer_size & 0x3FF);
298

    
299
            constraint_parameter_flag= 
300
                s->width <= 768 && s->height <= 576 && 
301
                s->mb_width * s->mb_height <= 396 &&
302
                s->mb_width * s->mb_height * framerate.num <= framerate.den*396*25 &&
303
                framerate.num <= framerate.den*30 &&
304
                vbv_buffer_size <= 20 &&
305
                v <= 1856000/400 &&
306
                s->codec_id == CODEC_ID_MPEG1VIDEO;
307
                
308
            put_bits(&s->pb, 1, constraint_parameter_flag);
309
            
310
            ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
311
            ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
312

    
313
            if(s->codec_id == CODEC_ID_MPEG2VIDEO){
314
                put_header(s, EXT_START_CODE);
315
                put_bits(&s->pb, 4, 1); //seq ext
316
                put_bits(&s->pb, 1, 0); //esc
317
                put_bits(&s->pb, 3, 4); //profile
318
                put_bits(&s->pb, 4, 8); //level
319
                put_bits(&s->pb, 1, s->progressive_sequence);
320
                put_bits(&s->pb, 2, 1); //chroma format 4:2:0
321
                put_bits(&s->pb, 2, 0); //horizontal size ext
322
                put_bits(&s->pb, 2, 0); //vertical size ext
323
                put_bits(&s->pb, 12, v>>18); //bitrate ext
324
                put_bits(&s->pb, 1, 1); //marker
325
                put_bits(&s->pb, 8, vbv_buffer_size >>10); //vbv buffer ext
326
                put_bits(&s->pb, 1, s->low_delay);
327
                put_bits(&s->pb, 2, 0); // frame_rate_ext_n
328
                put_bits(&s->pb, 5, 0); // frame_rate_ext_d
329
            }
330
            
331
            put_header(s, GOP_START_CODE);
332
            put_bits(&s->pb, 1, 0); /* do drop frame */
333
            /* time code : we must convert from the real frame rate to a
334
               fake mpeg frame rate in case of low frame rate */
335
            fps = (framerate.num + framerate.den/2)/ framerate.den;
336
            time_code = s->current_picture_ptr->coded_picture_number;
337

    
338
            s->gop_picture_number = time_code;
339
            put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
340
            put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
341
            put_bits(&s->pb, 1, 1);
342
            put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
343
            put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
344
            put_bits(&s->pb, 1, !!(s->flags & CODEC_FLAG_CLOSED_GOP));
345
            put_bits(&s->pb, 1, 0); /* broken link */
346
        }
347
}
348

    
349
static inline void encode_mb_skip_run(MpegEncContext *s, int run){
350
    while (run >= 33) {
351
        put_bits(&s->pb, 11, 0x008);
352
        run -= 33;
353
    }
354
    put_bits(&s->pb, mbAddrIncrTable[run][1], 
355
             mbAddrIncrTable[run][0]);
356
}
357
#endif //CONFIG_ENCODERS
358

    
359
static void common_init(MpegEncContext *s)
360
{
361
int i;
362

    
363
    s->y_dc_scale_table=
364
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
365

    
366
    if(!s->encoding)    
367
    for(i=0;i<64;i++)
368
       s->dsp.idct_permutation[i]=i;
369
}
370

    
371
void ff_mpeg1_clean_buffers(MpegEncContext *s){
372
    s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
373
    s->last_dc[1] = s->last_dc[0];
374
    s->last_dc[2] = s->last_dc[0];
375
    memset(s->last_mv, 0, sizeof(s->last_mv));
376
}
377

    
378
#ifdef CONFIG_ENCODERS
379

    
380
void ff_mpeg1_encode_slice_header(MpegEncContext *s){
381
    put_header(s, SLICE_MIN_START_CODE + s->mb_y);
382
    put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
383
    put_bits(&s->pb, 1, 0); /* slice extra information */
384
}
385

    
386
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
387
{
388
    mpeg1_encode_sequence_header(s);
389

    
390
    /* mpeg1 picture header */
391
    put_header(s, PICTURE_START_CODE);
392
    /* temporal reference */
393

    
394
    // RAL: s->picture_number instead of s->fake_picture_number
395
    put_bits(&s->pb, 10, (s->picture_number - 
396
                          s->gop_picture_number) & 0x3ff); 
397
    put_bits(&s->pb, 3, s->pict_type);
398

    
399
    s->vbv_delay_ptr= s->pb.buf + put_bits_count(&s->pb)/8;
400
    put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
401
    
402
    // RAL: Forward f_code also needed for B frames
403
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
404
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
405
        if(s->codec_id == CODEC_ID_MPEG1VIDEO)
406
            put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
407
        else
408
            put_bits(&s->pb, 3, 7); /* forward_f_code */
409
    }
410
    
411
    // RAL: Backward f_code necessary for B frames
412
    if (s->pict_type == B_TYPE) {
413
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
414
        if(s->codec_id == CODEC_ID_MPEG1VIDEO)
415
            put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
416
        else
417
            put_bits(&s->pb, 3, 7); /* backward_f_code */
418
    }
419

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

    
422
    s->frame_pred_frame_dct = 1;
423
    if(s->codec_id == CODEC_ID_MPEG2VIDEO){
424
        put_header(s, EXT_START_CODE);
425
        put_bits(&s->pb, 4, 8); //pic ext
426
        if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
427
            put_bits(&s->pb, 4, s->f_code);
428
            put_bits(&s->pb, 4, s->f_code);
429
        }else{
430
            put_bits(&s->pb, 8, 255);
431
        }
432
        if (s->pict_type == B_TYPE) {
433
            put_bits(&s->pb, 4, s->b_code);
434
            put_bits(&s->pb, 4, s->b_code);
435
        }else{
436
            put_bits(&s->pb, 8, 255);
437
        }
438
        put_bits(&s->pb, 2, s->intra_dc_precision);
439
        
440
        assert(s->picture_structure == PICT_FRAME);
441
        put_bits(&s->pb, 2, s->picture_structure);
442
        if (s->progressive_sequence) {
443
            put_bits(&s->pb, 1, 0); /* no repeat */
444
        } else {
445
            put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
446
        }
447
        /* XXX: optimize the generation of this flag with entropy
448
           measures */
449
        s->frame_pred_frame_dct = s->progressive_sequence;
450
        
451
        put_bits(&s->pb, 1, s->frame_pred_frame_dct);
452
        put_bits(&s->pb, 1, s->concealment_motion_vectors);
453
        put_bits(&s->pb, 1, s->q_scale_type);
454
        put_bits(&s->pb, 1, s->intra_vlc_format);
455
        put_bits(&s->pb, 1, s->alternate_scan);
456
        put_bits(&s->pb, 1, s->repeat_first_field);
457
        put_bits(&s->pb, 1, s->chroma_420_type=1);
458
        s->progressive_frame = s->progressive_sequence;
459
        put_bits(&s->pb, 1, s->progressive_frame);
460
        put_bits(&s->pb, 1, 0); //composite_display_flag
461
    }
462
    if(s->flags & CODEC_FLAG_SVCD_SCAN_OFFSET){
463
        int i;
464

    
465
        put_header(s, USER_START_CODE);
466
        for(i=0; i<sizeof(svcd_scan_offset_placeholder); i++){
467
            put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
468
        }
469
    }
470
    
471
    s->mb_y=0;
472
    ff_mpeg1_encode_slice_header(s);
473
}
474

    
475
static inline void put_mb_modes(MpegEncContext *s, int n, int bits, 
476
                                int has_mv, int field_motion)
477
{
478
    put_bits(&s->pb, n, bits);
479
    if (!s->frame_pred_frame_dct) {
480
        if (has_mv) 
481
            put_bits(&s->pb, 2, 2 - field_motion); /* motion_type: frame/field */
482
        put_bits(&s->pb, 1, s->interlaced_dct);
483
    }
484
}
485

    
486
void mpeg1_encode_mb(MpegEncContext *s,
487
                     DCTELEM block[6][64],
488
                     int motion_x, int motion_y)
489
{
490
    int i, cbp;
491
    const int mb_x = s->mb_x;
492
    const int mb_y = s->mb_y;
493
    const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
494

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

    
582
                if (cbp) {
583
                    if(s->dquant){
584
                        put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
585
                        put_bits(&s->pb, 5, s->qscale);
586
                    }else{
587
                        put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
588
                    }
589
                } else {
590
                    put_bits(&s->pb, 3, 1); /* motion only */
591
                    put_bits(&s->pb, 2, 1); /* motion_type: field */
592
                    s->qscale -= s->dquant;
593
                }
594
                s->misc_bits+= get_bits_diff(s);
595
                for(i=0; i<2; i++){
596
                    put_bits(&s->pb, 1, s->field_select[0][i]);
597
                    mpeg1_encode_motion(s, s->mv[0][i][0] -  s->last_mv[0][i][0]    , s->f_code);
598
                    mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code);
599
                    s->last_mv[0][i][0]=   s->mv[0][i][0];
600
                    s->last_mv[0][i][1]= 2*s->mv[0][i][1];
601
                }
602
                s->mv_bits+= get_bits_diff(s);
603
            }
604
            if(cbp)
605
                put_bits(&s->pb, mbPatTable[cbp][1], mbPatTable[cbp][0]);
606
            s->f_count++;
607
        } else{  
608
            static const int mb_type_len[4]={0,3,4,2}; //bak,for,bi
609

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

    
699
// RAL: Parameter added: f_or_b_code
700
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
701
{
702
    int code, bit_size, l, m, bits, range, sign;
703

    
704
    if (val == 0) {
705
        /* zero vector */
706
        code = 0;
707
        put_bits(&s->pb,
708
                 mbMotionVectorTable[0][1], 
709
                 mbMotionVectorTable[0][0]); 
710
    } else {
711
        bit_size = f_or_b_code - 1;
712
        range = 1 << bit_size;
713
        /* modulo encoding */
714
        l = 16 * range;
715
        m = 2 * l;
716
        if (val < -l) {
717
            val += m;
718
        } else if (val >= l) {
719
            val -= m;
720
        }
721

    
722
        if (val >= 0) {
723
            val--;
724
            code = (val >> bit_size) + 1;
725
            bits = val & (range - 1);
726
            sign = 0;
727
        } else {
728
            val = -val;
729
            val--;
730
            code = (val >> bit_size) + 1;
731
            bits = val & (range - 1);
732
            sign = 1;
733
        }
734

    
735
        assert(code > 0 && code <= 16);
736

    
737
        put_bits(&s->pb,
738
                 mbMotionVectorTable[code][1], 
739
                 mbMotionVectorTable[code][0]); 
740

    
741
        put_bits(&s->pb, 1, sign);
742
        if (bit_size > 0) {
743
            put_bits(&s->pb, bit_size, bits);
744
        }
745
    }
746
}
747

    
748
void ff_mpeg1_encode_init(MpegEncContext *s)
749
{
750
    static int done=0;
751

    
752
    common_init(s);
753

    
754
    if(!done){
755
        int f_code;
756
        int mv;
757
        int i;
758

    
759
        done=1;
760
        init_rl(&rl_mpeg1);
761

    
762
        for(i=0; i<64; i++)
763
        {
764
                mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
765
                mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
766
        }
767
        
768
        init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_bits, uni_mpeg1_ac_vlc_len);
769

    
770
        /* build unified dc encoding tables */
771
        for(i=-255; i<256; i++)
772
        {
773
                int adiff, index;
774
                int bits, code;
775
                int diff=i;
776

    
777
                adiff = ABS(diff);
778
                if(diff<0) diff--;
779
                index = vlc_dc_table[adiff];
780

    
781
                bits= vlc_dc_lum_bits[index] + index;
782
                code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
783
                mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
784
                
785
                bits= vlc_dc_chroma_bits[index] + index;
786
                code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
787
                mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
788
        }
789

    
790
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
791

    
792
        for(f_code=1; f_code<=MAX_FCODE; f_code++){
793
            for(mv=-MAX_MV; mv<=MAX_MV; mv++){
794
                int len;
795

    
796
                if(mv==0) len= mbMotionVectorTable[0][1];
797
                else{
798
                    int val, bit_size, range, code;
799

    
800
                    bit_size = f_code - 1;
801
                    range = 1 << bit_size;
802

    
803
                    val=mv;
804
                    if (val < 0) 
805
                        val = -val;
806
                    val--;
807
                    code = (val >> bit_size) + 1;
808
                    if(code<17){
809
                        len= mbMotionVectorTable[code][1] + 1 + bit_size;
810
                    }else{
811
                        len= mbMotionVectorTable[16][1] + 2 + bit_size;
812
                    }
813
                }
814

    
815
                mv_penalty[f_code][mv+MAX_MV]= len;
816
            }
817
        }
818
        
819

    
820
        for(f_code=MAX_FCODE; f_code>0; f_code--){
821
            for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
822
                fcode_tab[mv+MAX_MV]= f_code;
823
            }
824
        }
825
    }
826
    s->me.mv_penalty= mv_penalty;
827
    s->fcode_tab= fcode_tab;
828
    if(s->codec_id == CODEC_ID_MPEG1VIDEO){
829
        s->min_qcoeff=-255;
830
        s->max_qcoeff= 255;
831
    }else{
832
        s->min_qcoeff=-2047;
833
        s->max_qcoeff= 2047;
834
    }
835
    s->intra_ac_vlc_length=
836
    s->inter_ac_vlc_length=
837
    s->intra_ac_vlc_last_length=
838
    s->inter_ac_vlc_last_length= uni_mpeg1_ac_vlc_len;
839
}
840

    
841
static inline void encode_dc(MpegEncContext *s, int diff, int component)
842
{
843
    if (component == 0) {
844
        put_bits(
845
            &s->pb, 
846
            mpeg1_lum_dc_uni[diff+255]&0xFF,
847
            mpeg1_lum_dc_uni[diff+255]>>8);
848
    } else {
849
        put_bits(
850
            &s->pb, 
851
            mpeg1_chr_dc_uni[diff+255]&0xFF,
852
            mpeg1_chr_dc_uni[diff+255]>>8);
853
    }
854
}
855

    
856
static void mpeg1_encode_block(MpegEncContext *s, 
857
                               DCTELEM *block, 
858
                               int n)
859
{
860
    int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
861
    int code, component;
862
//    RLTable *rl = &rl_mpeg1;
863

    
864
    last_index = s->block_last_index[n];
865

    
866
    /* DC coef */
867
    if (s->mb_intra) {
868
        component = (n <= 3 ? 0 : n - 4 + 1);
869
        dc = block[0]; /* overflow is impossible */
870
        diff = dc - s->last_dc[component];
871
        encode_dc(s, diff, component);
872
        s->last_dc[component] = dc;
873
        i = 1;
874
/*
875
        if (s->intra_vlc_format)
876
            rl = &rl_mpeg2;
877
        else
878
            rl = &rl_mpeg1;
879
*/
880
    } else {
881
        /* encode the first coefficient : needs to be done here because
882
           it is handled slightly differently */
883
        level = block[0];
884
        if (abs(level) == 1) {
885
                code = ((uint32_t)level >> 31); /* the sign bit */
886
                put_bits(&s->pb, 2, code | 0x02);
887
                i = 1;
888
        } else {
889
            i = 0;
890
            last_non_zero = -1;
891
            goto next_coef;
892
        }
893
    }
894

    
895
    /* now quantify & encode AC coefs */
896
    last_non_zero = i - 1;
897

    
898
    for(;i<=last_index;i++) {
899
        j = s->intra_scantable.permutated[i];
900
        level = block[j];
901
    next_coef:
902
#if 0
903
        if (level != 0)
904
            dprintf("level[%d]=%d\n", i, level);
905
#endif            
906
        /* encode using VLC */
907
        if (level != 0) {
908
            run = i - last_non_zero - 1;
909
            
910
            alevel= level;
911
            MASK_ABS(sign, alevel)
912
            sign&=1;
913

    
914
//            code = get_rl_index(rl, 0, run, alevel);
915
            if (alevel <= mpeg1_max_level[0][run]){
916
                code= mpeg1_index_run[0][run] + alevel - 1;
917
                    /* store the vlc & sign at once */
918
                put_bits(&s->pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign);
919
            } else {
920
                /* escape seems to be pretty rare <5% so i dont optimize it */
921
                put_bits(&s->pb, mpeg1_vlc[111/*rl->n*/][1], mpeg1_vlc[111/*rl->n*/][0]);
922
                /* escape: only clip in this case */
923
                put_bits(&s->pb, 6, run);
924
                if(s->codec_id == CODEC_ID_MPEG1VIDEO){
925
                    if (alevel < 128) {
926
                        put_bits(&s->pb, 8, level & 0xff);
927
                    } else {
928
                        if (level < 0) {
929
                            put_bits(&s->pb, 16, 0x8001 + level + 255);
930
                        } else {
931
                            put_bits(&s->pb, 16, level & 0xffff);
932
                        }
933
                    }
934
                }else{
935
                    put_bits(&s->pb, 12, level & 0xfff);
936
                }
937
            }
938
            last_non_zero = i;
939
        }
940
    }
941
    /* end of block */
942
    put_bits(&s->pb, 2, 0x2);
943
}
944
#endif //CONFIG_ENCODERS
945

    
946
/******************************************/
947
/* decoding */
948

    
949
static VLC dc_lum_vlc;
950
static VLC dc_chroma_vlc;
951
static VLC mv_vlc;
952
static VLC mbincr_vlc;
953
static VLC mb_ptype_vlc;
954
static VLC mb_btype_vlc;
955
static VLC mb_pat_vlc;
956

    
957
static void init_vlcs()
958
{
959
    static int done = 0;
960

    
961
    if (!done) {
962
        done = 1;
963

    
964
        init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12, 
965
                 vlc_dc_lum_bits, 1, 1,
966
                 vlc_dc_lum_code, 2, 2);
967
        init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12, 
968
                 vlc_dc_chroma_bits, 1, 1,
969
                 vlc_dc_chroma_code, 2, 2);
970
        init_vlc(&mv_vlc, MV_VLC_BITS, 17, 
971
                 &mbMotionVectorTable[0][1], 2, 1,
972
                 &mbMotionVectorTable[0][0], 2, 1);
973
        init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36, 
974
                 &mbAddrIncrTable[0][1], 2, 1,
975
                 &mbAddrIncrTable[0][0], 2, 1);
976
        init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 64,
977
                 &mbPatTable[0][1], 2, 1,
978
                 &mbPatTable[0][0], 2, 1);
979
        
980
        init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7, 
981
                 &table_mb_ptype[0][1], 2, 1,
982
                 &table_mb_ptype[0][0], 2, 1);
983
        init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11, 
984
                 &table_mb_btype[0][1], 2, 1,
985
                 &table_mb_btype[0][0], 2, 1);
986
        init_rl(&rl_mpeg1);
987
        init_rl(&rl_mpeg2);
988

    
989
        init_2d_vlc_rl(&rl_mpeg1);
990
        init_2d_vlc_rl(&rl_mpeg2);
991
    }
992
}
993

    
994
static inline int get_dmv(MpegEncContext *s)
995
{
996
    if(get_bits1(&s->gb)) 
997
        return 1 - (get_bits1(&s->gb) << 1);
998
    else
999
        return 0;
1000
}
1001

    
1002
static inline int get_qscale(MpegEncContext *s)
1003
{
1004
    int qscale = get_bits(&s->gb, 5);
1005
    if (s->q_scale_type) {
1006
        return non_linear_qscale[qscale];
1007
    } else {
1008
        return qscale << 1;
1009
    }
1010
}
1011

    
1012
/* motion type (for mpeg2) */
1013
#define MT_FIELD 1
1014
#define MT_FRAME 2
1015
#define MT_16X8  2
1016
#define MT_DMV   3
1017

    
1018
static int mpeg_decode_mb(MpegEncContext *s,
1019
                          DCTELEM block[12][64])
1020
{
1021
    int i, j, k, cbp, val, mb_type, motion_type;
1022
    
1023
    dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
1024

    
1025
    assert(s->mb_skiped==0);
1026

    
1027
    if (s->mb_skip_run-- != 0) {
1028
        if(s->pict_type == I_TYPE){
1029
            av_log(s->avctx, AV_LOG_ERROR, "skiped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1030
            return -1;
1031
        }
1032
    
1033
        /* skip mb */
1034
        s->mb_intra = 0;
1035
        for(i=0;i<12;i++)
1036
            s->block_last_index[i] = -1;
1037
        if(s->picture_structure == PICT_FRAME)
1038
            s->mv_type = MV_TYPE_16X16;
1039
        else
1040
            s->mv_type = MV_TYPE_FIELD;
1041
        if (s->pict_type == P_TYPE) {
1042
            /* if P type, zero motion vector is implied */
1043
            s->mv_dir = MV_DIR_FORWARD;
1044
            s->mv[0][0][0] = s->mv[0][0][1] = 0;
1045
            s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1046
            s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1047
            s->field_select[0][0]= s->picture_structure - 1;
1048
            s->mb_skiped = 1;
1049
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1050
        } else {
1051
            /* if B type, reuse previous vectors and directions */
1052
            s->mv[0][0][0] = s->last_mv[0][0][0];
1053
            s->mv[0][0][1] = s->last_mv[0][0][1];
1054
            s->mv[1][0][0] = s->last_mv[1][0][0];
1055
            s->mv[1][0][1] = s->last_mv[1][0][1];
1056

    
1057
            s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= 
1058
                s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1] | MB_TYPE_SKIP;
1059
//            assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
1060

    
1061
            if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0) 
1062
                s->mb_skiped = 1;
1063
        }
1064

    
1065
        return 0;
1066
    }
1067

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

    
1107
        if (IS_QUANT(mb_type))
1108
            s->qscale = get_qscale(s);
1109
        
1110
        if (s->concealment_motion_vectors) {
1111
            /* just parse them */
1112
            if (s->picture_structure != PICT_FRAME) 
1113
                skip_bits1(&s->gb); /* field select */
1114
            
1115
            s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] = 
1116
                mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
1117
            s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] = 
1118
                mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
1119

    
1120
            skip_bits1(&s->gb); /* marker */
1121
        }else
1122
            memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
1123
        s->mb_intra = 1;
1124
#ifdef HAVE_XVMC
1125
        //one 1 we memcpy blocks in xvmcvideo
1126
        if(s->avctx->xvmc_acceleration > 1){
1127
            XVMC_pack_pblocks(s,-1);//inter are always full blocks
1128
            if(s->swap_uv){
1129
                exchange_uv(s);
1130
            }
1131
        }
1132
#endif
1133

    
1134
        if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1135
            for(i=0;i<4+(1<<s->chroma_format);i++) {
1136
                if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0)
1137
                    return -1;
1138
            }
1139
        } else {
1140
            for(i=0;i<6;i++) {
1141
                if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 0)
1142
                    return -1;
1143
            }
1144
        }
1145
    } else {
1146
        if (mb_type & MB_TYPE_ZERO_MV){
1147
            assert(mb_type & MB_TYPE_CBP);
1148

    
1149
            /* compute dct type */
1150
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1151
                !s->frame_pred_frame_dct) {
1152
                s->interlaced_dct = get_bits1(&s->gb);
1153
            }
1154

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

    
1158
            s->mv_dir = MV_DIR_FORWARD;
1159
            if(s->picture_structure == PICT_FRAME)
1160
                s->mv_type = MV_TYPE_16X16;
1161
            else{
1162
                s->mv_type = MV_TYPE_FIELD;
1163
                mb_type |= MB_TYPE_INTERLACED;
1164
                s->field_select[0][0]= s->picture_structure - 1;
1165
            }
1166
            s->last_mv[0][0][0] = 0;
1167
            s->last_mv[0][0][1] = 0;
1168
            s->last_mv[0][1][0] = 0;
1169
            s->last_mv[0][1][1] = 0;
1170
            s->mv[0][0][0] = 0;
1171
            s->mv[0][0][1] = 0;
1172
        }else{
1173
            assert(mb_type & MB_TYPE_L0L1);
1174
//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
1175
            /* get additionnal motion vector type */
1176
            if (s->frame_pred_frame_dct) 
1177
                motion_type = MT_FRAME;
1178
            else{
1179
                motion_type = get_bits(&s->gb, 2);
1180
            }
1181

    
1182
            /* compute dct type */
1183
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1184
                !s->frame_pred_frame_dct && HAS_CBP(mb_type)) {
1185
                s->interlaced_dct = get_bits1(&s->gb);
1186
            }
1187

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

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

    
1260
                            mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 
1261
                                                    s->last_mv[i][0][0]);
1262
                            s->last_mv[i][0][0] = mx;
1263
                            s->last_mv[i][1][0] = mx;
1264
                            dmx = get_dmv(s);
1265
                            my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 
1266
                                                    s->last_mv[i][0][1] >> 1);
1267
                            dmy = get_dmv(s);
1268
                            s->mv_type = MV_TYPE_DMV;
1269

    
1270

    
1271
                            s->last_mv[i][0][1] = my<<1;
1272
                            s->last_mv[i][1][1] = my<<1;
1273

    
1274
                            s->mv[i][0][0] = mx;
1275
                            s->mv[i][0][1] = my;
1276
                            s->mv[i][1][0] = mx;//not used
1277
                            s->mv[i][1][1] = my;//not used
1278

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

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

    
1285
                                /* top -> top pred */
1286
                                s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1287
                                s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1288
                                m = 4 - m;
1289
                                s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1290
                                s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1291
                            } else {
1292
                                mb_type |= MB_TYPE_16x16;
1293

    
1294
                                s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
1295
                                s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
1296
                                if(s->picture_structure == PICT_TOP_FIELD)
1297
                                    s->mv[i][2][1]--;
1298
                                else 
1299
                                    s->mv[i][2][1]++;
1300
                            }
1301
                        }
1302
                        break;
1303
                    default:
1304
                        av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
1305
                        return -1;
1306
                    }
1307
                }
1308
            }
1309
        }
1310
        
1311
        s->mb_intra = 0;
1312

    
1313
        if (HAS_CBP(mb_type)) {
1314
            cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1315
            if (cbp < 0 || ((cbp == 0) && (s->chroma_format < 2)) ){
1316
                av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
1317
                return -1;
1318
            }
1319
            if(s->chroma_format == 2){//CHROMA422
1320
                 cbp|= ( get_bits(&s->gb,2) ) << 6;
1321
            }else
1322
            if(s->chroma_format >  2){//CHROMA444
1323
                 cbp|= ( get_bits(&s->gb,6) ) << 6;
1324
            }
1325

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

    
1336
            if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1337
                for(i=0;i<6;i++) {
1338
                    if (cbp & (1<<(5-i)) ) {
1339
                        if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
1340
                            return -1;
1341
                    } else {
1342
                        s->block_last_index[i] = -1;
1343
                    }
1344
                }
1345
                if (s->chroma_format >= 2) {
1346
                    if (s->chroma_format == 2) {//CHROMA_422)
1347
                        for(i=6;i<8;i++) {
1348
                            if (cbp & (1<<(6+7-i)) ) {
1349
                                if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
1350
                                    return -1;
1351
                            } else {
1352
                                s->block_last_index[i] = -1;
1353
                            }
1354
                        }
1355
                    }else{ /*CHROMA_444*/
1356
                        for(i=6;i<12;i++) {
1357
                            if (cbp & (1<<(6+11-i)) ) {
1358
                                if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
1359
                                    return -1;
1360
                            } else {
1361
                                s->block_last_index[i] = -1;
1362
                            }
1363
                        }
1364
                    }
1365
                }
1366
            } else {
1367
                for(i=0;i<6;i++) {
1368
                    if (cbp & 32) {
1369
                        if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 0)
1370
                            return -1;
1371
                    } else {
1372
                        s->block_last_index[i] = -1;
1373
                    }
1374
                    cbp+=cbp;
1375
                }
1376
            }
1377
        }else{
1378
            for(i=0;i<6;i++)
1379
                s->block_last_index[i] = -1;
1380
        }
1381
    }
1382

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

    
1385
    return 0;
1386
}
1387

    
1388
/* as h263, but only 17 codes */
1389
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
1390
{
1391
    int code, sign, val, l, shift;
1392

    
1393
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
1394
    if (code == 0) {
1395
        return pred;
1396
    }
1397
    if (code < 0) {
1398
        return 0xffff;
1399
    }
1400

    
1401
    sign = get_bits1(&s->gb);
1402
    shift = fcode - 1;
1403
    val = code;
1404
    if (shift) {
1405
        val = (val - 1) << shift;
1406
        val |= get_bits(&s->gb, shift);
1407
        val++;
1408
    }
1409
    if (sign)
1410
        val = -val;
1411
    val += pred;
1412
    
1413
    /* modulo decoding */
1414
    l = 1 << (shift+4);
1415
    val = ((val + l)&(l*2-1)) - l;
1416
    return val;
1417
}
1418

    
1419
static inline int decode_dc(GetBitContext *gb, int component)
1420
{
1421
    int code, diff;
1422

    
1423
    if (component == 0) {
1424
        code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1425
    } else {
1426
        code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1427
    }
1428
    if (code < 0){
1429
        av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
1430
        return 0xffff;
1431
    }
1432
    if (code == 0) {
1433
        diff = 0;
1434
    } else {
1435
        diff = get_xbits(gb, code);
1436
    }
1437
    return diff;
1438
}
1439

    
1440
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
1441
                               DCTELEM *block, 
1442
                               int n)
1443
{
1444
    int level, dc, diff, i, j, run;
1445
    int component;
1446
    RLTable *rl = &rl_mpeg1;
1447
    uint8_t * const scantable= s->intra_scantable.permutated;
1448
    const uint16_t *quant_matrix= s->intra_matrix;
1449
    const int qscale= s->qscale;
1450

    
1451
    /* DC coef */
1452
    component = (n <= 3 ? 0 : n - 4 + 1);
1453
    diff = decode_dc(&s->gb, component);
1454
    if (diff >= 0xffff)
1455
        return -1;
1456
    dc = s->last_dc[component];
1457
    dc += diff;
1458
    s->last_dc[component] = dc;
1459
    block[0] = dc<<3;
1460
    dprintf("dc=%d diff=%d\n", dc, diff);
1461
    i = 0;
1462
    {
1463
        OPEN_READER(re, &s->gb);    
1464
        /* now quantify & encode AC coefs */
1465
        for(;;) {
1466
            UPDATE_CACHE(re, &s->gb);
1467
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1468
            
1469
            if(level == 127){
1470
                break;
1471
            } else if(level != 0) {
1472
                i += run;
1473
                j = scantable[i];
1474
                level= (level*qscale*quant_matrix[j])>>4;
1475
                level= (level-1)|1;
1476
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1477
                LAST_SKIP_BITS(re, &s->gb, 1);
1478
            } else {
1479
                /* escape */
1480
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1481
                UPDATE_CACHE(re, &s->gb);
1482
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1483
                if (level == -128) {
1484
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1485
                } else if (level == 0) {
1486
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1487
                }
1488
                i += run;
1489
                j = scantable[i];
1490
                if(level<0){
1491
                    level= -level;
1492
                    level= (level*qscale*quant_matrix[j])>>4;
1493
                    level= (level-1)|1;
1494
                    level= -level;
1495
                }else{
1496
                    level= (level*qscale*quant_matrix[j])>>4;
1497
                    level= (level-1)|1;
1498
                }
1499
            }
1500
            if (i > 63){
1501
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1502
                return -1;
1503
            }
1504

    
1505
            block[j] = level;
1506
        }
1507
        CLOSE_READER(re, &s->gb);
1508
    }
1509
    s->block_last_index[n] = i;
1510
   return 0;
1511
}
1512

    
1513
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
1514
                               DCTELEM *block, 
1515
                               int n)
1516
{
1517
    int level, i, j, run;
1518
    RLTable *rl = &rl_mpeg1;
1519
    uint8_t * const scantable= s->intra_scantable.permutated;
1520
    const uint16_t *quant_matrix= s->inter_matrix;
1521
    const int qscale= s->qscale;
1522

    
1523
    {
1524
        int v;
1525
        OPEN_READER(re, &s->gb);
1526
        i = -1;
1527
        /* special case for the first coef. no need to add a second vlc table */
1528
        UPDATE_CACHE(re, &s->gb);
1529
        v= SHOW_UBITS(re, &s->gb, 2);
1530
        if (v & 2) {
1531
            LAST_SKIP_BITS(re, &s->gb, 2);
1532
            level= (3*qscale*quant_matrix[0])>>5;
1533
            level= (level-1)|1;
1534
            if(v&1)
1535
                level= -level;
1536
            block[0] = level;
1537
            i++;
1538
        }
1539

    
1540
        /* now quantify & encode AC coefs */
1541
        for(;;) {
1542
            UPDATE_CACHE(re, &s->gb);
1543
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1544
            
1545
            if(level == 127){
1546
                break;
1547
            } else if(level != 0) {
1548
                i += run;
1549
                j = scantable[i];
1550
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1551
                level= (level-1)|1;
1552
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1553
                LAST_SKIP_BITS(re, &s->gb, 1);
1554
            } else {
1555
                /* escape */
1556
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1557
                UPDATE_CACHE(re, &s->gb);
1558
                level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1559
                if (level == -128) {
1560
                    level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1561
                } else if (level == 0) {
1562
                    level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1563
                }
1564
                i += run;
1565
                j = scantable[i];
1566
                if(level<0){
1567
                    level= -level;
1568
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1569
                    level= (level-1)|1;
1570
                    level= -level;
1571
                }else{
1572
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1573
                    level= (level-1)|1;
1574
                }
1575
            }
1576
            if (i > 63){
1577
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1578
                return -1;
1579
            }
1580

    
1581
            block[j] = level;
1582
        }
1583
        CLOSE_READER(re, &s->gb);
1584
    }
1585
    s->block_last_index[n] = i;
1586
    return 0;
1587
}
1588

    
1589
/* Also does unquantization here, since I will never support mpeg2
1590
   encoding */
1591
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1592
                               DCTELEM *block, 
1593
                               int n)
1594
{
1595
    int level, i, j, run;
1596
    RLTable *rl = &rl_mpeg1;
1597
    uint8_t * const scantable= s->intra_scantable.permutated;
1598
    const uint16_t *quant_matrix;
1599
    const int qscale= s->qscale;
1600
    int mismatch;
1601

    
1602
    mismatch = 1;
1603

    
1604
    {
1605
        int v;
1606
        OPEN_READER(re, &s->gb);
1607
        i = -1;
1608
        if (n < 4)
1609
            quant_matrix = s->inter_matrix;
1610
        else
1611
            quant_matrix = s->chroma_inter_matrix;
1612

    
1613
        /* special case for the first coef. no need to add a second vlc table */
1614
        UPDATE_CACHE(re, &s->gb);
1615
        v= SHOW_UBITS(re, &s->gb, 2);
1616
        if (v & 2) {
1617
            LAST_SKIP_BITS(re, &s->gb, 2);
1618
            level= (3*qscale*quant_matrix[0])>>5;
1619
            if(v&1)
1620
                level= -level;
1621
            block[0] = level;
1622
            mismatch ^= level;
1623
            i++;
1624
        }
1625

    
1626
        /* now quantify & encode AC coefs */
1627
        for(;;) {
1628
            UPDATE_CACHE(re, &s->gb);
1629
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1630
            
1631
            if(level == 127){
1632
                break;
1633
            } else if(level != 0) {
1634
                i += run;
1635
                j = scantable[i];
1636
                level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1637
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1638
                LAST_SKIP_BITS(re, &s->gb, 1);
1639
            } else {
1640
                /* escape */
1641
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1642
                UPDATE_CACHE(re, &s->gb);
1643
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1644

    
1645
                i += run;
1646
                j = scantable[i];
1647
                if(level<0){
1648
                    level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1649
                    level= -level;
1650
                }else{
1651
                    level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1652
                }
1653
            }
1654
            if (i > 63){
1655
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1656
                return -1;
1657
            }
1658
            
1659
            mismatch ^= level;
1660
            block[j] = level;
1661
        }
1662
        CLOSE_READER(re, &s->gb);
1663
    }
1664
    block[63] ^= (mismatch & 1);
1665
    
1666
    s->block_last_index[n] = i;
1667
    return 0;
1668
}
1669

    
1670
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
1671
                               DCTELEM *block, 
1672
                               int n)
1673
{
1674
    int level, dc, diff, i, j, run;
1675
    int component;
1676
    RLTable *rl;
1677
    uint8_t * const scantable= s->intra_scantable.permutated;
1678
    const uint16_t *quant_matrix;
1679
    const int qscale= s->qscale;
1680
    int mismatch;
1681

    
1682
    /* DC coef */
1683
    if (n < 4){
1684
        quant_matrix = s->intra_matrix;
1685
        component = 0; 
1686
    }else{
1687
        quant_matrix = s->chroma_intra_matrix;
1688
        component = (n&1) + 1;
1689
    }
1690
    diff = decode_dc(&s->gb, component);
1691
    if (diff >= 0xffff)
1692
        return -1;
1693
    dc = s->last_dc[component];
1694
    dc += diff;
1695
    s->last_dc[component] = dc;
1696
    block[0] = dc << (3 - s->intra_dc_precision);
1697
    dprintf("dc=%d\n", block[0]);
1698
    mismatch = block[0] ^ 1;
1699
    i = 0;
1700
    if (s->intra_vlc_format)
1701
        rl = &rl_mpeg2;
1702
    else
1703
        rl = &rl_mpeg1;
1704

    
1705
    {
1706
        OPEN_READER(re, &s->gb);    
1707
        /* now quantify & encode AC coefs */
1708
        for(;;) {
1709
            UPDATE_CACHE(re, &s->gb);
1710
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1711
            
1712
            if(level == 127){
1713
                break;
1714
            } else if(level != 0) {
1715
                i += run;
1716
                j = scantable[i];
1717
                level= (level*qscale*quant_matrix[j])>>4;
1718
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1719
                LAST_SKIP_BITS(re, &s->gb, 1);
1720
            } else {
1721
                /* escape */
1722
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1723
                UPDATE_CACHE(re, &s->gb);
1724
                level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1725
                i += run;
1726
                j = scantable[i];
1727
                if(level<0){
1728
                    level= (-level*qscale*quant_matrix[j])>>4;
1729
                    level= -level;
1730
                }else{
1731
                    level= (level*qscale*quant_matrix[j])>>4;
1732
                }
1733
            }
1734
            if (i > 63){
1735
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1736
                return -1;
1737
            }
1738
            
1739
            mismatch^= level;
1740
            block[j] = level;
1741
        }
1742
        CLOSE_READER(re, &s->gb);
1743
    }
1744
    block[63]^= mismatch&1;
1745
    
1746
    s->block_last_index[n] = i;
1747
    return 0;
1748
}
1749

    
1750
typedef struct Mpeg1Context {
1751
    MpegEncContext mpeg_enc_ctx;
1752
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1753
    int repeat_field; /* true if we must repeat the field */
1754
    AVPanScan pan_scan; /** some temporary storage for the panscan */
1755
    int slice_count;
1756
    int swap_uv;//indicate VCR2
1757
    int save_aspect_info;
1758

    
1759
} Mpeg1Context;
1760

    
1761
static int mpeg_decode_init(AVCodecContext *avctx)
1762
{
1763
    Mpeg1Context *s = avctx->priv_data;
1764
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
1765
    
1766
    MPV_decode_defaults(s2);
1767
    
1768
    s->mpeg_enc_ctx.avctx= avctx;
1769
    s->mpeg_enc_ctx.flags= avctx->flags;
1770
    s->mpeg_enc_ctx.flags2= avctx->flags2;
1771
    common_init(&s->mpeg_enc_ctx);
1772
    init_vlcs();
1773

    
1774
    s->mpeg_enc_ctx_allocated = 0;
1775
    s->mpeg_enc_ctx.picture_number = 0;
1776
    s->repeat_field = 0;
1777
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1778
    return 0;
1779
}
1780

    
1781
static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm, 
1782
                                     const uint8_t *new_perm){
1783
uint16_t temp_matrix[64];
1784
int i;
1785

    
1786
    memcpy(temp_matrix,matrix,64*sizeof(uint16_t));
1787
    
1788
    for(i=0;i<64;i++){
1789
        matrix[new_perm[i]] = temp_matrix[old_perm[i]];
1790
    }      
1791
}
1792

    
1793
//Call this function when we know all parameters
1794
//it may be called in different places for mpeg1 and mpeg2
1795
static int mpeg_decode_postinit(AVCodecContext *avctx){
1796
Mpeg1Context *s1 = avctx->priv_data;
1797
MpegEncContext *s = &s1->mpeg_enc_ctx;
1798
uint8_t old_permutation[64];
1799

    
1800

    
1801
    if (
1802
            (s1->mpeg_enc_ctx_allocated == 0)|| 
1803
        avctx->width  != s->width ||
1804
        avctx->height != s->height||
1805
//      s1->save_aspect_info != avctx->aspect_ratio_info||
1806
        0)
1807
    {
1808
    
1809
        if (s1->mpeg_enc_ctx_allocated) {
1810
            MPV_common_end(s);
1811
        }
1812

    
1813
        if( (s->width == 0 )||(s->height == 0))
1814
            return -2;
1815

    
1816
        avctx->width = s->width;
1817
        avctx->height = s->height;
1818
        avctx->bit_rate = s->bit_rate;
1819
        s1->save_aspect_info = s->aspect_ratio_info;
1820

    
1821
     //low_delay may be forced, in this case we will have B frames
1822
     //that behave like P frames
1823
        avctx->has_b_frames = !(s->low_delay);
1824

    
1825
        if(avctx->sub_id==1){//s->codec_id==avctx->codec_id==CODEC_ID
1826
            //mpeg1 fps
1827
            avctx->frame_rate     = frame_rate_tab[s->frame_rate_index].num;
1828
            avctx->frame_rate_base= frame_rate_tab[s->frame_rate_index].den;
1829
            //mpeg1 aspect
1830
            avctx->sample_aspect_ratio= av_d2q(
1831
                    1.0/mpeg1_aspect[s->aspect_ratio_info], 255);
1832

    
1833
        }else{//mpeg2
1834
        //mpeg2 fps
1835
            av_reduce(
1836
                &s->avctx->frame_rate, 
1837
                &s->avctx->frame_rate_base, 
1838
                frame_rate_tab[s->frame_rate_index].num * (s->frame_rate_ext_n+1),
1839
                frame_rate_tab[s->frame_rate_index].den * (s->frame_rate_ext_d+1),
1840
                1<<30);
1841
        //mpeg2 aspect
1842
            if(s->aspect_ratio_info > 1){
1843
                if( (s1->pan_scan.width == 0 )||(s1->pan_scan.height == 0) ){
1844
                    s->avctx->sample_aspect_ratio= 
1845
                        av_div_q(
1846
                         mpeg2_aspect[s->aspect_ratio_info], 
1847
                         (AVRational){s->width, s->height}
1848
                         );
1849
                }else{
1850
                    s->avctx->sample_aspect_ratio= 
1851
                        av_div_q(
1852
                         mpeg2_aspect[s->aspect_ratio_info], 
1853
                         (AVRational){s1->pan_scan.width, s1->pan_scan.height}
1854
                        );
1855
                }
1856
            }else{
1857
                s->avctx->sample_aspect_ratio= 
1858
                    mpeg2_aspect[s->aspect_ratio_info];
1859
            }
1860
        }//mpeg2
1861

    
1862
        if(avctx->xvmc_acceleration){
1863
            avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
1864
        }else{
1865
            if(s->chroma_format <  2){
1866
                avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420);
1867
            }else
1868
            if(s->chroma_format == 2){
1869
                avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_422);
1870
            }else
1871
            if(s->chroma_format >  2){
1872
                avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_444);
1873
            }
1874
        }
1875
        //until then pix_fmt may be changed right after codec init
1876
        if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
1877
            if( avctx->idct_algo == FF_IDCT_AUTO )
1878
                avctx->idct_algo = FF_IDCT_SIMPLE;
1879

    
1880
        //quantization matrixes may need reordering 
1881
        //if dct permutation is changed
1882
        memcpy(old_permutation,s->dsp.idct_permutation,64*sizeof(uint8_t));
1883

    
1884
        if (MPV_common_init(s) < 0)
1885
            return -2;
1886

    
1887
        quant_matrix_rebuild(s->intra_matrix,       old_permutation,s->dsp.idct_permutation);
1888
        quant_matrix_rebuild(s->inter_matrix,       old_permutation,s->dsp.idct_permutation);
1889
        quant_matrix_rebuild(s->chroma_intra_matrix,old_permutation,s->dsp.idct_permutation);
1890
        quant_matrix_rebuild(s->chroma_inter_matrix,old_permutation,s->dsp.idct_permutation);
1891

    
1892
        s1->mpeg_enc_ctx_allocated = 1;
1893
    }
1894
    return 0;
1895
}
1896

    
1897
/* return the 8 bit start code value and update the search
1898
   state. Return -1 if no start code found */
1899
static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
1900
{
1901
    const uint8_t *buf_ptr= *pbuf_ptr;
1902

    
1903
    buf_ptr++; //gurantees that -1 is within the array
1904
    buf_end -= 2; // gurantees that +2 is within the array
1905

    
1906
    while (buf_ptr < buf_end) {
1907
        if(*buf_ptr==0){
1908
            while(buf_ptr < buf_end && buf_ptr[1]==0)
1909
                buf_ptr++;
1910

    
1911
            if(buf_ptr[-1] == 0 && buf_ptr[1] == 1){
1912
                *pbuf_ptr = buf_ptr+3;
1913
                return buf_ptr[2] + 0x100;
1914
            }
1915
        }
1916
        buf_ptr += 2;
1917
    }
1918
    buf_end += 2; //undo the hack above
1919
    
1920
    *pbuf_ptr = buf_end;
1921
    return -1;
1922
}
1923

    
1924
static int mpeg1_decode_picture(AVCodecContext *avctx, 
1925
                                const uint8_t *buf, int buf_size)
1926
{
1927
    Mpeg1Context *s1 = avctx->priv_data;
1928
    MpegEncContext *s = &s1->mpeg_enc_ctx;
1929
    int ref, f_code, vbv_delay;
1930

    
1931
    if(mpeg_decode_postinit(s->avctx) < 0) 
1932
       return -2;
1933

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

    
1936
    ref = get_bits(&s->gb, 10); /* temporal ref */
1937
    s->pict_type = get_bits(&s->gb, 3);
1938

    
1939
    vbv_delay= get_bits(&s->gb, 16);
1940
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
1941
        s->full_pel[0] = get_bits1(&s->gb);
1942
        f_code = get_bits(&s->gb, 3);
1943
        if (f_code == 0)
1944
            return -1;
1945
        s->mpeg_f_code[0][0] = f_code;
1946
        s->mpeg_f_code[0][1] = f_code;
1947
    }
1948
    if (s->pict_type == B_TYPE) {
1949
        s->full_pel[1] = get_bits1(&s->gb);
1950
        f_code = get_bits(&s->gb, 3);
1951
        if (f_code == 0)
1952
            return -1;
1953
        s->mpeg_f_code[1][0] = f_code;
1954
        s->mpeg_f_code[1][1] = f_code;
1955
    }
1956
    s->current_picture.pict_type= s->pict_type;
1957
    s->current_picture.key_frame= s->pict_type == I_TYPE;
1958
    
1959
//    if(avctx->debug & FF_DEBUG_PICT_INFO)
1960
//        av_log(avctx, AV_LOG_DEBUG, "vbv_delay %d, ref %d\n", vbv_delay, ref);
1961
    
1962
    s->y_dc_scale = 8;
1963
    s->c_dc_scale = 8;
1964
    s->first_slice = 1;
1965
    return 0;
1966
}
1967

    
1968
static void mpeg_decode_sequence_extension(MpegEncContext *s)
1969
{
1970
    int horiz_size_ext, vert_size_ext;
1971
    int bit_rate_ext;
1972
    int level, profile;
1973

    
1974
    skip_bits(&s->gb, 1); /* profil and level esc*/
1975
    profile= get_bits(&s->gb, 3);
1976
    level= get_bits(&s->gb, 4);
1977
    s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1978
    s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1979
    horiz_size_ext = get_bits(&s->gb, 2);
1980
    vert_size_ext = get_bits(&s->gb, 2);
1981
    s->width |= (horiz_size_ext << 12);
1982
    s->height |= (vert_size_ext << 12);
1983
    bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1984
    s->bit_rate += (bit_rate_ext << 12) * 400;
1985
    skip_bits1(&s->gb); /* marker */
1986
    s->avctx->rc_buffer_size += get_bits(&s->gb, 8)*1024*16<<10;
1987

    
1988
    s->low_delay = get_bits1(&s->gb);
1989
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
1990

    
1991
    s->frame_rate_ext_n = get_bits(&s->gb, 2);
1992
    s->frame_rate_ext_d = get_bits(&s->gb, 5);
1993

    
1994
    dprintf("sequence extension\n");
1995
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
1996
    s->avctx->sub_id = 2; /* indicates mpeg2 found */
1997

    
1998
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1999
        av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d vbv buffer: %d, bitrate:%d\n", 
2000
               profile, level, s->avctx->rc_buffer_size, s->bit_rate);
2001

    
2002
}
2003

    
2004
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
2005
{
2006
    MpegEncContext *s= &s1->mpeg_enc_ctx;
2007
    int color_description, w, h;
2008

    
2009
    skip_bits(&s->gb, 3); /* video format */
2010
    color_description= get_bits1(&s->gb);
2011
    if(color_description){
2012
        skip_bits(&s->gb, 8); /* color primaries */
2013
        skip_bits(&s->gb, 8); /* transfer_characteristics */
2014
        skip_bits(&s->gb, 8); /* matrix_coefficients */
2015
    }
2016
    w= get_bits(&s->gb, 14);
2017
    skip_bits(&s->gb, 1); //marker
2018
    h= get_bits(&s->gb, 14);
2019
    skip_bits(&s->gb, 1); //marker
2020
    
2021
    s1->pan_scan.width= 16*w;
2022
    s1->pan_scan.height=16*h;
2023
        
2024
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2025
        av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
2026
}
2027

    
2028
static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
2029
{
2030
    MpegEncContext *s= &s1->mpeg_enc_ctx;
2031
    int i,nofco;
2032

    
2033
    nofco = 1;
2034
    if(s->progressive_sequence){
2035
        if(s->repeat_first_field){
2036
            nofco++;
2037
            if(s->top_field_first)
2038
                nofco++;        
2039
        }
2040
    }else{
2041
        if(s->picture_structure == PICT_FRAME){
2042
            nofco++;
2043
            if(s->repeat_first_field)
2044
                nofco++;
2045
        }
2046
    }
2047
    for(i=0; i<nofco; i++){
2048
        s1->pan_scan.position[i][0]= get_sbits(&s->gb, 16);
2049
        skip_bits(&s->gb, 1); //marker
2050
        s1->pan_scan.position[i][1]= get_sbits(&s->gb, 16);
2051
        skip_bits(&s->gb, 1); //marker
2052
    }
2053
   
2054
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2055
        av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n", 
2056
            s1->pan_scan.position[0][0], s1->pan_scan.position[0][1], 
2057
            s1->pan_scan.position[1][0], s1->pan_scan.position[1][1], 
2058
            s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]
2059
        );
2060
}
2061

    
2062
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
2063
{
2064
    int i, v, j;
2065

    
2066
    dprintf("matrix extension\n");
2067

    
2068
    if (get_bits1(&s->gb)) {
2069
        for(i=0;i<64;i++) {
2070
            v = get_bits(&s->gb, 8);
2071
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2072
            s->intra_matrix[j] = v;
2073
            s->chroma_intra_matrix[j] = v;
2074
        }
2075
    }
2076
    if (get_bits1(&s->gb)) {
2077
        for(i=0;i<64;i++) {
2078
            v = get_bits(&s->gb, 8);
2079
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2080
            s->inter_matrix[j] = v;
2081
            s->chroma_inter_matrix[j] = v;
2082
        }
2083
    }
2084
    if (get_bits1(&s->gb)) {
2085
        for(i=0;i<64;i++) {
2086
            v = get_bits(&s->gb, 8);
2087
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2088
            s->chroma_intra_matrix[j] = v;
2089
        }
2090
    }
2091
    if (get_bits1(&s->gb)) {
2092
        for(i=0;i<64;i++) {
2093
            v = get_bits(&s->gb, 8);
2094
            j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2095
            s->chroma_inter_matrix[j] = v;
2096
        }
2097
    }
2098
}
2099

    
2100
static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
2101
{
2102
    s->full_pel[0] = s->full_pel[1] = 0;
2103
    s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
2104
    s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
2105
    s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
2106
    s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
2107
    s->intra_dc_precision = get_bits(&s->gb, 2);
2108
    s->picture_structure = get_bits(&s->gb, 2);
2109
    s->top_field_first = get_bits1(&s->gb);
2110
    s->frame_pred_frame_dct = get_bits1(&s->gb);
2111
    s->concealment_motion_vectors = get_bits1(&s->gb);
2112
    s->q_scale_type = get_bits1(&s->gb);
2113
    s->intra_vlc_format = get_bits1(&s->gb);
2114
    s->alternate_scan = get_bits1(&s->gb);
2115
    s->repeat_first_field = get_bits1(&s->gb);
2116
    s->chroma_420_type = get_bits1(&s->gb);
2117
    s->progressive_frame = get_bits1(&s->gb);
2118

    
2119
    if(s->picture_structure == PICT_FRAME)
2120
        s->first_field=0;
2121
    else{
2122
        s->first_field ^= 1;
2123
        memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
2124
    }
2125
    
2126
    if(s->alternate_scan){
2127
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
2128
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
2129
    }else{
2130
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
2131
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
2132
    }
2133
    
2134
    /* composite display not parsed */
2135
    dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
2136
    dprintf("picture_structure=%d\n", s->picture_structure);
2137
    dprintf("top field first=%d\n", s->top_field_first);
2138
    dprintf("repeat first field=%d\n", s->repeat_first_field);
2139
    dprintf("conceal=%d\n", s->concealment_motion_vectors);
2140
    dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
2141
    dprintf("alternate_scan=%d\n", s->alternate_scan);
2142
    dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
2143
    dprintf("progressive_frame=%d\n", s->progressive_frame);
2144
}
2145

    
2146
static void mpeg_decode_extension(AVCodecContext *avctx, 
2147
                                  const uint8_t *buf, int buf_size)
2148
{
2149
    Mpeg1Context *s1 = avctx->priv_data;
2150
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2151
    int ext_type;
2152

    
2153
    init_get_bits(&s->gb, buf, buf_size*8);
2154
    
2155
    ext_type = get_bits(&s->gb, 4);
2156
    switch(ext_type) {
2157
    case 0x1:
2158
        mpeg_decode_sequence_extension(s);
2159
        break;
2160
    case 0x2:
2161
        mpeg_decode_sequence_display_extension(s1);
2162
        break;
2163
    case 0x3:
2164
        mpeg_decode_quant_matrix_extension(s);
2165
        break;
2166
    case 0x7:
2167
        mpeg_decode_picture_display_extension(s1);
2168
        break;
2169
    case 0x8:
2170
        mpeg_decode_picture_coding_extension(s);
2171
        break;
2172
    }
2173
}
2174

    
2175
static void exchange_uv(MpegEncContext *s){
2176
short * tmp;
2177

    
2178
    tmp = s->pblocks[4];
2179
    s->pblocks[4] = s->pblocks[5];
2180
    s->pblocks[5] = tmp;
2181
}
2182

    
2183
static int mpeg_field_start(MpegEncContext *s){
2184
    AVCodecContext *avctx= s->avctx;
2185
    Mpeg1Context *s1 = (Mpeg1Context*)s;
2186

    
2187
    /* start frame decoding */
2188
    if(s->first_field || s->picture_structure==PICT_FRAME){
2189
        if(MPV_frame_start(s, avctx) < 0)
2190
            return -1;
2191

    
2192
        ff_er_frame_start(s);
2193

    
2194
        /* first check if we must repeat the frame */
2195
        s->current_picture_ptr->repeat_pict = 0;
2196
        if (s->repeat_first_field) {
2197
            if (s->progressive_sequence) {
2198
                if (s->top_field_first)
2199
                    s->current_picture_ptr->repeat_pict = 4;
2200
                else
2201
                    s->current_picture_ptr->repeat_pict = 2;
2202
            } else if (s->progressive_frame) {
2203
                s->current_picture_ptr->repeat_pict = 1;
2204
            }
2205
        }         
2206

    
2207
        *s->current_picture_ptr->pan_scan= s1->pan_scan;
2208
    }else{ //second field
2209
            int i;
2210
            
2211
            if(!s->current_picture_ptr){
2212
                av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
2213
                return -1;
2214
            }
2215
            
2216
            for(i=0; i<4; i++){
2217
                s->current_picture.data[i] = s->current_picture_ptr->data[i];
2218
                if(s->picture_structure == PICT_BOTTOM_FIELD){
2219
                    s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
2220
                } 
2221
            }
2222
    }
2223
#ifdef HAVE_XVMC
2224
// MPV_frame_start will call this function too,
2225
// but we need to call it on every field
2226
    if(s->avctx->xvmc_acceleration)
2227
         XVMC_field_start(s,avctx);
2228
#endif
2229

    
2230
    return 0;
2231
}
2232

    
2233
#define DECODE_SLICE_ERROR -1
2234
#define DECODE_SLICE_OK 0
2235

    
2236
/**
2237
 * decodes a slice. MpegEncContext.mb_y must be set to the MB row from the startcode
2238
 * @return DECODE_SLICE_ERROR if the slice is damaged<br>
2239
 *         DECODE_SLICE_OK if this slice is ok<br>
2240
 */
2241
static int mpeg_decode_slice(Mpeg1Context *s1, int mb_y,
2242
                             const uint8_t **buf, int buf_size)
2243
{
2244
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2245
    AVCodecContext *avctx= s->avctx;
2246
    int ret;
2247
    const int field_pic= s->picture_structure != PICT_FRAME;
2248

    
2249
    s->resync_mb_x=
2250
    s->resync_mb_y= -1;
2251

    
2252
    if (mb_y >= s->mb_height){
2253
        av_log(s->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", s->mb_y, s->mb_height);
2254
        return -1;
2255
    }
2256
    
2257
    init_get_bits(&s->gb, *buf, buf_size*8);
2258

    
2259
    ff_mpeg1_clean_buffers(s);
2260
    s->interlaced_dct = 0;
2261

    
2262
    s->qscale = get_qscale(s);
2263

    
2264
    if(s->qscale == 0){
2265
        av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
2266
        return -1;
2267
    }
2268
    
2269
    /* extra slice info */
2270
    while (get_bits1(&s->gb) != 0) {
2271
        skip_bits(&s->gb, 8);
2272
    }
2273
    
2274
    s->mb_x=0;
2275

    
2276
    for(;;) {
2277
        int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
2278
        if (code < 0){
2279
            av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
2280
            return -1;
2281
        }
2282
        if (code >= 33) {
2283
            if (code == 33) {
2284
                s->mb_x += 33;
2285
            }
2286
            /* otherwise, stuffing, nothing to do */
2287
        } else {
2288
            s->mb_x += code;
2289
            break;
2290
        }
2291
    }
2292

    
2293
    s->resync_mb_x= s->mb_x;
2294
    s->resync_mb_y= s->mb_y= mb_y;
2295
    s->mb_skip_run= 0;
2296
    ff_init_block_index(s);
2297

    
2298
    if (s->mb_y==0 && s->mb_x==0 && (s->first_field || s->picture_structure==PICT_FRAME)) {
2299
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
2300
             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", 
2301
                 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],
2302
                 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), 
2303
                 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"", 
2304
                 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
2305
                 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
2306
        }
2307
    }    
2308
    
2309
    for(;;) {
2310
#ifdef HAVE_XVMC
2311
        //one 1 we memcpy blocks in xvmcvideo
2312
        if(s->avctx->xvmc_acceleration > 1)
2313
            XVMC_init_block(s);//set s->block
2314
#endif
2315

    
2316
        s->dsp.clear_blocks(s->block[0]);
2317

    
2318
        ret = mpeg_decode_mb(s, s->block);
2319
        s->chroma_qscale= s->qscale;
2320

    
2321
        dprintf("ret=%d\n", ret);
2322
        if (ret < 0)
2323
            return -1;
2324

    
2325
        if(s->current_picture.motion_val[0] && !s->encoding){ //note motion_val is normally NULL unless we want to extract the MVs
2326
            const int wrap = field_pic ? 2*s->block_wrap[0] : s->block_wrap[0];
2327
            int xy = s->mb_x*2 + 1 + (s->mb_y*2 +1)*wrap;
2328
            int motion_x, motion_y, dir, i;
2329
            if(field_pic && !s->first_field)
2330
                xy += wrap/2;
2331

    
2332
            for(i=0; i<2; i++){
2333
                for(dir=0; dir<2; dir++){
2334
                    if (s->mb_intra || (dir==1 && s->pict_type != B_TYPE)) {
2335
                        motion_x = motion_y = 0;
2336
                    }else if (s->mv_type == MV_TYPE_16X16){
2337
                        motion_x = s->mv[dir][0][0];
2338
                        motion_y = s->mv[dir][0][1];
2339
                    } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ {
2340
                        motion_x = s->mv[dir][i][0];
2341
                        motion_y = s->mv[dir][i][1];
2342
                    }
2343
                    
2344
                    s->current_picture.motion_val[dir][xy    ][0] = motion_x;
2345
                    s->current_picture.motion_val[dir][xy    ][1] = motion_y;
2346
                    s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
2347
                    s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
2348
                }
2349
                xy += wrap;
2350
            }
2351
        }
2352

    
2353
        s->dest[0] += 16;
2354
        s->dest[1] += 8;
2355
        s->dest[2] += 8;
2356

    
2357
        MPV_decode_mb(s, s->block);
2358
        
2359
        if (++s->mb_x >= s->mb_width) {
2360

    
2361
            ff_draw_horiz_band(s, 16*s->mb_y, 16);
2362

    
2363
            s->mb_x = 0;
2364
            s->mb_y++;
2365

    
2366
            if(s->mb_y<<field_pic >= s->mb_height){
2367
                int left= s->gb.size_in_bits - get_bits_count(&s->gb);
2368

    
2369
                if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)))
2370
                   || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
2371
                    av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d\n", left);
2372
                    return -1;
2373
                }else
2374
                    goto eos;
2375
            }
2376
            
2377
            ff_init_block_index(s);
2378
        }
2379

    
2380
        /* skip mb handling */
2381
        if (s->mb_skip_run == -1) {
2382
            /* read again increment */
2383
            s->mb_skip_run = 0;
2384
            for(;;) {
2385
                int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
2386
                if (code < 0){
2387
                    av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
2388
                    return -1;
2389
                }
2390
                if (code >= 33) {
2391
                    if (code == 33) {
2392
                        s->mb_skip_run += 33;
2393
                    }else if(code == 35){
2394
                        if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
2395
                            av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
2396
                            return -1;
2397
                        }
2398
                        goto eos; /* end of slice */
2399
                    }
2400
                    /* otherwise, stuffing, nothing to do */
2401
                } else {
2402
                    s->mb_skip_run += code;
2403
                    break;
2404
                }
2405
            }
2406
        }
2407
    }
2408
eos: // end of slice
2409
    *buf += get_bits_count(&s->gb)/8 - 1;
2410
//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
2411
    return 0;
2412
}
2413

    
2414
static int slice_decode_thread(AVCodecContext *c, void *arg){
2415
    MpegEncContext *s= arg;
2416
    const uint8_t *buf= s->gb.buffer;
2417
    int mb_y= s->start_mb_y;
2418

    
2419
    s->error_count= 3*(s->end_mb_y - s->start_mb_y)*s->mb_width;
2420

    
2421
    for(;;){
2422
        int start_code, ret;
2423

    
2424
        ret= mpeg_decode_slice((Mpeg1Context*)s, mb_y, &buf, s->gb.buffer_end - buf);
2425
        emms_c();
2426
//av_log(c, AV_LOG_DEBUG, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n", 
2427
//ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, s->start_mb_y, s->end_mb_y, s->error_count);
2428
        if(ret < 0){
2429
            if(s->resync_mb_x>=0 && s->resync_mb_y>=0)
2430
                ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, AC_ERROR|DC_ERROR|MV_ERROR);
2431
        }else{
2432
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
2433
        }
2434
        
2435
        if(s->mb_y == s->end_mb_y)
2436
            return 0;
2437
        
2438
        start_code = find_start_code(&buf, s->gb.buffer_end);
2439
        mb_y= start_code - SLICE_MIN_START_CODE;
2440
        if(mb_y < 0 || mb_y >= s->end_mb_y)
2441
            return -1;
2442
    }
2443
    
2444
    return 0; //not reached
2445
}
2446

    
2447
/**
2448
 * handles slice ends.
2449
 * @return 1 if it seems to be the last slice of 
2450
 */
2451
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2452
{
2453
    Mpeg1Context *s1 = avctx->priv_data;
2454
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2455
       
2456
    if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2457
        return 0;
2458

    
2459
#ifdef HAVE_XVMC
2460
    if(s->avctx->xvmc_acceleration)
2461
        XVMC_field_end(s);
2462
#endif
2463
    /* end of slice reached */
2464
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
2465
        /* end of image */
2466

    
2467
        s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
2468

    
2469
        ff_er_frame_end(s);
2470

    
2471
        MPV_frame_end(s);
2472

    
2473
        if (s->pict_type == B_TYPE || s->low_delay) {
2474
            *pict= *(AVFrame*)s->current_picture_ptr;
2475
            ff_print_debug_info(s, pict);
2476
        } else {
2477
            s->picture_number++;
2478
            /* latency of 1 frame for I and P frames */
2479
            /* XXX: use another variable than picture_number */
2480
            if (s->last_picture_ptr != NULL) {
2481
                *pict= *(AVFrame*)s->last_picture_ptr;
2482
                 ff_print_debug_info(s, pict);
2483
            }
2484
        }
2485

    
2486
        return 1;
2487
    } else {
2488
        return 0;
2489
    }
2490
}
2491

    
2492
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
2493
                                 const uint8_t *buf, int buf_size)
2494
{
2495
    Mpeg1Context *s1 = avctx->priv_data;
2496
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2497
    int width,height;
2498
    int i, v, j;
2499

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

    
2502
    width = get_bits(&s->gb, 12);
2503
    height = get_bits(&s->gb, 12);
2504
    if (width <= 0 || height <= 0 ||
2505
        (width % 2) != 0 || (height % 2) != 0)
2506
        return -1;
2507
    s->aspect_ratio_info= get_bits(&s->gb, 4);
2508
    if (s->aspect_ratio_info == 0)
2509
        return -1;
2510
    s->frame_rate_index = get_bits(&s->gb, 4);
2511
    if (s->frame_rate_index == 0 || s->frame_rate_index > 13)
2512
        return -1;
2513
    s->bit_rate = get_bits(&s->gb, 18) * 400;
2514
    if (get_bits1(&s->gb) == 0) /* marker */
2515
        return -1;
2516
    s->width = width;
2517
    s->height = height;
2518

    
2519
    s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16;
2520
    skip_bits(&s->gb, 1);
2521

    
2522
    /* get matrix */
2523
    if (get_bits1(&s->gb)) {
2524
        for(i=0;i<64;i++) {
2525
            v = get_bits(&s->gb, 8);
2526
            if(v==0){
2527
                av_log(s->avctx, AV_LOG_ERROR, "intra matrix damaged\n");
2528
                return -1;
2529
            }
2530
            j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2531
            s->intra_matrix[j] = v;
2532
            s->chroma_intra_matrix[j] = v;
2533
        }
2534
#ifdef DEBUG
2535
        dprintf("intra matrix present\n");
2536
        for(i=0;i<64;i++)
2537
            dprintf(" %d", s->intra_matrix[s->dsp.idct_permutation[i]);
2538
        printf("\n");
2539
#endif
2540
    } else {
2541
        for(i=0;i<64;i++) {
2542
            j = s->dsp.idct_permutation[i];
2543
            v = ff_mpeg1_default_intra_matrix[i];
2544
            s->intra_matrix[j] = v;
2545
            s->chroma_intra_matrix[j] = v;
2546
        }
2547
    }
2548
    if (get_bits1(&s->gb)) {
2549
        for(i=0;i<64;i++) {
2550
            v = get_bits(&s->gb, 8);
2551
            if(v==0){
2552
                av_log(s->avctx, AV_LOG_ERROR, "inter matrix damaged\n");
2553
                return -1;
2554
            }
2555
            j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2556
            s->inter_matrix[j] = v;
2557
            s->chroma_inter_matrix[j] = v;
2558
        }
2559
#ifdef DEBUG
2560
        dprintf("non intra matrix present\n");
2561
        for(i=0;i<64;i++)
2562
            dprintf(" %d", s->inter_matrix[s->dsp.idct_permutation[i]);
2563
        printf("\n");
2564
#endif
2565
    } else {
2566
        for(i=0;i<64;i++) {
2567
            int j= s->dsp.idct_permutation[i];
2568
            v = ff_mpeg1_default_non_intra_matrix[i];
2569
            s->inter_matrix[j] = v;
2570
            s->chroma_inter_matrix[j] = v;
2571
        }
2572
    }
2573
    
2574
    if(show_bits(&s->gb, 23) != 0){
2575
        av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2576
        return -1;
2577
    }
2578

    
2579
    /* we set mpeg2 parameters so that it emulates mpeg1 */
2580
    s->progressive_sequence = 1;
2581
    s->progressive_frame = 1;
2582
    s->picture_structure = PICT_FRAME;
2583
    s->frame_pred_frame_dct = 1;
2584
    s->chroma_format = 1;
2585
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO;
2586
    avctx->sub_id = 1; /* indicates mpeg1 */
2587
    s->out_format = FMT_MPEG1;
2588
    s->swap_uv = 0;//AFAIK VCR2 don't have SEQ_HEADER
2589
    if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
2590
    
2591
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2592
        av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n", 
2593
               s->avctx->rc_buffer_size, s->bit_rate);
2594
    
2595
    return 0;
2596
}
2597

    
2598
static int vcr2_init_sequence(AVCodecContext *avctx)
2599
{
2600
    Mpeg1Context *s1 = avctx->priv_data;
2601
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2602
    int i, v;
2603

    
2604
    /* start new mpeg1 context decoding */
2605
    s->out_format = FMT_MPEG1;
2606
    if (s1->mpeg_enc_ctx_allocated) {
2607
        MPV_common_end(s);
2608
    }
2609
    s->width = avctx->width;
2610
    s->height = avctx->height;
2611
    avctx->has_b_frames= 0; //true?
2612
    s->low_delay= 1;
2613

    
2614
    if(avctx->xvmc_acceleration){
2615
        avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
2616
    }else{
2617
        avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420);
2618
    }
2619

    
2620
    if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2621
        if( avctx->idct_algo == FF_IDCT_AUTO )
2622
            avctx->idct_algo = FF_IDCT_SIMPLE;
2623
    
2624
    if (MPV_common_init(s) < 0)
2625
        return -1;
2626
    exchange_uv(s);//common init reset pblocks, so we swap them here
2627
    s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB 
2628
    s1->mpeg_enc_ctx_allocated = 1;
2629

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

    
2636
        v = ff_mpeg1_default_non_intra_matrix[i];
2637
        s->inter_matrix[j] = v;
2638
        s->chroma_inter_matrix[j] = v;
2639
    }
2640

    
2641
    s->progressive_sequence = 1;
2642
    s->progressive_frame = 1;
2643
    s->picture_structure = PICT_FRAME;
2644
    s->frame_pred_frame_dct = 1;
2645
    s->chroma_format = 1;
2646
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2647
    avctx->sub_id = 2; /* indicates mpeg2 */
2648
    return 0;
2649
}
2650

    
2651

    
2652
static void mpeg_decode_user_data(AVCodecContext *avctx, 
2653
                                  const uint8_t *buf, int buf_size)
2654
{
2655
    const uint8_t *p;
2656
    int len, flags;
2657
    p = buf;
2658
    len = buf_size;
2659

    
2660
    /* we parse the DTG active format information */
2661
    if (len >= 5 &&
2662
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2663
        flags = p[4];
2664
        p += 5;
2665
        len -= 5;
2666
        if (flags & 0x80) {
2667
            /* skip event id */
2668
            if (len < 2)
2669
                return;
2670
            p += 2;
2671
            len -= 2;
2672
        }
2673
        if (flags & 0x40) {
2674
            if (len < 1)
2675
                return;
2676
            avctx->dtg_active_format = p[0] & 0x0f;
2677
        }
2678
    }
2679
}
2680

    
2681
static void mpeg_decode_gop(AVCodecContext *avctx, 
2682
                            const uint8_t *buf, int buf_size){
2683
    Mpeg1Context *s1 = avctx->priv_data;
2684
    MpegEncContext *s = &s1->mpeg_enc_ctx;
2685

    
2686
    int drop_frame_flag;
2687
    int time_code_hours, time_code_minutes;
2688
    int time_code_seconds, time_code_pictures;
2689
    int broken_link;
2690

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

    
2693
    drop_frame_flag = get_bits1(&s->gb);
2694
    
2695
    time_code_hours=get_bits(&s->gb,5);
2696
    time_code_minutes = get_bits(&s->gb,6);
2697
    skip_bits1(&s->gb);//marker bit
2698
    time_code_seconds = get_bits(&s->gb,6);
2699
    time_code_pictures = get_bits(&s->gb,6);
2700

    
2701
    /*broken_link indicate that after editing the
2702
      reference frames of the first B-Frames after GOP I-Frame
2703
      are missing (open gop)*/
2704
    broken_link = get_bits1(&s->gb);
2705

    
2706
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2707
        av_log(s->avctx, AV_LOG_DEBUG, "GOP (%2d:%02d:%02d.[%02d]) broken_link=%d\n",
2708
            time_code_hours, time_code_minutes, time_code_seconds,
2709
            time_code_pictures, broken_link);
2710
}
2711
/**
2712
 * finds the end of the current frame in the bitstream.
2713
 * @return the position of the first byte of the next frame, or -1
2714
 */
2715
static int mpeg1_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
2716
    ParseContext *pc= &s->parse_context;
2717
    int i;
2718
    uint32_t state;
2719
    
2720
    state= pc->state;
2721
    
2722
    i=0;
2723
    if(!pc->frame_start_found){
2724
        for(i=0; i<buf_size; i++){
2725
            state= (state<<8) | buf[i];
2726
            if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2727
                i++;
2728
                pc->frame_start_found=1;
2729
                break;
2730
            }
2731
        }
2732
    }
2733
    
2734
    if(pc->frame_start_found){
2735
        for(; i<buf_size; i++){
2736
            state= (state<<8) | buf[i];
2737
            if((state&0xFFFFFF00) == 0x100){
2738
                if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2739
                    pc->frame_start_found=0;
2740
                    pc->state=-1; 
2741
                    return i-3;
2742
                }
2743
            }
2744
        }
2745
    }        
2746
    pc->state= state;
2747
    return END_NOT_FOUND;
2748
}
2749

    
2750
/* handle buffering and image synchronisation */
2751
static int mpeg_decode_frame(AVCodecContext *avctx, 
2752
                             void *data, int *data_size,
2753
                             uint8_t *buf, int buf_size)
2754
{
2755
    Mpeg1Context *s = avctx->priv_data;
2756
    const uint8_t *buf_end;
2757
    const uint8_t *buf_ptr;
2758
    int ret, start_code, input_size;
2759
    AVFrame *picture = data;
2760
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2761
    dprintf("fill_buffer\n");
2762

    
2763
    *data_size = 0;
2764

    
2765
    /* special case for last picture */
2766
    if (buf_size == 0 && s2->low_delay==0 && s2->next_picture_ptr) {
2767
        *picture= *(AVFrame*)s2->next_picture_ptr;
2768
        s2->next_picture_ptr= NULL;
2769

    
2770
        *data_size = sizeof(AVFrame);
2771
        return 0;
2772
    }
2773

    
2774
    if(s2->flags&CODEC_FLAG_TRUNCATED){
2775
        int next= mpeg1_find_frame_end(s2, buf, buf_size);
2776
        
2777
        if( ff_combine_frame(s2, next, &buf, &buf_size) < 0 )
2778
            return buf_size;
2779
    }    
2780
    
2781
    buf_ptr = buf;
2782
    buf_end = buf + buf_size;
2783

    
2784
#if 0    
2785
    if (s->repeat_field % 2 == 1) { 
2786
        s->repeat_field++;
2787
        //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2788
        //        s2->picture_number, s->repeat_field);
2789
        if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2790
            *data_size = sizeof(AVPicture);
2791
            goto the_end;
2792
        }
2793
    }
2794
#endif
2795

    
2796
    if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2"))
2797
        vcr2_init_sequence(avctx);
2798
    
2799
    s->slice_count= 0;
2800
        
2801
    for(;;) {
2802
        /* find start next code */
2803
        start_code = find_start_code(&buf_ptr, buf_end);
2804
        if (start_code < 0){
2805
            if(s2->pict_type != B_TYPE || avctx->hurry_up==0){
2806
                if(avctx->thread_count > 1){
2807
                    int i;
2808

    
2809
                    avctx->execute(avctx, slice_decode_thread,  (void**)&(s2->thread_context[0]), NULL, s->slice_count);
2810
                    for(i=0; i<s->slice_count; i++)
2811
                        s2->error_count += s2->thread_context[i]->error_count;
2812
                }
2813
                if (slice_end(avctx, picture)) {
2814
                    if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
2815
                        *data_size = sizeof(AVPicture);
2816
                }
2817
            }
2818
            return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2819
        }
2820
        
2821
        input_size = buf_end - buf_ptr;
2822

    
2823
        if(avctx->debug & FF_DEBUG_STARTCODE){
2824
            av_log(avctx, AV_LOG_DEBUG, "%3X at %d left %d\n", start_code, buf_ptr-buf, input_size);
2825
        }
2826

    
2827
                /* prepare data for next start code */
2828
                switch(start_code) {
2829
                case SEQ_START_CODE:
2830
                    mpeg1_decode_sequence(avctx, buf_ptr, 
2831
                                          input_size);
2832
                    break;
2833
                            
2834
                case PICTURE_START_CODE:
2835
                    /* we have a complete image : we try to decompress it */
2836
                    mpeg1_decode_picture(avctx, 
2837
                                         buf_ptr, input_size);
2838
                    break;
2839
                case EXT_START_CODE:
2840
                    mpeg_decode_extension(avctx,
2841
                                          buf_ptr, input_size);
2842
                    break;
2843
                case USER_START_CODE:
2844
                    mpeg_decode_user_data(avctx, 
2845
                                          buf_ptr, input_size);
2846
                    break;
2847
                case GOP_START_CODE:
2848
                    s2->first_field=0;
2849
                    mpeg_decode_gop(avctx, 
2850
                                          buf_ptr, input_size);
2851
                    break;
2852
                default:
2853
                    if (start_code >= SLICE_MIN_START_CODE &&
2854
                        start_code <= SLICE_MAX_START_CODE) {
2855
                        int mb_y= start_code - SLICE_MIN_START_CODE;
2856
                        
2857
                        /* skip b frames if we dont have reference frames */
2858
                        if(s2->last_picture_ptr==NULL && s2->pict_type==B_TYPE) break;
2859
                        /* skip b frames if we are in a hurry */
2860
                        if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
2861
                        /* skip everything if we are in a hurry>=5 */
2862
                        if(avctx->hurry_up>=5) break;
2863
                        
2864
                        if (!s->mpeg_enc_ctx_allocated) break;
2865
                        
2866
                        if(s2->first_slice){
2867
                            s2->first_slice=0;
2868
                            if(mpeg_field_start(s2) < 0)
2869
                                return -1;
2870
                        }
2871
                        
2872
                        if(avctx->thread_count > 1){
2873
                            int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count;
2874
                            if(threshold <= mb_y){
2875
                                MpegEncContext *thread_context= s2->thread_context[s->slice_count];
2876
                                
2877
                                thread_context->start_mb_y= mb_y;
2878
                                thread_context->end_mb_y  = s2->mb_height;
2879
                                if(s->slice_count){
2880
                                    s2->thread_context[s->slice_count-1]->end_mb_y= mb_y;
2881
                                    ff_update_duplicate_context(thread_context, s2);
2882
                                }
2883
                                init_get_bits(&thread_context->gb, buf_ptr, input_size*8);
2884
                                s->slice_count++;
2885
                            }
2886
                            buf_ptr += 2; //FIXME add minimum num of bytes per slice
2887
                        }else{
2888
                            ret = mpeg_decode_slice(s, mb_y, &buf_ptr, input_size);
2889
                            emms_c();
2890

    
2891
                            if(ret < 0){
2892
                                if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2893
                                    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);
2894
                            }else{
2895
                                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);
2896
                            }
2897
                        }
2898
                    }
2899
                    break;
2900
                }
2901
    }
2902
}
2903

    
2904
static int mpeg_decode_end(AVCodecContext *avctx)
2905
{
2906
    Mpeg1Context *s = avctx->priv_data;
2907

    
2908
    if (s->mpeg_enc_ctx_allocated)
2909
        MPV_common_end(&s->mpeg_enc_ctx);
2910
    return 0;
2911
}
2912

    
2913
AVCodec mpeg1video_decoder = {
2914
    "mpeg1video",
2915
    CODEC_TYPE_VIDEO,
2916
    CODEC_ID_MPEG1VIDEO,
2917
    sizeof(Mpeg1Context),
2918
    mpeg_decode_init,
2919
    NULL,
2920
    mpeg_decode_end,
2921
    mpeg_decode_frame,
2922
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2923
    .flush= ff_mpeg_flush,
2924
};
2925

    
2926
AVCodec mpeg2video_decoder = {
2927
    "mpeg2video",
2928
    CODEC_TYPE_VIDEO,
2929
    CODEC_ID_MPEG2VIDEO,
2930
    sizeof(Mpeg1Context),
2931
    mpeg_decode_init,
2932
    NULL,
2933
    mpeg_decode_end,
2934
    mpeg_decode_frame,
2935
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2936
    .flush= ff_mpeg_flush,
2937
};
2938

    
2939
//legacy decoder
2940
AVCodec mpegvideo_decoder = {
2941
    "mpegvideo",
2942
    CODEC_TYPE_VIDEO,
2943
    CODEC_ID_MPEG2VIDEO,
2944
    sizeof(Mpeg1Context),
2945
    mpeg_decode_init,
2946
    NULL,
2947
    mpeg_decode_end,
2948
    mpeg_decode_frame,
2949
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2950
    .flush= ff_mpeg_flush,
2951
};
2952

    
2953
#ifdef CONFIG_ENCODERS
2954

    
2955
AVCodec mpeg1video_encoder = {
2956
    "mpeg1video",
2957
    CODEC_TYPE_VIDEO,
2958
    CODEC_ID_MPEG1VIDEO,
2959
    sizeof(MpegEncContext),
2960
    encode_init,
2961
    MPV_encode_picture,
2962
    MPV_encode_end,
2963
    .supported_framerates= frame_rate_tab+1,
2964
};
2965

    
2966
#ifdef CONFIG_RISKY
2967

    
2968
AVCodec mpeg2video_encoder = {
2969
    "mpeg2video",
2970
    CODEC_TYPE_VIDEO,
2971
    CODEC_ID_MPEG2VIDEO,
2972
    sizeof(MpegEncContext),
2973
    encode_init,
2974
    MPV_encode_picture,
2975
    MPV_encode_end,
2976
    .supported_framerates= frame_rate_tab+1,
2977
};
2978
#endif
2979
#endif
2980

    
2981
#ifdef HAVE_XVMC
2982
static int mpeg_mc_decode_init(AVCodecContext *avctx){
2983
    Mpeg1Context *s;
2984

    
2985
    if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
2986
        return -1;
2987
    if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){
2988
        dprintf("mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2989
    }
2990
    mpeg_decode_init(avctx);
2991
    s = avctx->priv_data;
2992

    
2993
    avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
2994
    avctx->xvmc_acceleration = 2;//2 - the blocks are packed!
2995

    
2996
    return 0;
2997
}
2998

    
2999
AVCodec mpeg_xvmc_decoder = {
3000
    "mpegvideo_xvmc",
3001
    CODEC_TYPE_VIDEO,
3002
    CODEC_ID_MPEG2VIDEO_XVMC,
3003
    sizeof(Mpeg1Context),
3004
    mpeg_mc_decode_init,
3005
    NULL,
3006
    mpeg_decode_end,
3007
    mpeg_decode_frame,
3008
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL,
3009
    .flush= ff_mpeg_flush,
3010
};
3011

    
3012
#endif
3013

    
3014
/* this is ugly i know, but the alternative is too make 
3015
   hundreds of vars global and prefix them with ff_mpeg1_
3016
   which is far uglier. */
3017
#include "mdec.c"